@demig0d2/skills 1.0.0

package/skills/humanizer/references/patterns_quick_ref.md

@@ -0,0 +1,71 @@
+# AI Pattern Quick Reference
+
+All 25 documented AI writing patterns from Wikipedia's "Signs of AI Writing" guide.
+Used by `scan_ai_patterns.py` and the humanizer skill.
+
+---
+
+## CONTENT PATTERNS (1–6)
+
+| # | Pattern | Key Trigger Words |
+|---|---------|------------------|
+| 1 | Significance Inflation | stands/serves as, testament to, pivotal moment, underscores, evolving landscape |
+| 2 | Notability Claims | national media outlets, active social media presence, leading expert |
+| 3 | Superficial -ing Endings | highlighting..., symbolizing..., contributing to..., showcasing... |
+| 4 | Promotional Language | vibrant, nestled, breathtaking, groundbreaking, renowned, stunning |
+| 5 | Vague Attributions | experts argue, observers say, many believe, several sources |
+| 6 | Challenges/Future Sections | Despite challenges... continues to thrive, Future Outlook |
+
+## LANGUAGE & GRAMMAR (7–12)
+
+| # | Pattern | Key Trigger Words |
+|---|---------|------------------|
+| 7 | AI Vocabulary | delve, tapestry, multifaceted, nuanced, embark, realm, foster, transformative |
+| 8 | Copula Avoidance | serves as, stands as, represents a, boasts, features, offers a |
+| 9 | Negative Parallelism | "It's not just X; it's Y" / "Not merely X, but Y" |
+| 10 | Rule of Three | Exactly 3 abstract parallel items used as rhetorical device |
+| 11 | Synonym Cycling | Excessive substitution: protagonist → main character → central figure |
+| 12 | False Ranges | "from X to Y, from A to B" where items aren't on a real scale |
+
+## STYLE PATTERNS (13–18)
+
+| # | Pattern | Key Trigger Words |
+|---|---------|------------------|
+| 13 | Em Dash Overuse | — used as default connector more than 2× per page |
+| 14 | Boldface Overuse | **Bold** applied mechanically in prose |
+| 15 | Inline-Header Lists | **Header:** description as bullet items |
+| 16 | Title Case in Headings | Every Main Word Capitalized In Heading |
+| 17 | Emojis | 🚀 💡 ✅ in headings or bullets |
+| 18 | Curly Quotes | "smart" curly quotes in manuscripts |
+
+## COMMUNICATION PATTERNS (19–21)
+
+| # | Pattern | Key Trigger Words |
+|---|---------|------------------|
+| 19 | Chatbot Artifacts | I hope this helps, Let me know, Of course!, Feel free to |
+| 20 | Knowledge-Cutoff Disclaimers | "as of [date]", "while specific details are limited" |
+| 21 | Sycophantic Tone | Great question!, You're absolutely right!, That's excellent |
+
+## FILLER & HEDGING (22–25)
+
+| # | Pattern | Key Trigger Words |
+|---|---------|------------------|
+| 22 | Filler Phrases | In order to, Due to the fact that, At this point in time |
+| 23 | Hedging Overload | could potentially possibly be argued that might |
+| 24 | Generic Positive Conclusions | The future looks bright, Exciting times ahead |
+| 25 | Hyphen Overuse | cross-functional, data-driven, decision-making, well-known |
+
+---
+
+## PROTECTED — NEVER STRIP (Vivid's DNA)
+
+These constructions superficially match patterns above but are protected:
+
+| Construction | Why Protected | Strip Instead |
+|---|---|---|
+| "Not the silence, but what it forced me to face" | Grounded in specific experience | "Not just X; it's Y" (abstract) |
+| Parallel phrases building to emotional peak | Earned accumulation | Generic 3-item lists |
+| Em dash around emotionally significant phrase | Rhythmic weight | Em dash as default connector |
+| "But here's..." / "The hardest part wasn't..." | Signature phrases | Generic pivots |
+| insidious, agonizing, desolate, suffocating | Name felt experience | vibrant, groundbreaking, stunning |
+| Physical imagery: "pressed down on my chest" | Specific + grounded | Recycled: journey, storm, burden |

package/skills/humanizer/scripts/dna_scan.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+dna_scan.py — Scan text for Vivid's protected DNA constructions
+
+Identifies Vivid's authentic signature constructions that must NOT be
+stripped by the humanizer. Marks them so the pattern elimination pass
+knows to skip them.
+
+Usage:
+    python dna_scan.py <input_file>
+    python dna_scan.py <input_file> --json
+"""
+
+import sys
+import re
+import json
+from pathlib import Path
+
+# ─── DNA Constructions to Protect ────────────────────────────────────────────
+
+DNA_RULES = [
+    {
+        "name": "Signature Phrases",
+        "description": "Vivid's recurring voice markers — never strip",
+        "patterns": [
+            r"\bbut here'?s\b",
+            r"\bthe hardest part wasn'?t\b",
+            r"\bthat is what .{3,40} did to me from the inside\b",
+            r"\band you start to see\b",
+        ],
+    },
+    {
+        "name": "Protected Negative Parallelisms",
+        "description": "Grounded in specific experience — not generic contrast",
+        "patterns": [
+            r"\bnot the .{5,60}, but what\b",
+            r"\bnot the .{5,60}, but the\b",
+        ],
+        "note": "Only protect if both sides reference concrete, specific experience",
+    },
+    {
+        "name": "Protected Em Dashes (Emotional Weight)",
+        "description": "Em dashes around emotionally significant phrases",
+        "patterns": [
+            r"— that .{3,50} —",
+            r"— [a-z].{3,50} —",
+        ],
+        "note": "Only protect when em dash is around a named emotional moment",
+    },
+    {
+        "name": "Physical Imagery",
+        "description": "Vivid's grounded physical metaphors — never flatten",
+        "patterns": [
+            r"\bpressed down on my chest\b",
+            r"\bknife that cut\b",
+            r"\bscraps of attention\b",
+            r"\binvisible chains\b",
+            r"\bdeafening scream inside\b",
+            r"\bsuffocating grip\b",
+            r"\bunraveling\b",
+        ],
+    },
+    {
+        "name": "Protected Elevated Vocabulary",
+        "description": "Elevated words used to name felt experience — not decoration",
+        "patterns": [
+            r"\binsidious\b", r"\bimperceptibly\b", r"\bagonizing\b",
+            r"\bdesolate\b", r"\bconspicuously\b", r"\bgrotesque\b",
+            r"\bincessant\b", r"\bsuffocating\b",
+        ],
+        "note": "Protect only when modifying a specific felt experience",
+    },
+    {
+        "name": "Reframe Closings",
+        "description": "Single-sentence reframe closings — core Vivid structure",
+        "patterns": [
+            r"^[A-Z].{20,120}\.$",  # standalone short paragraph (reframe closing)
+        ],
+        "note": "Flag for review — Claude determines if it's a reframe closing",
+    },
+]
+
+# ─── Scanner ──────────────────────────────────────────────────────────────────
+
+def scan_dna(filepath: str) -> dict:
+    path = Path(filepath)
+    if not path.exists():
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    results = {
+        "file": str(path),
+        "total_lines": len(lines),
+        "protected_constructions": [],
+        "total_protected": 0,
+    }
+
+    for rule in DNA_RULES:
+        rule_findings = []
+        for line_num, line in enumerate(lines, start=1):
+            for pattern in rule["patterns"]:
+                if re.search(pattern, line, re.IGNORECASE):
+                    rule_findings.append({
+                        "line": line_num,
+                        "text": line.strip()[:120],
+                        "note": rule.get("note", ""),
+                    })
+                    break  # one match per line per rule is enough
+
+        if rule_findings:
+            results["protected_constructions"].append({
+                "rule": rule["name"],
+                "description": rule["description"],
+                "count": len(rule_findings),
+                "instances": rule_findings,
+            })
+            results["total_protected"] += len(rule_findings)
+
+    return results
+
+
+def print_dna_report(results: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  DNA PROTECTION SCAN")
+    print(f"  File: {results['file']}")
+    print(f"{'═' * 60}")
+
+    if results["total_protected"] == 0:
+        print("\n  No protected DNA constructions found.\n")
+        print("  This is normal for non-Vivid text or early drafts.\n")
+        return
+
+    print(f"\n  Protected constructions found: {results['total_protected']}")
+    print(f"  These will be EXEMPT from AI pattern elimination.\n")
+
+    for item in results["protected_constructions"]:
+        print(f"  {'─' * 56}")
+        print(f"  ✓ PROTECT: {item['rule']}  ({item['count']} instance{'s' if item['count'] > 1 else ''})")
+        print(f"    {item['description']}")
+        for inst in item["instances"][:3]:
+            print(f"    Line {inst['line']:>4}: {inst['text'][:90]}")
+            if inst.get("note"):
+                print(f"            Note: {inst['note']}")
+
+    print(f"\n{'═' * 60}")
+    print(f"  Mark these {results['total_protected']} line(s) as protected")
+    print(f"  before running scan_ai_patterns.py.\n")
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python dna_scan.py <input_file> [--json]")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    mode = sys.argv[2] if len(sys.argv) > 2 else "--report"
+
+    results = scan_dna(filepath)
+
+    if mode == "--json":
+        print(json.dumps(results, indent=2))
+    else:
+        print_dna_report(results)

package/skills/humanizer/scripts/scan_ai_patterns.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+scan_ai_patterns.py — Scan text for AI writing patterns
+
+Usage:
+    python scan_ai_patterns.py <input_file>
+    python scan_ai_patterns.py <input_file> --json
+    python scan_ai_patterns.py <input_file> --summary
+
+Output:
+    Human-readable report of all AI patterns found, with line numbers.
+    Use --json for machine-readable output (for audit scripts).
+    Use --summary for a count-only view.
+"""
+
+import sys
+import re
+import json
+from pathlib import Path
+
+# ─── Pattern Definitions ─────────────────────────────────────────────────────
+
+PATTERNS = {
+    "significance_inflation": {
+        "label": "Pattern 1 — Significance Inflation",
+        "terms": [
+            r"\bstands as\b", r"\bserves as\b", r"\bmarks a\b", r"\btestament to\b",
+            r"\ba reminder that\b", r"\bpivotal moment\b", r"\bcrucial role\b",
+            r"\bvital role\b", r"\bunderscores\b", r"\bhighlights its importance\b",
+            r"\breflects broader\b", r"\bsetting the stage for\b", r"\bevolving landscape\b",
+            r"\bindel[i]ble mark\b", r"\bdeeply rooted\b", r"\bkey turning point\b",
+            r"\bfocal point\b", r"\bmarks a shift\b", r"\bshaping the\b",
+        ],
+    },
+    "promotional_language": {
+        "label": "Pattern 4 — Promotional Language",
+        "terms": [
+            r"\bboasts\b", r"\bvibrant\b", r"\bnestled\b", r"\bbreathtaking\b",
+            r"\bgroundbreaking\b", r"\brenowned\b", r"\bstunning\b", r"\bmust-visit\b",
+            r"\bmust-read\b", r"\bshowcasing\b", r"\bexemplifies\b",
+        ],
+    },
+    "ing_tack_ons": {
+        "label": "Pattern 3 — Superficial -ing Endings",
+        "terms": [
+            r"\bhighlighting\b", r"\bunderscoring\b", r"\bemphasizing\b",
+            r"\bensuring\b", r"\breflecting\b", r"\bsymbolizing\b",
+            r"\bcontributing to\b", r"\bcultivating\b", r"\bfostering\b",
+            r"\bshowcasing\b", r"\bencompassing\b",
+        ],
+    },
+    "ai_vocabulary": {
+        "label": "Pattern 7 — AI Vocabulary Words",
+        "terms": [
+            r"\bdelve\b", r"\btapestry\b", r"\bmultifaceted\b", r"\bnuanced\b",
+            r"\bembark\b", r"\brealm\b", r"\bfoster\b", r"\belevate\b",
+            r"\bleverage\b", r"\bnavigate\b", r"\bunpack\b", r"\bholistic\b",
+            r"\bsynergy\b", r"\btransformative\b", r"\bimpactful\b", r"\brobust\b",
+            r"\bpivotal\b", r"\btestament\b", r"\blandscape\b", r"\bgarner\b",
+            r"\bintricate\b", r"\binterplay\b",
+        ],
+    },
+    "copula_avoidance": {
+        "label": "Pattern 8 — Copula Avoidance",
+        "terms": [
+            r"\bserves as\b", r"\bstands as\b", r"\brepresents a\b", r"\bboasts\b",
+            r"\bfeatures\b", r"\boffers a\b",
+        ],
+    },
+    "vague_attributions": {
+        "label": "Pattern 5 — Vague Attributions",
+        "terms": [
+            r"\bexperts (say|argue|believe|suggest)\b",
+            r"\bindustry (reports|observers)\b",
+            r"\bmany believe\b", r"\bsome critics argue\b",
+            r"\bit is widely believed\b", r"\bobservers (have|say)\b",
+        ],
+    },
+    "filler_phrases": {
+        "label": "Pattern 22 — Filler Phrases",
+        "terms": [
+            r"\bin order to\b", r"\bdue to the fact that\b", r"\bat this point in time\b",
+            r"\bin the event that\b", r"\bhas the ability to\b",
+            r"\bit is important to note\b", r"\bat its core\b",
+            r"\bin today's world\b", r"\bin conclusion\b",
+            r"\bto summarize\b", r"\bit goes without saying\b",
+            r"\bneedless to say\b",
+        ],
+    },
+    "hedging_overload": {
+        "label": "Pattern 23 — Hedging Overload",
+        "terms": [
+            r"\bcould potentially\b", r"\bmight possibly\b",
+            r"\bit could be argued\b", r"\bpotentially possibly\b",
+        ],
+    },
+    "generic_conclusions": {
+        "label": "Pattern 24 — Generic Positive Conclusions",
+        "terms": [
+            r"\bthe future (looks|is) bright\b", r"\bexciting times (lie |)ahead\b",
+            r"\bthis is just the beginning\b", r"\bcontinue this journey\b",
+            r"\bthe possibilities are endless\b", r"\btoward excellence\b",
+        ],
+    },
+    "chatbot_artifacts": {
+        "label": "Pattern 19 — Chatbot Artifacts",
+        "terms": [
+            r"\bgreat question\b", r"\bi hope this helps\b",
+            r"\blet me know if\b", r"\bfeel free to\b",
+            r"\bof course!\b", r"\bcertainly!\b",
+            r"\byou'?re absolutely right\b",
+        ],
+    },
+    "em_dash_overuse": {
+        "label": "Pattern 13 — Em Dash Overuse",
+        "terms": [r"—"],
+        "count_threshold": 3,  # flag only if more than N per paragraph
+    },
+    "negative_parallelism": {
+        "label": "Pattern 9 — Negative Parallelism",
+        "terms": [
+            r"\bit'?s not just (about |)\b.*?it'?s\b",
+            r"\bnot (only|merely|just)\b.*?\bbut\b",
+        ],
+    },
+    "false_ranges": {
+        "label": "Pattern 12 — False Ranges",
+        "terms": [
+            r"\bfrom .{5,40} to .{5,40}, from\b",
+        ],
+    },
+    "hyphen_overuse": {
+        "label": "Pattern 25 — Hyphenated Word Pair Overuse",
+        "terms": [
+            r"\bcross-functional\b", r"\bdata-driven\b", r"\bclient-facing\b",
+            r"\bdecision-making\b", r"\bwell-known\b", r"\bhigh-quality\b",
+            r"\breal-time\b", r"\blong-term\b", r"\bend-to-end\b",
+            r"\bthird-party\b",
+        ],
+    },
+}
+
+# ─── DNA Protection Terms (never flag these) ─────────────────────────────────
+
+DNA_PROTECTED_PHRASES = [
+    "but here's",
+    "the hardest part wasn't",
+    "that is what",
+    "did to me from the inside",
+    "and you start to see",
+]
+
+# ─── Scanner ──────────────────────────────────────────────────────────────────
+
+def is_dna_protected(line: str) -> bool:
+    line_lower = line.lower()
+    return any(phrase in line_lower for phrase in DNA_PROTECTED_PHRASES)
+
+
+def scan_file(filepath: str) -> dict:
+    path = Path(filepath)
+    if not path.exists():
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    results = {
+        "file": str(path),
+        "total_lines": len(lines),
+        "total_words": len(text.split()),
+        "findings": [],
+        "pattern_counts": {},
+        "total_flags": 0,
+        "clean": True,
+    }
+
+    for pattern_key, pattern_data in PATTERNS.items():
+        label = pattern_data["label"]
+        terms = pattern_data["terms"]
+        threshold = pattern_data.get("count_threshold", 1)
+        pattern_findings = []
+
+        for line_num, line in enumerate(lines, start=1):
+            if is_dna_protected(line):
+                continue
+
+            line_lower = line.lower()
+            matched_terms = []
+
+            for term in terms:
+                matches = re.findall(term, line_lower)
+                if matches:
+                    matched_terms.extend(matches)
+
+            if matched_terms:
+                # For em dash, only flag if count exceeds threshold in paragraph
+                if pattern_key == "em_dash_overuse":
+                    count = line.count("—")
+                    if count < threshold:
+                        continue
+
+                pattern_findings.append({
+                    "line": line_num,
+                    "text": line.strip()[:120],
+                    "matched": list(set(matched_terms)),
+                })
+
+        if pattern_findings:
+            results["findings"].append({
+                "pattern": label,
+                "key": pattern_key,
+                "count": len(pattern_findings),
+                "instances": pattern_findings,
+            })
+            results["pattern_counts"][pattern_key] = len(pattern_findings)
+            results["total_flags"] += len(pattern_findings)
+            results["clean"] = False
+
+    return results
+
+
+def print_report(results: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  AI PATTERN SCAN REPORT")
+    print(f"  File: {results['file']}")
+    print(f"  Words: {results['total_words']:,} | Lines: {results['total_lines']:,}")
+    print(f"{'═' * 60}")
+
+    if results["clean"]:
+        print("\n  ✓ No AI patterns detected. Text is clean.\n")
+        return
+
+    print(f"\n  Total flags: {results['total_flags']}")
+    print(f"  Patterns triggered: {len(results['findings'])}\n")
+
+    for finding in results["findings"]:
+        print(f"  {'─' * 56}")
+        print(f"  {finding['pattern']}  ({finding['count']} instance{'s' if finding['count'] > 1 else ''})")
+        for instance in finding["instances"][:5]:  # cap at 5 per pattern
+            print(f"    Line {instance['line']:>4}: {instance['text'][:90]}")
+            print(f"            Matched: {', '.join(instance['matched'][:3])}")
+        if len(finding["instances"]) > 5:
+            print(f"    ... and {len(finding['instances']) - 5} more")
+
+    print(f"\n{'═' * 60}")
+    print(f"  Run humanizer pass to fix {results['total_flags']} flag(s).\n")
+
+
+def print_summary(results: dict):
+    print(f"\n  {results['file']} — {results['total_words']:,} words")
+    if results["clean"]:
+        print("  ✓ Clean — no AI patterns found\n")
+        return
+    print(f"  ✗ {results['total_flags']} flags across {len(results['findings'])} patterns\n")
+    for finding in results["findings"]:
+        print(f"    {str(finding['count']).rjust(3)}x  {finding['pattern']}")
+    print()
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python scan_ai_patterns.py <input_file> [--json|--summary]")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    mode = sys.argv[2] if len(sys.argv) > 2 else "--report"
+
+    results = scan_file(filepath)
+
+    if mode == "--json":
+        print(json.dumps(results, indent=2))
+    elif mode == "--summary":
+        print_summary(results)
+    else:
+        print_report(results)