Copy Editing

#!/usr/bin/env python3
"""
ai_content_detector.py — Detect AI-generated content patterns.

Three detection methods:
  1. Burstiness analysis — human writing has high variance in sentence length;
     AI writing has consistently medium-length sentences
  2. Vocabulary diversity (Type-Token Ratio) — AI reuses words more than humans
  3. Known AI phrases — specific phrases that appear disproportionately in
     AI-generated text

This is a heuristic tool, NOT a proof engine. False positives are expected.
The goal is to flag passages that FEEL AI-generated so a human editor can
inject voice, variance, and specificity.

Usage:
    python ai_content_detector.py article.md
    python ai_content_detector.py article.md --json
    python ai_content_detector.py --demo

Scoring:
    0-20   = likely human (high burstiness, diverse vocab, no AI phrases)
    21-50  = mixed signals (review flagged passages)
    51-100 = likely AI (flat burstiness, repetitive vocab, AI phrase density)
"""
from __future__ import annotations
import argparse
import json
import math
import re
import sys
from collections import Counter
from pathlib import Path

# --- Known AI phrases (commonly overrepresented in LLM output) ---

AI_PHRASES = [
    "in today's digital landscape",
    "in today's fast-paced",
    "it's worth noting that",
    "it is important to note",
    "delve into",
    "dive deep into",
    "leverage",
    "game-changer",
    "game changer",
    "unlock the potential",
    "unlock the power",
    "harness the power",
    "at the end of the day",
    "in conclusion",
    "in summary",
    "navigating the complexities",
    "a comprehensive guide",
    "seamlessly integrate",
    "robust solution",
    "cutting-edge",
    "state-of-the-art",
    "empower you to",
    "take your .* to the next level",
    "in the realm of",
    "tapestry of",
    "multifaceted",
    "it's crucial to",
    "paramount",
    "foster a .* environment",
    "elevate your",
]

AI_PHRASE_RES = [re.compile(p, re.IGNORECASE) for p in AI_PHRASES]

# --- Sentence splitting ---

SENTENCE_RE = re.compile(r"[^.!?]+[.!?]+", re.DOTALL)
WORD_RE = re.compile(r"[a-zA-Z]+")

DEMO_CONTENT = """In today's digital landscape, leveraging AI tools has become a game-changer for content creators. It's worth noting that the ability to harness the power of large language models can unlock the potential of your marketing efforts. This comprehensive guide will delve into the multifaceted world of AI-assisted content creation.

The integration of AI into content workflows is a robust solution that seamlessly integrates with existing processes. By navigating the complexities of modern content production, you can elevate your brand's voice and foster a creative environment that empowers your team to take their content to the next level.

At the end of the day, it's crucial to understand that AI is a tool, not a replacement. The cutting-edge capabilities of state-of-the-art models are paramount for staying competitive in the realm of digital marketing. In conclusion, the tapestry of modern content creation requires both human creativity and artificial intelligence working in harmony."""


def extract_sentences(text):
    body = re.sub(r"^---.*?---\s*", "", text, count=1, flags=re.DOTALL)
    body = re.sub(r"^#+\s+.*$", "", body, flags=re.MULTILINE)
    body = re.sub(r"```.*?```", "", body, flags=re.DOTALL)
    body = re.sub(r"`[^`]+`", "", body)
    body = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", body)
    sentences = SENTENCE_RE.findall(body)
    return [s.strip() for s in sentences if len(s.strip().split()) >= 3]


def burstiness_score(sentences):
    """Compute burstiness (sentence length variance). High = human, low = AI."""
    if len(sentences) < 5:
        return {"score": 50, "mean": 0, "std": 0, "cv": 0, "note": "too few sentences"}
    lengths = [len(s.split()) for s in sentences]
    mean = sum(lengths) / len(lengths)
    variance = sum((l - mean) ** 2 for l in lengths) / len(lengths)
    std = math.sqrt(variance)
    cv = std / mean if mean > 0 else 0  # coefficient of variation

    # Human writing: CV typically 0.4-0.8+ (high variance)
    # AI writing: CV typically 0.15-0.35 (consistently medium)
    if cv >= 0.5:
        ai_prob = max(0, 30 - (cv - 0.5) * 60)
    elif cv >= 0.35:
        ai_prob = 30 + (0.5 - cv) * 130
    else:
        ai_prob = 50 + (0.35 - cv) * 250

    ai_prob = max(0, min(100, ai_prob))
    return {
        "score": round(ai_prob, 1),
        "mean_sentence_length": round(mean, 1),
        "std_sentence_length": round(std, 1),
        "coefficient_of_variation": round(cv, 3),
        "note": "low CV = flat sentence lengths (AI-like)" if cv < 0.35 else "healthy variance",
    }


def vocabulary_diversity(text):
    """Type-Token Ratio. Low TTR = repetitive vocabulary (AI-like)."""
    body = re.sub(r"^---.*?---\s*", "", text, count=1, flags=re.DOTALL)
    words = [w.lower() for w in WORD_RE.findall(body) if len(w) > 2]
    if len(words) < 50:
        return {"score": 50, "ttr": 0, "unique": 0, "total": len(words), "note": "too few words"}
    # Use a sliding window TTR for length-independence
    window = min(200, len(words))
    ttrs = []
    for i in range(0, len(words) - window + 1, window // 2):
        chunk = words[i : i + window]
        ttrs.append(len(set(chunk)) / len(chunk))
    avg_ttr = sum(ttrs) / len(ttrs)

    # Human: TTR 0.55-0.75+ (varied vocabulary)
    # AI: TTR 0.35-0.50 (repetitive patterns)
    if avg_ttr >= 0.60:
        ai_prob = max(0, 25 - (avg_ttr - 0.60) * 150)
    elif avg_ttr >= 0.45:
        ai_prob = 25 + (0.60 - avg_ttr) * 330
    else:
        ai_prob = 75 + (0.45 - avg_ttr) * 250

    ai_prob = max(0, min(100, ai_prob))

    # Top repeated words (excluding stop words)
    stop = {"the", "and", "for", "that", "this", "with", "from", "are", "was", "were", "been",
            "have", "has", "had", "not", "but", "can", "will", "your", "you", "they", "their",
            "more", "than", "also", "into", "when", "how", "what", "which", "about", "each"}
    content_words = [w for w in words if w not in stop]
    top_repeated = Counter(content_words).most_common(5)

    return {
        "score": round(ai_prob, 1),
        "avg_ttr": round(avg_ttr, 3),
        "unique_words": len(set(words)),
        "total_words": len(words),
        "top_repeated": [{"word": w, "count": c} for w, c in top_repeated],
        "note": "low TTR = repetitive vocabulary (AI-like)" if avg_ttr < 0.45 else "healthy diversity",
    }


def phrase_detection(text):
    """Count known AI phrases."""
    found = []
    text_lower = text.lower()
    for i, pattern in enumerate(AI_PHRASE_RES):
        matches = pattern.findall(text_lower)
        if matches:
            found.append({"phrase": AI_PHRASES[i], "count": len(matches)})

    total_matches = sum(f["count"] for f in found)
    word_count = len(text.split())
    density = (total_matches / (word_count / 1000)) if word_count > 0 else 0

    # 0-2 per 1K words = normal; 3-5 = suspect; 6+ = likely AI
    if density <= 2:
        ai_prob = density * 15
    elif density <= 5:
        ai_prob = 30 + (density - 2) * 20
    else:
        ai_prob = min(100, 90 + (density - 5) * 5)

    return {
        "score": round(ai_prob, 1),
        "phrases_found": len(found),
        "total_matches": total_matches,
        "density_per_1k_words": round(density, 1),
        "matches": found[:10],
        "note": f"{density:.1f} AI phrases per 1K words" if found else "no known AI phrases",
    }


def analyze(text):
    sentences = extract_sentences(text)
    burst = burstiness_score(sentences)
    vocab = vocabulary_diversity(text)
    phrases = phrase_detection(text)

    # Weighted composite: burstiness 35%, vocab 30%, phrases 35%
    composite = burst["score"] * 0.35 + vocab["score"] * 0.30 + phrases["score"] * 0.35
    composite = round(min(100, max(0, composite)), 1)

    if composite <= 20:
        verdict = "LIKELY_HUMAN"
    elif composite <= 50:
        verdict = "MIXED"
    else:
        verdict = "LIKELY_AI"

    return {
        "status": "ok",
        "composite_score": composite,
        "verdict": verdict,
        "burstiness": burst,
        "vocabulary": vocab,
        "phrases": phrases,
        "sentences_analyzed": len(sentences),
        "recommendations": _recommendations(burst, vocab, phrases),
    }


def _recommendations(burst, vocab, phrases):
    recs = []
    if burst["score"] > 40:
        recs.append("Vary sentence lengths: mix short punchy sentences (5-8 words) with longer explanatory ones (20-30 words).")
    if vocab["score"] > 40:
        recs.append("Diversify vocabulary: replace repeated words with synonyms. Use domain-specific jargon where appropriate.")
    if phrases["total_matches"] > 0:
        top = phrases["matches"][:3]
        recs.append(f"Remove/replace AI phrases: {', '.join(p['phrase'] for p in top)}")
    if not recs:
        recs.append("Content reads naturally. No humanization needed.")
    return recs


def main():
    p = argparse.ArgumentParser(
        description="Detect AI-generated content via burstiness, vocabulary diversity, and phrase analysis.",
        epilog="Score 0-20 = likely human, 21-50 = mixed, 51-100 = likely AI. Run with --demo.",
    )
    p.add_argument("file", nargs="?", help="Markdown/text file to analyze")
    p.add_argument("--json", action="store_true", help="JSON output")
    p.add_argument("--demo", action="store_true", help="Run with AI-heavy demo text")
    args = p.parse_args()

    if args.demo:
        text = DEMO_CONTENT
    elif args.file:
        path = Path(args.file)
        if not path.exists():
            print(f"[error] {path} not found", file=sys.stderr)
            sys.exit(1)
        text = path.read_text(encoding="utf-8", errors="replace")
    else:
        p.print_help()
        sys.exit(0)

    result = analyze(text)

    if args.json:
        print(json.dumps(result, indent=2))
        return

    print(f"AI Content Detection — Composite: {result['composite_score']}/100 ({result['verdict']})")
    print()
    b = result["burstiness"]
    print(f"  Burstiness:  {b['score']}/100 — CV={b['coefficient_of_variation']} ({b['note']})")
    v = result["vocabulary"]
    print(f"  Vocabulary:  {v['score']}/100 — TTR={v['avg_ttr']} ({v['note']})")
    ph = result["phrases"]
    print(f"  AI Phrases:  {ph['score']}/100 — {ph['total_matches']} matches, {ph['density_per_1k_words']}/1K words")
    if ph["matches"]:
        for m in ph["matches"][:5]:
            print(f"    → \"{m['phrase']}\" (×{m['count']})")
    print()
    print("Recommendations:")
    for r in result["recommendations"]:
        print(f"  → {r}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
readability_scorer.py — Readability metrics for marketing copy
Usage:
  python3 readability_scorer.py --file copy.txt
  echo "Your text here" | python3 readability_scorer.py
  python3 readability_scorer.py          # demo mode
  python3 readability_scorer.py --json
"""

import argparse
import json
import math
import re
import sys


# ---------------------------------------------------------------------------
# Word lists
# ---------------------------------------------------------------------------

FILLER_WORDS = [
    "very", "really", "just", "actually", "basically", "literally",
    "honestly", "totally", "absolutely", "definitely", "certainly",
    "obviously", "clearly", "quite", "rather", "somewhat", "fairly",
    "pretty", "simply", "truly", "genuinely", "essentially",
]

# Simple passive voice detection: "was/were/is/are/been/being + past participle"
PASSIVE_PATTERN = re.compile(
    r"\b(was|were|is|are|been|being|be|am)\s+(\w+ed|known|written|built|made|done|seen|given|taken|brought|thought|found|put|set|cut|read|let|hit|hurt|cost|led|felt|kept|left|meant|sent|spent|stood|told|wore|won|beat|lost|broke|chose|drove|flew|froze|grew|hid|rang|rode|rose|ran|sank|sang|spoke|swore|swam|threw|woke|wrote)\b",
    re.IGNORECASE,
)

ADVERB_PATTERN = re.compile(r"\b\w+ly\b", re.IGNORECASE)

# Syllable estimation: count vowel groups
def count_syllables(word: str) -> int:
    word = word.lower().strip(".,!?;:\"'")
    if not word:
        return 0
    # Silent e
    if word.endswith("e") and len(word) > 2:
        word = word[:-1]
    count = len(re.findall(r"[aeiou]+", word))
    return max(1, count)


def split_sentences(text: str) -> list:
    # Split on sentence-ending punctuation
    parts = re.split(r"(?<=[.!?])\s+", text.strip())
    return [p.strip() for p in parts if p.strip()]


def split_words(text: str) -> list:
    return re.findall(r"\b[a-zA-Z]+\b", text)


# ---------------------------------------------------------------------------
# Metrics
# ---------------------------------------------------------------------------

def flesch_reading_ease(avg_sentence_len: float, avg_syllables: float) -> float:
    """Flesch Reading Ease formula."""
    score = 206.835 - (1.015 * avg_sentence_len) - (84.6 * avg_syllables)
    return round(max(0.0, min(100.0, score)), 1)


def flesch_kincaid_grade(avg_sentence_len: float, avg_syllables: float) -> float:
    """Flesch-Kincaid Grade Level formula."""
    grade = (0.39 * avg_sentence_len) + (11.8 * avg_syllables) - 15.59
    return round(max(0.0, grade), 1)


def ease_label(score: float) -> str:
    if score >= 90: return "Very Easy (5th grade)"
    if score >= 80: return "Easy (6th grade)"
    if score >= 70: return "Fairly Easy (7th grade)"
    if score >= 60: return "Standard (8-9th grade)"
    if score >= 50: return "Fairly Difficult (10-12th grade)"
    if score >= 30: return "Difficult (College)"
    return "Very Confusing (Professional)"


def analyze_text(text: str) -> dict:
    sentences = split_sentences(text)
    words = split_words(text)

    if not words:
        return {"error": "No readable text found."}

    num_sentences = max(1, len(sentences))
    num_words = len(words)

    # Syllables
    syllable_counts = [count_syllables(w) for w in words]
    total_syllables = sum(syllable_counts)

    avg_sentence_len = num_words / num_sentences
    avg_word_len = sum(len(w) for w in words) / num_words
    avg_syllables_per_word = total_syllables / num_words

    fre = flesch_reading_ease(avg_sentence_len, avg_syllables_per_word)
    fk_grade = flesch_kincaid_grade(avg_sentence_len, avg_syllables_per_word)

    # Passive voice
    passive_matches = PASSIVE_PATTERN.findall(text)
    passive_count = len(passive_matches)
    passive_pct = round(passive_count / num_sentences * 100, 1)

    # Adverbs
    adverb_matches = ADVERB_PATTERN.findall(text)
    # Filter obvious non-adverbs
    non_adverb = {"family", "early", "only", "likely", "nearly", "really",
                  "daily", "weekly", "monthly", "yearly", "friendly", "lovely",
                  "lonely", "lively", "elderly", "costly"}
    adverbs = [a for a in adverb_matches if a.lower() not in non_adverb]
    adverb_density = round(len(adverbs) / num_words * 100, 1)

    # Filler words
    text_lower = text.lower()
    word_tokens_lower = [w.lower() for w in words]
    filler_found = {fw: word_tokens_lower.count(fw) for fw in FILLER_WORDS if fw in word_tokens_lower}
    filler_total = sum(filler_found.values())

    # Scoring:
    # FRE already 0-100 (higher = easier = better for marketing copy)
    # Target for marketing: 60-80 range
    fre_score = fre  # use as-is

    return {
        "stats": {
            "word_count": num_words,
            "sentence_count": num_sentences,
            "avg_sentence_length": round(avg_sentence_len, 1),
            "avg_word_length": round(avg_word_len, 1),
            "avg_syllables_per_word": round(avg_syllables_per_word, 2),
        },
        "flesch_reading_ease": {
            "score": fre,
            "label": ease_label(fre),
            "target": "60-80 for most marketing copy",
        },
        "flesch_kincaid_grade": {
            "grade_level": fk_grade,
            "note": f"Equivalent to grade {fk_grade} reading level",
        },
        "passive_voice": {
            "count": passive_count,
            "percentage": passive_pct,
            "target": "<10%",
            "pass": passive_pct < 10,
        },
        "adverb_density": {
            "count": len(adverbs),
            "percentage": adverb_density,
            "examples": list(set(adverbs))[:8],
            "target": "<5%",
            "pass": adverb_density < 5,
        },
        "filler_words": {
            "total_count": filler_total,
            "breakdown": filler_found,
            "target": "0-3 per 100 words",
            "per_100_words": round(filler_total / num_words * 100, 1),
        },
        "overall_score": round(fre),
    }


# ---------------------------------------------------------------------------
# Demo text
# ---------------------------------------------------------------------------

DEMO_TEXT = """
Marketing copy needs to be clear, direct, and persuasive. When you write for your audience, 
you should always think about what they actually want to hear. Really good copy is basically 
about solving problems. It is very important to avoid using overly complicated language that 
might confuse the reader.

The best headlines are written by experts who truly understand their customers. A strong 
call-to-action is absolutely essential for any landing page. You need to make sure that 
every single word is earning its place on the page.

Studies show that shorter sentences improve comprehension. The average reader processes 
information faster when sentences contain fewer than 20 words. This is genuinely proven 
by research. Passive voice constructions are often used by writers who want to sound 
authoritative, but they can actually make copy feel distant and unclear.

Focus on benefits, not features. Tell the reader what they will gain. Use numbers when 
you can — "save 3 hours per week" beats "save time" every single time. Specificity 
builds trust. Vague promises are ignored.
"""


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

def main():
    parser = argparse.ArgumentParser(
        description="Readability scorer for marketing copy — Flesch, passive voice, filler words."
    )
    parser.add_argument("--file", help="Path to text file")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.file:
        with open(args.file, "r", encoding="utf-8", errors="replace") as f:
            text = f.read()
    elif not sys.stdin.isatty():
        text = sys.stdin.read()
        if not text.strip():
            text = DEMO_TEXT
            if not args.json:
                print("No input provided — running in demo mode.\n")
    else:
        text = DEMO_TEXT
        if not args.json:
            print("No input provided — running in demo mode.\n")

    result = analyze_text(text)

    if "error" in result:
        print(f"Error: {result['error']}", file=sys.stderr)
        sys.exit(1)

    if args.json:
        print(json.dumps(result, indent=2))
        return

    fre = result["flesch_reading_ease"]
    fk = result["flesch_kincaid_grade"]
    stats = result["stats"]
    passive = result["passive_voice"]
    adverbs = result["adverb_density"]
    fillers = result["filler_words"]
    score = result["overall_score"]

    PASS = "✅"
    FAIL = "❌"

    print("=" * 62)
    print(f"  READABILITY REPORT   Flesch Score: {fre['score']}/100")
    print("=" * 62)
    print(f"  {fre['label']}")
    print(f"  Target: {fre['target']}")
    print()
    print(f"  📊 Stats")
    print(f"     Words:              {stats['word_count']}")
    print(f"     Sentences:          {stats['sentence_count']}")
    print(f"     Avg sentence length:{stats['avg_sentence_length']} words")
    print(f"     Avg word length:    {stats['avg_word_length']} chars")
    print(f"     Syllables/word:     {stats['avg_syllables_per_word']}")
    print()
    print(f"  📐 Flesch-Kincaid Grade Level: {fk['grade_level']}")
    print(f"     {fk['note']}")
    print()

    pv_icon = PASS if passive["pass"] else FAIL
    print(f"  {pv_icon} Passive Voice: {passive['count']} instances ({passive['percentage']}%)")
    print(f"     Target: {passive['target']}")

    av_icon = PASS if adverbs["pass"] else FAIL
    print(f"  {av_icon} Adverb Density: {adverbs['count']} adverbs ({adverbs['percentage']}%)")
    if adverbs["examples"]:
        print(f"     Examples: {', '.join(adverbs['examples'][:5])}")

    filler_ok = fillers["per_100_words"] <= 3
    fw_icon = PASS if filler_ok else FAIL
    print(f"  {fw_icon} Filler Words: {fillers['total_count']} total ({fillers['per_100_words']} per 100 words)")
    if fillers["breakdown"]:
        top = sorted(fillers["breakdown"].items(), key=lambda x: -x[1])[:5]
        print(f"     Top: {', '.join(f'{w}({c})' for w,c in top)}")

    print()
    print("=" * 62)
    score_bar_len = round(score / 10)
    bar = "█" * score_bar_len + "░" * (10 - score_bar_len)
    print(f"  Readability Score:  [{bar}] {score}/100")
    print("=" * 62)


if __name__ == "__main__":
    main()