@demig0d2/skills 1.0.2 → 1.1.2

package/skills/book-creator/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)

package/skills/book-creator/scripts/score_report.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+score_report.py — Generate and save a structured chapter audit report
+
+Takes audit scores as input and produces a formatted report.
+Can also read a JSON audit file and re-format it.
+
+Usage:
+    # Interactive scoring
+    python score_report.py --chapter "Chapter 1: Why It Hurts So Much"
+
+    # From JSON input
+    python score_report.py --input audit.json
+
+    # Output formats
+    python score_report.py --chapter "Title" --output report.md
+    python score_report.py --input audit.json --json
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+# ─── Scoring Constants ────────────────────────────────────────────────────────
+
+DIMENSIONS = [
+    {
+        "key": "voice_authenticity",
+        "label": "Voice Authenticity",
+        "description": "Opens with scene/confession, immersive My Story, oscillates I/you in Reflection, no LinkedIn sentences",
+        "weight": 1,
+    },
+    {
+        "key": "arc_quality",
+        "label": "Pain-to-Transformation Arc",
+        "description": "Pain entered fully, wrong attempts shown, realization from within, perspective shift not tidy fix, closing reframes",
+        "weight": 1,
+    },
+    {
+        "key": "sentence_rhythm",
+        "label": "Sentence Rhythm",
+        "description": "Mix of short punchy and long flowing, varied paragraph length, rhetorical questions as pivots",
+        "weight": 1,
+    },
+    {
+        "key": "imagery_quality",
+        "label": "Metaphor & Imagery",
+        "description": "Physical/grounded images, specific enough to visualize, no recycled metaphors, min 2 strong images",
+        "weight": 1,
+    },
+    {
+        "key": "structural_integrity",
+        "label": "Structural Integrity",
+        "description": "Sections demarcated, each paragraph has one beat, no filler, within word count target",
+        "weight": 1,
+    },
+    {
+        "key": "ai_contamination",
+        "label": "AI Pattern Contamination",
+        "description": "Clean of AI vocabulary, significance inflation, -ing tack-ons, chatbot residue (5=clean, 1=heavy)",
+        "weight": 1,
+    },
+    {
+        "key": "reader_resonance",
+        "label": "Reader Resonance",
+        "description": "Reader's pain named accurately, 'how did he know' moment present, no condescension, author in-process",
+        "weight": 1,
+    },
+]
+
+VERDICTS = {
+    (28, 35): ("PASS", "✓", "Proceed to Humanizer (Module 6D)"),
+    (21, 27): ("CONDITIONAL PASS", "~", "Proceed to Humanizer, address Required Fixes after"),
+    (0, 20):  ("REVISE", "✗", "Return to Chapter Writer (Module 6B) with fix list"),
+}
+
+
+def get_verdict(total: int) -> tuple:
+    for (lo, hi), (label, icon, action) in VERDICTS.items():
+        if lo <= total <= hi:
+            return label, icon, action
+    return "REVISE", "✗", "Return to Chapter Writer"
+
+
+def score_to_label(score: int) -> str:
+    labels = {5: "Excellent", 4: "Good", 3: "Needs work", 2: "Significant issues", 1: "Failing"}
+    return labels.get(score, "Unknown")
+
+
+def build_report(chapter_title: str, scores: dict, word_count: int = 0,
+                 target_words: int = 0, notes: dict = None) -> dict:
+    notes = notes or {}
+    total = sum(scores.get(d["key"], 0) for d in DIMENSIONS)
+    max_score = len(DIMENSIONS) * 5
+    verdict, icon, action = get_verdict(total)
+
+    required_fixes = []
+    recommended = []
+
+    for dim in DIMENSIONS:
+        key = dim["key"]
+        score = scores.get(key, 0)
+        note = notes.get(key, "")
+        if score <= 3:
+            required_fixes.append({
+                "dimension": dim["label"],
+                "score": score,
+                "note": note or f"Score {score}/5 — {score_to_label(score)}",
+            })
+        elif score == 4 and note:
+            recommended.append({
+                "dimension": dim["label"],
+                "score": score,
+                "note": note,
+            })
+
+    return {
+        "chapter": chapter_title,
+        "timestamp": datetime.now().isoformat(),
+        "word_count": word_count,
+        "target_words": target_words,
+        "scores": {d["key"]: scores.get(d["key"], 0) for d in DIMENSIONS},
+        "total": total,
+        "max_score": max_score,
+        "verdict": verdict,
+        "icon": icon,
+        "action": action,
+        "required_fixes": required_fixes,
+        "recommended": recommended,
+    }
+
+
+def format_report(report: dict) -> str:
+    lines = []
+    lines.append(f"\n{'═' * 60}")
+    lines.append(f"  CHAPTER AUDIT — {report['chapter']}")
+    if report.get("word_count"):
+        wc_line = f"  Words: {report['word_count']:,}"
+        if report.get("target_words"):
+            wc_line += f" / Target: {report['target_words']:,}"
+        lines.append(wc_line)
+    lines.append(f"{'═' * 60}")
+    lines.append(f"\n  SCORES")
+    lines.append(f"  {'─' * 46}")
+
+    for dim in DIMENSIONS:
+        key = dim["key"]
+        score = report["scores"].get(key, 0)
+        bar = "█" * score + "░" * (5 - score)
+        lines.append(f"  {dim['label']:<30} {bar}  {score}/5")
+
+    lines.append(f"  {'─' * 46}")
+    lines.append(f"  {'OVERALL':<30} {report['total']}/{report['max_score']}")
+    lines.append(f"\n  VERDICT: {report['icon']} {report['verdict']}")
+    lines.append(f"  Action:  {report['action']}")
+
+    if report["required_fixes"]:
+        lines.append(f"\n  {'─' * 46}")
+        lines.append(f"  REQUIRED FIXES ({len(report['required_fixes'])}):")
+        for i, fix in enumerate(report["required_fixes"], 1):
+            lines.append(f"\n  {i}. {fix['dimension']} [{fix['score']}/5]")
+            if fix["note"]:
+                lines.append(f"     {fix['note']}")
+
+    if report["recommended"]:
+        lines.append(f"\n  RECOMMENDED IMPROVEMENTS:")
+        for rec in report["recommended"]:
+            lines.append(f"  · {rec['dimension']}: {rec['note']}")
+
+    lines.append(f"\n{'═' * 60}\n")
+    return "\n".join(lines)
+
+
+def interactive_score(chapter_title: str) -> dict:
+    """Prompt for scores interactively."""
+    print(f"\n  Scoring: {chapter_title}\n")
+    scores = {}
+    notes = {}
+
+    for dim in DIMENSIONS:
+        while True:
+            try:
+                val = input(f"  {dim['label']} [1-5]: ").strip()
+                score = int(val)
+                if 1 <= score <= 5:
+                    scores[dim["key"]] = score
+                    if score <= 3:
+                        note = input(f"    Issue note (enter to skip): ").strip()
+                        if note:
+                            notes[dim["key"]] = note
+                    break
+                else:
+                    print("  Enter a number between 1 and 5")
+            except (ValueError, EOFError):
+                print("  Invalid input")
+                break
+
+    wc = input("\n  Chapter word count (enter to skip): ").strip()
+    target = input("  Target word count (enter to skip): ").strip()
+
+    return build_report(
+        chapter_title,
+        scores,
+        int(wc) if wc.isdigit() else 0,
+        int(target) if target.isdigit() else 0,
+        notes,
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate chapter audit report")
+    parser.add_argument("--chapter", help="Chapter title")
+    parser.add_argument("--input", help="Load scores from JSON file")
+    parser.add_argument("--output", help="Save report to file")
+    parser.add_argument("--json", action="store_true", help="Output JSON")
+    args = parser.parse_args()
+
+    if args.input:
+        report = json.loads(Path(args.input).read_text())
+    elif args.chapter:
+        report = interactive_score(args.chapter)
+    else:
+        print("Error: provide --chapter or --input", file=sys.stderr)
+        sys.exit(1)
+
+    if args.json:
+        output = json.dumps(report, indent=2)
+        print(output)
+    else:
+        output = format_report(report)
+        print(output)
+
+    if args.output:
+        Path(args.output).write_text(output if not args.json else json.dumps(report, indent=2))
+        print(f"  Saved to: {args.output}")

package/skills/book-creator/scripts/toc_extract.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+toc_extract.py — Extract table of contents from a manuscript
+
+Detects chapter headings, part dividers, and section structure.
+Outputs formatted TOC or JSON.
+
+Usage:
+    python toc_extract.py <manuscript_file>
+    python toc_extract.py <manuscript_file> --json
+    python toc_extract.py <manuscript_file> --markdown
+"""
+
+import sys
+import re
+import json
+from pathlib import Path
+
+PART_PATTERN = re.compile(r"^(Part\s+(I{1,4}|[0-9]+)|PART\s+\w+)[:\s]?", re.IGNORECASE)
+CHAPTER_PATTERN = re.compile(r"^(Chapter\s+\d+|CHAPTER\s+\d+|#{1,2}\s+Chapter)", re.IGNORECASE)
+INTRO_PATTERN = re.compile(r"^(Introduction|Foreword|Preface|Prologue|How to Use)", re.IGNORECASE)
+OUTRO_PATTERN = re.compile(r"^(Conclusion|Epilogue|Afterword|About the Author|Acknowledgments)", re.IGNORECASE)
+HEADING_PATTERN = re.compile(r"^#{1,3}\s+(.+)")
+
+
+def extract_toc(filepath: str) -> dict:
+    path = Path(filepath)
+    if not path.exists():
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+
+    lines = path.read_text(encoding="utf-8").splitlines()
+
+    toc = {
+        "front_matter": [],
+        "parts": [],
+        "back_matter": [],
+        "ungrouped_chapters": [],
+    }
+
+    current_part = None
+    chapter_num = 0
+
+    for line_num, line in enumerate(lines, 1):
+        stripped = line.strip()
+        if not stripped:
+            continue
+
+        if INTRO_PATTERN.match(stripped):
+            toc["front_matter"].append({
+                "title": stripped.lstrip("#").strip(),
+                "line": line_num,
+                "type": "front",
+            })
+
+        elif OUTRO_PATTERN.match(stripped):
+            toc["back_matter"].append({
+                "title": stripped.lstrip("#").strip(),
+                "line": line_num,
+                "type": "back",
+            })
+
+        elif PART_PATTERN.match(stripped):
+            current_part = {
+                "title": stripped.lstrip("#").strip(),
+                "line": line_num,
+                "chapters": [],
+            }
+            toc["parts"].append(current_part)
+
+        elif CHAPTER_PATTERN.match(stripped) or (HEADING_PATTERN.match(stripped) and stripped.startswith("#")):
+            chapter_num += 1
+            title = stripped.lstrip("#").strip()
+            chapter = {
+                "number": chapter_num,
+                "title": title,
+                "line": line_num,
+            }
+            if current_part:
+                current_part["chapters"].append(chapter)
+            else:
+                toc["ungrouped_chapters"].append(chapter)
+
+    return toc
+
+
+def print_toc(toc: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  TABLE OF CONTENTS")
+    print(f"{'═' * 60}\n")
+
+    if toc["front_matter"]:
+        for item in toc["front_matter"]:
+            print(f"  {item['title']}")
+        print()
+
+    if toc["parts"]:
+        for part in toc["parts"]:
+            print(f"  {part['title'].upper()}")
+            for ch in part["chapters"]:
+                print(f"    Chapter {ch['number']}: {ch['title']}")
+            print()
+    elif toc["ungrouped_chapters"]:
+        for ch in toc["ungrouped_chapters"]:
+            print(f"  Chapter {ch['number']}: {ch['title']}")
+        print()
+
+    if toc["back_matter"]:
+        for item in toc["back_matter"]:
+            print(f"  {item['title']}")
+        print()
+
+    total = sum(len(p["chapters"]) for p in toc["parts"]) + len(toc["ungrouped_chapters"])
+    print(f"  Total chapters: {total}")
+    print(f"{'═' * 60}\n")
+
+
+def print_markdown_toc(toc: dict):
+    print("## Table of Contents\n")
+    for item in toc["front_matter"]:
+        print(f"- {item['title']}")
+    if toc["parts"]:
+        for part in toc["parts"]:
+            print(f"\n### {part['title']}")
+            for ch in part["chapters"]:
+                print(f"- Chapter {ch['number']}: {ch['title']}")
+    else:
+        for ch in toc["ungrouped_chapters"]:
+            print(f"- Chapter {ch['number']}: {ch['title']}")
+    if toc["back_matter"]:
+        print()
+        for item in toc["back_matter"]:
+            print(f"- {item['title']}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python toc_extract.py <file> [--json|--markdown]")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    mode = sys.argv[2] if len(sys.argv) > 2 else "--report"
+
+    toc = extract_toc(filepath)
+
+    if mode == "--json":
+        print(json.dumps(toc, indent=2))
+    elif mode == "--markdown":
+        print_markdown_toc(toc)
+    else:
+        print_toc(toc)