Copy Editing

#!/usr/bin/env python3
"""
AI Pattern Detector for Copy Editing

Detects AI-generated content markers relevant to editorial review.
Identifies filler words, hedging, structural uniformity, and provides
a pre-edit assessment for copy editors to know what they are working with.

Usage:
    python ai_pattern_detector.py article.md
    python ai_pattern_detector.py article.md --json
    python ai_pattern_detector.py article.md --verbose
"""

import argparse
import json
import math
import re
import sys
from pathlib import Path
from collections import Counter


FILLER_CRITICAL = [
    'delve', 'landscape', 'crucial', 'vital', 'pivotal', 'leverage',
    'robust', 'comprehensive', 'holistic', 'foster', 'facilitate',
    'utilize', 'furthermore', 'moreover', 'navigate', 'embark',
    'tapestry', 'multifaceted', 'underscore',
]

FILLER_MEDIUM = [
    'streamline', 'optimize', 'innovative', 'cutting-edge', 'game-changer',
    'paradigm', 'synergy', 'ecosystem', 'empower', 'transformative',
    'seamless', 'elevate', 'spearhead', 'groundbreaking',
]

HEDGING = [
    "it's important to note", "it is important to note",
    "it's worth mentioning", "it is worth mentioning",
    "one might argue", "in many cases",
    "it goes without saying", "needless to say",
]

GENERIC_OPENERS = [
    r'^in today\'?s (digital|modern|fast-paced|competitive|evolving)',
    r'^in the (rapidly|ever|constantly) (evolving|changing)',
    r'^in an? (increasingly|highly|rapidly)',
]


def detect_patterns(text):
    """Detect all AI patterns."""
    wc = len(text.split())
    findings = []

    # Filler words
    for word in FILLER_CRITICAL:
        count = len(re.findall(r'\b' + word + r'\b', text, re.IGNORECASE))
        if count:
            findings.append({
                "category": "filler",
                "severity": "Critical",
                "item": word,
                "count": count,
                "fix": f"Replace '{word}' — see content humanizer replacement guide",
            })

    for word in FILLER_MEDIUM:
        count = len(re.findall(r'\b' + word + r'\b', text, re.IGNORECASE))
        if count:
            findings.append({
                "category": "filler",
                "severity": "Medium",
                "item": word,
                "count": count,
                "fix": f"Consider replacing '{word}' with plain-language alternative",
            })

    # Hedging
    for phrase in HEDGING:
        count = len(re.findall(re.escape(phrase), text, re.IGNORECASE))
        if count:
            findings.append({
                "category": "hedging",
                "severity": "Critical",
                "item": phrase,
                "count": count,
                "fix": f"Delete '{phrase}' and start with the actual point",
            })

    # Generic openers
    for pattern in GENERIC_OPENERS:
        if re.search(pattern, text, re.IGNORECASE | re.MULTILINE):
            findings.append({
                "category": "generic_opener",
                "severity": "High",
                "item": "Generic AI opener detected",
                "count": 1,
                "fix": "Rewrite opening — lead with the problem or the answer",
            })

    # Em-dash overuse
    em_count = text.count('—') + text.count(' -- ')
    per_500 = round(em_count / max(wc, 1) * 500, 1)
    if per_500 > 2:
        findings.append({
            "category": "em_dash",
            "severity": "Medium",
            "item": f"Em-dash overuse: {em_count} ({per_500} per 500 words)",
            "count": em_count,
            "fix": "Replace some em-dashes with periods, commas, or parentheses",
        })

    # Sentence uniformity
    sents = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip() and len(s.split()) >= 3]
    if len(sents) >= 10:
        lengths = [len(s.split()) for s in sents]
        std = math.sqrt(sum((l - sum(lengths)/len(lengths)) ** 2 for l in lengths) / len(lengths))
        if std < 3.5:
            findings.append({
                "category": "uniformity",
                "severity": "High",
                "item": f"Sentence length uniformity: std dev {round(std, 1)}",
                "count": 1,
                "fix": "Vary sentence length — add short sentences, fragments, and questions",
            })

    total = sum(f.get("count", 1) for f in findings)
    per_500_total = round(total / max(wc, 1) * 500, 1)

    if per_500_total < 3:
        assessment = "Light editing — minor AI patterns"
    elif per_500_total < 7:
        assessment = "Moderate editing — noticeable AI patterns throughout"
    else:
        assessment = "Heavy editing or rewrite — extensive AI patterns"

    return {
        "word_count": wc,
        "total_tells": total,
        "per_500_words": per_500_total,
        "assessment": assessment,
        "findings": findings,
    }


def main():
    parser = argparse.ArgumentParser(description="Detect AI patterns for copy editing")
    parser.add_argument("file", help="Content file")
    parser.add_argument("--json", action="store_true")
    parser.add_argument("--verbose", action="store_true")
    args = parser.parse_args()

    fp = Path(args.file)
    if not fp.exists():
        print(f"Error: {fp} not found", file=sys.stderr)
        sys.exit(1)

    text = fp.read_text(encoding="utf-8", errors="replace")
    result = detect_patterns(text)
    result["file"] = str(fp)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print(f"\n{'='*55}")
        print(f"  AI PATTERN SCAN — Pre-Edit Assessment")
        print(f"{'='*55}")
        print(f"  File: {fp} | Words: {result['word_count']}")
        print(f"  AI tells: {result['total_tells']} ({result['per_500_words']} per 500 words)")
        print(f"  Assessment: {result['assessment']}")

        if result["findings"]:
            # Group by category
            categories = {}
            for f in result["findings"]:
                cat = f["category"]
                if cat not in categories:
                    categories[cat] = []
                categories[cat].append(f)

            for cat, items in categories.items():
                total = sum(i.get("count", 1) for i in items)
                print(f"\n  {cat.upper()} ({total} instances):")
                for item in items:
                    sev = item["severity"]
                    if args.verbose:
                        print(f"    [{sev}] {item['item']} (x{item['count']})")
                        print(f"           Fix: {item['fix']}")
                    else:
                        print(f"    [{sev}] {item['item']} (x{item['count']})")
        else:
            print(f"\n  No AI patterns detected — content reads as human-written.")

        print()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Copy Editing Readability Scorer

Scores content for editorial readability including Flesch Reading Ease,
sentence complexity, paragraph structure, passive voice rate, filler
word density, and web-optimized formatting checks.

Usage:
    python readability_scorer.py article.md
    python readability_scorer.py article.md --json
    python readability_scorer.py article.md --verbose
"""

import argparse
import json
import math
import re
import sys
from pathlib import Path


def strip_formatting(text):
    """Remove markdown formatting."""
    t = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)
    t = re.sub(r'\*\*([^*]+)\*\*', r'\1', t)
    t = re.sub(r'\*([^*]+)\*', r'\1', t)
    t = re.sub(r'```.*?```', '', t, flags=re.DOTALL)
    t = re.sub(r'`[^`]+`', '', t)
    t = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', t)
    t = re.sub(r'^\|.*\|$', '', t, flags=re.MULTILINE)
    return t.strip()


def count_syllables(word):
    """Estimate syllables."""
    w = word.lower().strip('.,!?;:()[]"\'-')
    if len(w) <= 3:
        return 1
    count = 0
    prev = False
    for c in w:
        v = c in 'aeiouy'
        if v and not prev:
            count += 1
        prev = v
    if w.endswith('e') and count > 1:
        count -= 1
    return max(count, 1)


def sentences(text):
    """Get sentences."""
    return [s.strip() for s in re.split(r'(?<=[.!?])\s+', text) if s.strip() and len(s.split()) >= 3]


def flesch(words, sents, syls):
    """Flesch Reading Ease."""
    if words == 0 or sents == 0:
        return 0
    return round(206.835 - 1.015 * (words / sents) - 84.6 * (syls / words), 1)


FILLER_WORDS = [
    'very', 'really', 'extremely', 'incredibly', 'quite', 'rather',
    'somewhat', 'just', 'actually', 'basically', 'essentially',
    'literally', 'simply', 'totally', 'absolutely', 'definitely',
]

WEAK_VERBS = [
    'utilize', 'implement', 'leverage', 'facilitate', 'optimize',
    'streamline', 'enhance', 'maximize', 'synergize',
]


def analyze(text):
    """Full readability analysis."""
    clean = strip_formatting(text)
    words = clean.split()
    wc = len(words)
    sents = sentences(clean)
    sc = len(sents)
    syls = sum(count_syllables(w) for w in words)

    fre = flesch(wc, sc, syls)
    fkg = round(0.39 * (wc / max(sc, 1)) + 11.8 * (syls / max(wc, 1)) - 15.59, 1) if wc > 0 else 0

    # Sentence analysis
    lengths = [len(s.split()) for s in sents] if sents else [0]
    avg_sent = round(sum(lengths) / max(len(lengths), 1), 1)
    std_sent = round(math.sqrt(sum((l - avg_sent) ** 2 for l in lengths) / max(len(lengths), 1)), 1) if len(lengths) > 1 else 0
    long_sents = sum(1 for l in lengths if l > 30)

    # Passive voice
    passive = sum(1 for s in sents if re.search(r'\b(is|are|was|were|been|being)\s+\w+(ed|en)\b', s, re.I))
    passive_rate = round(passive / max(sc, 1) * 100, 1)

    # Filler words
    filler_count = sum(len(re.findall(r'\b' + w + r'\b', clean, re.I)) for w in FILLER_WORDS)
    filler_per_1000 = round(filler_count / max(wc, 1) * 1000, 1)

    # Weak verbs
    weak_count = sum(len(re.findall(r'\b' + w + r'\b', clean, re.I)) for w in WEAK_VERBS)

    # Paragraphs
    paras = [p.strip() for p in re.split(r'\n\s*\n', clean) if p.strip()]
    para_sents = [len(sentences(p)) for p in paras]
    long_paras = sum(1 for c in para_sents if c > 5)

    # Subheading frequency
    headings = len(re.findall(r'^#{1,6}\s+', text, re.MULTILINE))
    words_per_heading = round(wc / max(headings, 1))

    # Score
    score = 0
    checks = {}

    # Flesch (25 pts)
    if 55 <= fre <= 75:
        score += 25
        checks["flesch"] = ("PASS", f"Flesch: {fre} (web-friendly range)")
    elif 45 <= fre <= 80:
        score += 15
        checks["flesch"] = ("PASS", f"Flesch: {fre} (acceptable)")
    else:
        score += 5
        checks["flesch"] = ("FAIL", f"Flesch: {fre} (target 60-70)")

    # Sentence length (20 pts)
    if 12 <= avg_sent <= 22:
        score += 20
        checks["sentence_length"] = ("PASS", f"Avg {avg_sent} words/sentence")
    else:
        score += 8
        checks["sentence_length"] = ("FAIL", f"Avg {avg_sent} words/sentence (target 15-20)")

    # Sentence variety (15 pts)
    if std_sent >= 5:
        score += 15
        checks["sentence_variety"] = ("PASS", f"Good variety (std dev {std_sent})")
    elif std_sent >= 3:
        score += 10
        checks["sentence_variety"] = ("PASS", f"Moderate variety (std dev {std_sent})")
    else:
        score += 3
        checks["sentence_variety"] = ("FAIL", f"Low variety (std dev {std_sent}, target >5)")

    # Passive voice (15 pts)
    if passive_rate < 10:
        score += 15
        checks["passive_voice"] = ("PASS", f"Passive: {passive_rate}%")
    elif passive_rate < 20:
        score += 8
        checks["passive_voice"] = ("FAIL", f"Passive: {passive_rate}% (target <10%)")
    else:
        score += 3
        checks["passive_voice"] = ("FAIL", f"Passive: {passive_rate}% (excessive)")

    # Filler words (10 pts)
    if filler_per_1000 < 5:
        score += 10
        checks["filler_words"] = ("PASS", f"{filler_count} filler words ({filler_per_1000}/1000)")
    else:
        score += 3
        checks["filler_words"] = ("FAIL", f"{filler_count} filler words ({filler_per_1000}/1000)")

    # Paragraph length (10 pts)
    if long_paras == 0:
        score += 10
        checks["paragraph_length"] = ("PASS", "All paragraphs under 5 sentences")
    else:
        score += 3
        checks["paragraph_length"] = ("FAIL", f"{long_paras} paragraphs exceed 5 sentences")

    # Formatting (5 pts)
    if words_per_heading <= 350:
        score += 5
        checks["heading_frequency"] = ("PASS", f"Heading every ~{words_per_heading} words")
    else:
        checks["heading_frequency"] = ("FAIL", f"Heading every ~{words_per_heading} words (target <350)")

    return {
        "word_count": wc,
        "sentence_count": sc,
        "score": min(score, 100),
        "flesch_reading_ease": fre,
        "flesch_kincaid_grade": fkg,
        "avg_sentence_length": avg_sent,
        "sentence_std_dev": std_sent,
        "long_sentences": long_sents,
        "passive_voice_rate": passive_rate,
        "filler_word_count": filler_count,
        "weak_verb_count": weak_count,
        "long_paragraphs": long_paras,
        "words_per_heading": words_per_heading,
        "checks": checks,
    }


def main():
    parser = argparse.ArgumentParser(description="Score readability for copy editing")
    parser.add_argument("file", help="Content file")
    parser.add_argument("--json", action="store_true")
    parser.add_argument("--verbose", action="store_true")
    args = parser.parse_args()

    fp = Path(args.file)
    if not fp.exists():
        print(f"Error: {fp} not found", file=sys.stderr)
        sys.exit(1)

    text = fp.read_text(encoding="utf-8", errors="replace")
    result = analyze(text)
    result["file"] = str(fp)

    grade = "A" if result["score"] >= 80 else "B" if result["score"] >= 65 else "C" if result["score"] >= 50 else "D"

    if args.json:
        # Convert checks tuples to dicts for JSON
        result["checks"] = {k: {"status": v[0], "detail": v[1]} for k, v in result["checks"].items()}
        print(json.dumps(result, indent=2))
    else:
        print(f"\n{'='*55}")
        print(f"  READABILITY: {result['score']}/100 (Grade: {grade})")
        print(f"{'='*55}")
        print(f"  Words: {result['word_count']} | Sentences: {result['sentence_count']}")
        print(f"  Flesch: {result['flesch_reading_ease']} | Grade: {result['flesch_kincaid_grade']}")

        for key, (status, detail) in result["checks"].items():
            print(f"  [{status}] {detail}")

        if args.verbose:
            print(f"\n  Details:")
            print(f"    Long sentences (>30 words): {result['long_sentences']}")
            print(f"    Weak verbs: {result['weak_verb_count']}")
            print(f"    Filler words: {result['filler_word_count']}")

        print()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Style Consistency Checker

Checks content for style consistency including Oxford comma usage,
heading capitalization, contraction consistency, number formatting,
punctuation patterns, and brand name formatting across one or more files.

Usage:
    python style_checker.py --file article.md
    python style_checker.py --files doc1.md doc2.md doc3.md --json
    python style_checker.py --file article.md --verbose
"""

import argparse
import json
import re
import sys
from pathlib import Path


def check_oxford_comma(text):
    """Check Oxford comma consistency."""
    # Pattern: X, Y, and Z (Oxford) vs X, Y and Z (no Oxford)
    with_oxford = len(re.findall(r'\w+,\s+\w+,\s+and\s+\w+', text))
    without_oxford = len(re.findall(r'\w+,\s+\w+\s+and\s+\w+', text)) - with_oxford

    if with_oxford > 0 and without_oxford > 0:
        return {
            "consistent": False,
            "with_oxford": with_oxford,
            "without_oxford": without_oxford,
            "detail": f"Mixed: {with_oxford} with Oxford comma, {without_oxford} without",
        }
    elif with_oxford > 0:
        return {"consistent": True, "style": "Oxford comma used", "count": with_oxford}
    elif without_oxford > 0:
        return {"consistent": True, "style": "No Oxford comma", "count": without_oxford}
    return {"consistent": True, "style": "No instances to check", "count": 0}


def check_heading_case(text):
    """Check heading capitalization consistency."""
    headings = re.findall(r'^#{1,6}\s+(.+)', text, re.MULTILINE)
    if len(headings) < 2:
        return {"consistent": True, "detail": "Not enough headings to check"}

    title_case = 0
    sentence_case = 0

    for h in headings:
        words = h.split()
        if len(words) < 2:
            continue
        # Check if non-first words are capitalized (title case signal)
        caps = sum(1 for w in words[1:] if w[0].isupper() and w.lower() not in
                   ['a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'])
        if caps > len(words[1:]) * 0.5:
            title_case += 1
        else:
            sentence_case += 1

    if title_case > 0 and sentence_case > 0:
        return {
            "consistent": False,
            "title_case": title_case,
            "sentence_case": sentence_case,
            "detail": f"Mixed: {title_case} Title Case, {sentence_case} sentence case",
        }
    return {
        "consistent": True,
        "style": "Title Case" if title_case > sentence_case else "Sentence case",
    }


def check_contractions(text):
    """Check contraction consistency."""
    contractions = len(re.findall(r"\b\w+'(t|s|re|ve|ll|d|m)\b", text))
    full_forms = len(re.findall(
        r'\b(do not|does not|is not|are not|was not|were not|will not|'
        r'would not|could not|should not|cannot|have not|has not|'
        r'it is|he is|she is|that is|there is|we are|they are|you are)\b',
        text, re.IGNORECASE
    ))

    if contractions > 0 and full_forms > 0:
        return {
            "consistent": False,
            "contractions": contractions,
            "full_forms": full_forms,
            "detail": f"Mixed: {contractions} contractions, {full_forms} full forms",
        }
    return {
        "consistent": True,
        "style": "Contractions" if contractions > full_forms else "Full forms",
        "contractions": contractions,
        "full_forms": full_forms,
    }


def check_number_format(text):
    """Check number formatting consistency."""
    # Spelled out small numbers vs digits
    spelled = len(re.findall(r'\b(one|two|three|four|five|six|seven|eight|nine)\b', text, re.I))
    digits_small = len(re.findall(r'\b[1-9]\b', text))  # Single digits as numbers

    issues = []
    if spelled > 0 and digits_small > 0:
        issues.append(f"Mixed: {spelled} spelled out, {digits_small} as digits for 1-9")

    return {
        "consistent": len(issues) == 0,
        "spelled_small": spelled,
        "digit_small": digits_small,
        "issues": issues,
    }


def check_list_punctuation(text):
    """Check bullet list punctuation consistency."""
    list_items = re.findall(r'^\s*[\-\*]\s+(.+)$', text, re.MULTILINE)
    if len(list_items) < 3:
        return {"consistent": True, "detail": "Not enough list items"}

    with_period = sum(1 for item in list_items if item.strip().endswith('.'))
    without_period = len(list_items) - with_period

    if with_period > 0 and without_period > 0:
        return {
            "consistent": False,
            "with_period": with_period,
            "without_period": without_period,
            "detail": f"Mixed: {with_period} with period, {without_period} without",
        }
    return {
        "consistent": True,
        "style": "With periods" if with_period > without_period else "Without periods",
    }


def check_quote_style(text):
    """Check quotation mark consistency."""
    curly = len(re.findall(r'[\u201c\u201d\u2018\u2019]', text))
    straight = len(re.findall(r'(?<!\w)["\'](?!\w)', text))

    if curly > 0 and straight > 0:
        return {
            "consistent": False,
            "curly": curly,
            "straight": straight,
            "detail": f"Mixed: {curly} curly quotes, {straight} straight quotes",
        }
    return {"consistent": True, "style": "Curly" if curly > straight else "Straight"}


def check_dash_usage(text):
    """Check dash consistency (em-dash, en-dash, hyphen)."""
    em_proper = text.count('\u2014')  # —
    em_double = len(re.findall(r'(?<!\-)\-\-(?!\-)', text))  # --
    en_dash = text.count('\u2013')  # –
    spaced_em = len(re.findall(r'\s\u2014\s', text))
    unspaced_em = em_proper - spaced_em

    issues = []
    if em_proper > 0 and em_double > 0:
        issues.append(f"Mixed em-dash styles: {em_proper} proper (—), {em_double} double-hyphen (--)")
    if spaced_em > 0 and unspaced_em > 0:
        issues.append(f"Mixed em-dash spacing: {spaced_em} spaced, {unspaced_em} unspaced")

    return {
        "consistent": len(issues) == 0,
        "em_dashes": em_proper,
        "double_hyphens": em_double,
        "issues": issues,
    }


def analyze_file(filepath):
    """Run all style checks on a file."""
    text = filepath.read_text(encoding="utf-8", errors="replace")

    checks = {
        "oxford_comma": check_oxford_comma(text),
        "heading_case": check_heading_case(text),
        "contractions": check_contractions(text),
        "number_format": check_number_format(text),
        "list_punctuation": check_list_punctuation(text),
        "quote_style": check_quote_style(text),
        "dash_usage": check_dash_usage(text),
    }

    inconsistencies = sum(1 for c in checks.values() if not c.get("consistent", True))
    score = round((1 - inconsistencies / len(checks)) * 100)

    return {
        "file": str(filepath),
        "word_count": len(text.split()),
        "score": score,
        "inconsistencies": inconsistencies,
        "checks": checks,
    }


def main():
    parser = argparse.ArgumentParser(description="Check style consistency")
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("--file", help="Single file to check")
    group.add_argument("--files", nargs="+", help="Multiple files to check")
    parser.add_argument("--json", action="store_true")
    parser.add_argument("--verbose", action="store_true")
    args = parser.parse_args()

    files = [Path(args.file)] if args.file else [Path(f) for f in args.files]
    results = []

    for fp in files:
        if not fp.exists():
            print(f"Warning: {fp} not found, skipping", file=sys.stderr)
            continue
        results.append(analyze_file(fp))

    if args.json:
        print(json.dumps({"files": results, "total": len(results)}, indent=2))
    else:
        for r in results:
            print(f"\n{'='*55}")
            print(f"  STYLE CHECK: {r['file']}")
            print(f"  Score: {r['score']}/100 | Inconsistencies: {r['inconsistencies']}")
            print(f"{'='*55}")

            for name, check in r["checks"].items():
                status = "PASS" if check.get("consistent", True) else "FAIL"
                detail = check.get("detail", check.get("style", ""))
                issues = check.get("issues", [])

                print(f"  [{status}] {name}: {detail}")
                if args.verbose and issues:
                    for issue in issues:
                        print(f"         {issue}")

        if len(results) > 1:
            avg = round(sum(r["score"] for r in results) / len(results))
            print(f"\n  Average consistency: {avg}/100 across {len(results)} files")
        print()


if __name__ == "__main__":
    main()