Scoring AI Influence in Jekyll Posts with Local LLMs

ai_analysis:
  ai_style_score: 72
  confidence: 0.88
  signals:
    list_density: medium
    repetition: low
    tone_uniformity: high
    structure_regularity: high
    instructional_style: medium
  summary: "The content shows consistent tone and structured formatting with moderate instructional patterns, suggesting partial AI assistance."

import requests
import json

def analyze_with_llm(content):
    prompt = """
You are analyzing a blog post for AI-style writing patterns.

Evaluate the following content and return ONLY valid JSON with this schema:
{
  "ai_style_score": int (0-100),
  "confidence": float (0-1),
  "signals": {
    "list_density": "low|medium|high",
    "repetition": "low|medium|high",
    "tone_uniformity": "low|medium|high",
    "structure_regularity": "low|medium|high",
    "instructional_style": "low|medium|high"
  },
  "summary": "short explanation"
}

Scoring guidance:
- High repetition, rigid structure, and uniform tone increase AI score
- Natural variation, uneven structure, and unique phrasing decrease AI score

Content:
\"\"\"{}\"\"\"
""".format(content[:8000])  # truncate to avoid context overflow

    response = requests.post(
        "http://127.0.0.1:11434/api/generate",
        json={
            "model": "llama3.1:latest",
            "prompt": prompt,
            "stream": False
        },
        timeout=60
    )

    result = response.json()

    # Ensure strict JSON parsing
    try:
        return json.loads(result.get("response", "{}"))
    except json.JSONDecodeError:
        return {
            "ai_style_score": 0,
            "confidence": 0.0,
            "signals": {},
            "summary": "Failed to parse model response"
        }

	import requests
	import frontmatter
	import json
	import shutil
	import os
	import re
	import datetime
	
	OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
	MODEL = "llama3.1:latest"
	
	
	def get_file_path():
		path = input("Enter full path to markdown file: ").strip()
	
		if not os.path.isfile(path):
			print("❌ File not found.")
			exit(1)
	
		if not path.endswith(".md"):
			print("❌ File must be a .md file.")
			exit(1)
	
		return path
	
	
	# -----------------------------
	# Deterministic Signal Detection
	# -----------------------------
	
	def detect_emoji_usage(text):
		emoji_pattern = re.compile(
		"[\U0001F300-\U0001FAFF]+", flags=re.UNICODE
		)
		return min(1.0, len(emoji_pattern.findall(text)) / 10.0)
	
	
	def detect_list_density(text):
		lines = text.split("\n")
		list_lines = sum(
			1 for l in lines if l.strip().startswith(("-", "*", "1.", "2.", "3."))
		)
		return min(1.0, list_lines / len(lines)) if lines else 0.0
	
	
	def detect_instructional_density(text):
		keywords = [
			"step", "steps", "first", "next", "then", "finally",
			"follow", "you can", "make sure", "ensure", "click",
			"open", "go to", "select"
		]
	
		lower = text.lower()
		count = sum(lower.count(k) for k in keywords)
	
		return min(1.0, count / 60.0)
	
	
	# -----------------------------
	# Temporal Intelligence
	# -----------------------------
	
	def extract_date_from_filename(path):
		filename = os.path.basename(path)
		match = re.match(r"(\d{4})-(\d{2})-(\d{2})", filename)
	
		if match:
			try:
				y, m, d = map(int, match.groups())
				return datetime.date(y, m, d)
			except ValueError:
				print(f"⚠️ Invalid date in filename: {filename}")
				return None
	
		return None
	
	
	def temporal_factor(date):
		if not date:
			return 1.0
	
		cutoff = datetime.date(2022, 11, 30)
		return 0.2 if date < cutoff else 1.0
	
	
	def classify_era(date):
		if not date:
			return "unknown"
	
		cutoff = datetime.date(2022, 11, 30)
		return "pre-ai" if date < cutoff else "ai-era"
	
	
	# -----------------------------
	# LLM Analysis
	# -----------------------------
	
	def analyze_with_ollama(content):
		content = content[:8000]
	
		prompt = f"""
	Return ONLY JSON.
	
		&#123;&#123;
		  "signals": &#123;&#123;
		"repetition": number,
		"tone_uniformity": number,
		"structure_regularity": number
	  }},
	  "summary": string
	}}
	
	Rules:
	- Conservative scoring
	- Do not assume AI authorship
	- Do not estimate emojis, lists, or instructions
	
	Content:
	---
	{content}
	---
	"""
	
		response = requests.post(
			OLLAMA_URL,
			json={
				"model": MODEL,
				"prompt": prompt,
				"stream": False,
				"options": {"temperature": 0}
			}
		)
	
		if response.status_code != 200:
			print("❌ Ollama request failed")
			print(response.text)
			return None
	
		raw = response.json().get("response", "").strip()
	
		print("\n--- RAW MODEL OUTPUT ---\n")
		print(raw)
		print("\n------------------------\n")
	
		try:
			return json.loads(raw)
		except:
			cleaned = raw.replace("```json", "").replace("```", "").strip()
			try:
				return json.loads(cleaned)
			except:
				print("❌ JSON parsing failed.")
				return None
	
	
	# -----------------------------
	# Scoring
	# -----------------------------
	
	def clamp(v):
		return max(0.0, min(1.0, float(v)))
	
	
	def soften(v):
		return max(0.0, min(1.0, round(v * 0.65, 2)))
	
	
	def compute_score(signals, date):
		weights = {
			"list_density": 0.35,
			"instructional_density": 0.25,
			"repetition": 0.15,
			"tone_uniformity": 0.1,
			"structure_regularity": 0.1,
			"emoji_usage": 0.05
		}
	
		base = sum(signals.get(k, 0) * weights[k] for k in weights)
	
		if date and date < datetime.date(2022, 11, 30):
			base *= 0.2
	
		return round(base, 2)
	
	
	def validate_and_merge(result, content, date):
		try:
			signals = result.get("signals", {})
	
			# LLM signals
			for k in signals:
				signals[k] = soften(clamp(signals[k]))
	
			# Deterministic signals
			signals["emoji_usage"] = detect_emoji_usage(content)
			signals["list_density"] = detect_list_density(content)
			signals["instructional_density"] = detect_instructional_density(content)
	
			score = compute_score(signals, date)
	
			return {
				"ai_style_score": score,
				"confidence": "medium",
				"era": classify_era(date),
				"signals": signals,
				"summary": result.get("summary", "")
			}
	
		except Exception as e:
			print("❌ Validation failed:", e)
			return None
	
	
	# -----------------------------
	# File Handling
	# -----------------------------
	
	def backup_file(path):
		backup_path = path + ".bak"
		shutil.copy(path, backup_path)
		print(f"🗂 Backup created: {backup_path}")
	
	
	def update_front_matter(path, analysis):
		post = frontmatter.load(path)
		post["ai_analysis"] = analysis
	
		with open(path, "w") as f:
			f.write(frontmatter.dumps(post))
	
		print("✅ Front matter updated.")
	
	
	# -----------------------------
	# Main
	# -----------------------------
	
	def main():
		path = get_file_path()
	
		backup_file(path)
	
		post = frontmatter.load(path)
	
		if not post.content.strip():
			print("❌ No content found.")
			return
	
		date = extract_date_from_filename(path)
	
		print(f"📅 Detected date: {date}")
		print("🧠 Analyzing content...\n")
	
		result = analyze_with_ollama(post.content)
	
		if not result:
			print("❌ Analysis failed.")
			return
	
		final = validate_and_merge(result, post.content, date)
	
		if not final:
			print("❌ Validation failed.")
			return
	
		print("\n📊 Final Analysis:\n")
		print(json.dumps(final, indent=2))
	
		confirm = input("\nWrite to front matter? (y/n): ").strip().lower()
	
		if confirm == "y":
			update_front_matter(path, final)
		else:
			print("❌ Aborted.")
	
	
	if __name__ == "__main__":
		main()

python3 analyze_post.py path/to/your/post.md

python3 script.py _posts/2026-03-29-Automating\ JAMF\ Pro\ Email\ Notifications\ with\ SendGrid\ \(Smart\ Group\ Driven\ Workflows\).md

📄 Processing single file

🧠 Processing: 2026-03-29-Automating JAMF Pro Email Notifications with SendGrid (Smart Group Driven Workflows).md

📝 Modern device management isn't just about enforcing policies—it's about communicating effectively with users at the right time. In JAMF Pro, Smart Groups give you powerful visibility into device state, but they don't natively solve the problem of proactive, automated user communication. Whether you're trying to prompt users to restart their machines, complete updates, or take action on compliance issues, bridging that gap requires a flexible and scalable notification system.

✅ Saved

✅ Done
jon@Mac-Studio Desktop % python3 analyze_post.py _posts/2026-04-01-scoring-ai-influence-jekyll-posts-local-llms.md 
Enter full path to markdown file: _posts/2026-04-01-scoring-ai-influence-jekyll-posts-local-llms.md 
🗂 Backup created: 2026-04-01-scoring-ai-influence-jekyll-posts-local-llms.md.bak
📅 Detected date: 2026-04-01
🧠 Analyzing content...


--- RAW MODEL OUTPUT ---

```
{
  "signals": {
    "repetition": "high",
    "tone_uniformity": "medium",
    "structure_regularity": "low"
  },
  "summary": "The content shows consistent tone and structured formatting with moderate instructional patterns, suggesting partial AI assistance."
}
```

------------------------

# Batch processing loop (from analyze_batch.py)

import os
import glob

def process_directory(directory, dry_run=True):
    files = glob.glob(os.path.join(directory, "*.md"))

    results = []

    for path in files:
        print(f"\n📄 Processing: {path}")

        try:
            # Call single-file analyzer
            analysis = analyze_post(path)

            if not analysis:
                print("❌ Skipping due to failed analysis.")
                continue

            results.append({
                "path": path,
                "analysis": analysis
            })

            if dry_run:
                print("🧪 Dry run enabled — not writing changes.")
            else:
                write_to_front_matter(path, analysis)

        except Exception as e:
            print(f"⚠️ Error processing {path}: {e}")
            continue

    return results

python3 analyze_batch.py /path/to/your/_posts

python3 analyze_batch.py /path/to/your/_posts --dry-run

import requests
import frontmatter
import json
import os
import re
import datetime
import random

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "llama3.1:latest"

POSTS_DIR = input("Enter path to _posts directory: ").strip()
SAMPLE_SIZE = int(input("How many posts to sample? (e.g. 10): ").strip())


# -----------------------------
# Helpers
# -----------------------------

def extract_date_from_filename(path):
    filename = os.path.basename(path)
    match = re.match(r"(\d{4})-(\d{2})-(\d{2})", filename)

    if match:
        try:
            y, m, d = map(int, match.groups())
            return datetime.date(y, m, d)
        except ValueError:
            print(f"⚠️ Invalid date in filename: {filename}")
            return None

    return None


def classify_bucket(date):
    if not date:
        return "unknown"

    if date < datetime.date(2022, 11, 30):
        return "pre-ai"
    elif date < datetime.date(2024, 1, 1):
        return "early-ai"
    else:
        return "recent-ai"


# -----------------------------
# Deterministic Signals
# -----------------------------

def detect_emoji_usage(text):
    emoji_pattern = re.compile(
    "[\U0001F300-\U0001FAFF]+", flags=re.UNICODE
	)
    return min(1.0, len(emoji_pattern.findall(text)) / 10.0)


def detect_list_density(text):
    lines = text.split("\n")
    list_lines = sum(
        1 for l in lines if l.strip().startswith(("-", "*", "1.", "2.", "3."))
    )
    return min(1.0, list_lines / len(lines)) if lines else 0.0


def detect_instructional_density(text):
    keywords = [
        "step", "steps", "first", "next", "then", "finally",
        "follow", "you can", "make sure", "ensure", "click",
        "open", "go to", "select"
    ]

    lower = text.lower()
    count = sum(lower.count(k) for k in keywords)

    return min(1.0, count / 60.0)


# -----------------------------
# LLM Call
# -----------------------------

def analyze(content):
    content = content[:8000]

    prompt = f"""
Return ONLY JSON.

&#123;&#123;
  "signals": &#123;&#123;
    "repetition": number,
    "tone_uniformity": number,
    "structure_regularity": number
  }}
}}

Rules:
- Conservative scoring
- Do not assume AI authorship
- Do not estimate emojis, lists, or instructions

Content:
---
{content}
---
"""

    r = requests.post(
        OLLAMA_URL,
        json={
            "model": MODEL,
            "prompt": prompt,
            "stream": False,
            "options": {"temperature": 0}
        }
    )

    if r.status_code != 200:
        return None

    raw = r.json().get("response", "").strip()

    try:
        return json.loads(raw)
    except:
        try:
            cleaned = raw.replace("```json", "").replace("```", "").strip()
            return json.loads(cleaned)
        except:
            return None


# -----------------------------
# Scoring
# -----------------------------

def soften(v):
    return max(0.0, min(1.0, v * 0.65))


def compute_score(signals, date):
    weights = {
        "list_density": 0.35,            # ↑ strong signal
        "instructional_density": 0.25,   # ↑ new strong signal
        "repetition": 0.15,
        "tone_uniformity": 0.1,
        "structure_regularity": 0.1,
        "emoji_usage": 0.05
    }

    base = sum(signals.get(k, 0) * weights[k] for k in weights)

    # Temporal adjustment
    if date and date < datetime.date(2022, 11, 30):
        base *= 0.2

    return round(base, 2)


# -----------------------------
# Sampling
# -----------------------------

def collect_posts():
    files = [
        os.path.join(POSTS_DIR, f)
        for f in os.listdir(POSTS_DIR)
        if f.endswith(".md")
    ]

    buckets = {
        "pre-ai": [],
        "early-ai": [],
        "recent-ai": []
    }

    for f in files:
        d = extract_date_from_filename(f)
        bucket = classify_bucket(d)
        if bucket in buckets:
            buckets[bucket].append(f)

    return buckets


def sample_posts(buckets, total):
    per_bucket = max(1, total // 3)

    sample = []
    for bucket in buckets:
        if buckets[bucket]:
            sample += random.sample(
                buckets[bucket],
                min(per_bucket, len(buckets[bucket]))
            )

    return sample


# -----------------------------
# Main
# -----------------------------

def main():
    buckets = collect_posts()
    sample = sample_posts(buckets, SAMPLE_SIZE)

    print("\n📦 Sample selected:\n")
    for f in sample:
        print(f)

    print("\n🧠 Running analysis...\n")

    results = []

    for path in sample:
        post = frontmatter.load(path)
        content = post.content.strip()

        if not content:
            continue

        date = extract_date_from_filename(path)
        bucket = classify_bucket(date)

        llm = analyze(content)

        if not llm:
            print(f"⚠️ Failed: {path}")
            continue

        signals = llm.get("signals", {})

        # soften LLM signals
        for k in signals:
            signals[k] = soften(signals[k])

        # deterministic signals
        signals["emoji_usage"] = detect_emoji_usage(content)
        signals["list_density"] = detect_list_density(content)
        signals["instructional_density"] = detect_instructional_density(content)

        score = compute_score(signals, date)

        result = {
            "file": os.path.basename(path),
            "date": str(date),
            "bucket": bucket,
            "score": score,
            "signals": signals
        }

        results.append(result)

        print(f"\n--- {result['file']} ---")
        print(json.dumps(result, indent=2))

    # -----------------------------
    # Summary
    # -----------------------------
    print("\n📊 SUMMARY\n")

    for bucket in ["pre-ai", "early-ai", "recent-ai"]:
        bucket_scores = [r["score"] for r in results if r["bucket"] == bucket]

        if bucket_scores:
            avg = round(sum(bucket_scores) / len(bucket_scores), 2)
            print(f"{bucket}: avg={avg} ({len(bucket_scores)} posts)")


if __name__ == "__main__":
    main()