@demig0d2/skills 1.0.2 → 1.1.2

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

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+bank_formatter.py — Format and validate a research bank
+
+Reads a research bank JSON or markdown file and outputs a
+structured, validated bank ready for the book-writer to use.
+Also validates quote lengths and source attribution.
+
+Usage:
+    python bank_formatter.py <bank.json>
+    python bank_formatter.py <bank.json> --chapter 3
+    python bank_formatter.py <bank.json> --validate
+    python bank_formatter.py <bank.json> --markdown
+"""
+
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+
+MAX_QUOTE_WORDS = 30
+
+# ─── Banned / Overexposed Terms ───────────────────────────────────────────────
+
+BANNED_SOURCES = [
+    "tony robbins", "brené brown", "marie kondo", "simon sinek",
+    "gary vee", "gary vaynerchuk", "oprah",
+]
+
+OVEREXPOSED_QUOTES = [
+    "be the change you wish to see",
+    "the unexamined life is not worth living",
+    "insanity is doing the same thing",
+    "you miss 100% of the shots",
+    "it always seems impossible until it's done",
+    "in the middle of difficulty lies opportunity",
+    "the only way to do great work",
+]
+
+
+def validate_quote(quote: str) -> list:
+    """Return list of issues with a quote."""
+    issues = []
+    words = quote.split()
+    if len(words) > MAX_QUOTE_WORDS:
+        issues.append(f"Quote too long ({len(words)} words, max {MAX_QUOTE_WORDS})")
+
+    quote_lower = quote.lower()
+    for overexposed in OVEREXPOSED_QUOTES:
+        if overexposed in quote_lower:
+            issues.append(f"Overexposed quote detected — find something more original")
+            break
+
+    return issues
+
+
+def validate_source(source: str) -> list:
+    """Return list of issues with a source attribution."""
+    issues = []
+    source_lower = source.lower()
+
+    for banned in BANNED_SOURCES:
+        if banned in source_lower:
+            issues.append(f"Pop-psychology source not aligned with Vivid's voice: {source}")
+
+    if source.lower() in ("unknown", "anonymous", "") :
+        issues.append("Source is unknown — verify or remove")
+
+    return issues
+
+
+def validate_bank(bank: dict) -> dict:
+    """Run full validation on a research bank."""
+    all_issues = []
+
+    for chapter_key, chapter_data in bank.get("chapters", {}).items():
+        chapter_issues = []
+
+        for quote_item in chapter_data.get("quotes", []):
+            quote = quote_item.get("quote", "")
+            source = quote_item.get("source", "")
+            q_issues = validate_quote(quote)
+            s_issues = validate_source(source)
+            if q_issues or s_issues:
+                chapter_issues.append({
+                    "chapter": chapter_key,
+                    "type": "quote",
+                    "content": quote[:60],
+                    "issues": q_issues + s_issues,
+                })
+
+        for anchor in chapter_data.get("philosophical_anchors", []):
+            if not anchor.get("connection"):
+                chapter_issues.append({
+                    "chapter": chapter_key,
+                    "type": "anchor",
+                    "content": str(anchor)[:60],
+                    "issues": ["Missing 'connection' field — how does this relate to the chapter?"],
+                })
+
+        all_issues.extend(chapter_issues)
+
+    return {
+        "total_issues": len(all_issues),
+        "clean": len(all_issues) == 0,
+        "issues": all_issues,
+    }
+
+
+def format_chapter_bank(chapter_key: str, chapter_data: dict) -> str:
+    lines = []
+    lines.append(f"\n{'─' * 56}")
+    lines.append(f"CHAPTER {chapter_key}: {chapter_data.get('title', '')}")
+    lines.append(f"Theme: {chapter_data.get('theme', 'Not specified')}")
+
+    anchors = chapter_data.get("philosophical_anchors", [])
+    if anchors:
+        lines.append(f"\nPhilosophical anchors:")
+        for a in anchors:
+            thinker = a.get("thinker", "Unknown")
+            idea = a.get("idea", "")
+            connection = a.get("connection", "")
+            lines.append(f"  • {thinker} — {idea}")
+            if connection:
+                lines.append(f"    → {connection}")
+
+    quotes = chapter_data.get("quotes", [])
+    if quotes:
+        lines.append(f"\nQuotes ({len(quotes)}):")
+        for q in quotes:
+            lines.append(f"  \"{q.get('quote', '')}\"")
+            lines.append(f"  — {q.get('source', 'Unknown')}")
+
+    research = chapter_data.get("research", [])
+    if research:
+        lines.append(f"\nResearch / data:")
+        for r in research:
+            lines.append(f"  • {r.get('finding', '')} [{r.get('source', '')}]")
+
+    opposition = chapter_data.get("opposition", "")
+    if opposition:
+        lines.append(f"\nConceptual opposition:")
+        lines.append(f"  {opposition}")
+
+    notes = chapter_data.get("writing_notes", "")
+    if notes:
+        lines.append(f"\nWriting notes:")
+        lines.append(f"  {notes}")
+
+    return "\n".join(lines)
+
+
+def print_bank(bank: dict, chapter_filter: int = None):
+    print(f"\n{'═' * 60}")
+    print(f"  RESEARCH BANK — {bank.get('book_title', 'Unknown Book')}")
+    print(f"{'═' * 60}")
+
+    global_anchors = bank.get("global_anchors", [])
+    if global_anchors:
+        print(f"\nGLOBAL ANCHORS (whole manuscript):")
+        for a in global_anchors:
+            print(f"  • {a}")
+
+    chapters = bank.get("chapters", {})
+    for key, data in sorted(chapters.items(), key=lambda x: int(x[0]) if x[0].isdigit() else 0):
+        if chapter_filter and int(key) != chapter_filter:
+            continue
+        print(format_chapter_bank(key, data))
+
+    print(f"\n{'═' * 60}")
+    print(f"  Chapters in bank: {len(chapters)}")
+    print()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("bank_file")
+    parser.add_argument("--chapter", type=int, help="Show specific chapter only")
+    parser.add_argument("--validate", action="store_true")
+    parser.add_argument("--markdown", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    path = Path(args.bank_file)
+    if not path.exists():
+        print(f"Error: File not found: {args.bank_file}", file=sys.stderr)
+        sys.exit(1)
+
+    bank = json.loads(path.read_text(encoding="utf-8"))
+
+    if args.validate:
+        result = validate_bank(bank)
+        if result["clean"]:
+            print(f"\n  ✓ Research bank is clean — {len(bank.get('chapters', {}))} chapters validated\n")
+        else:
+            print(f"\n  ✗ {result['total_issues']} issue(s) found:\n")
+            for issue in result["issues"]:
+                print(f"  Ch.{issue['chapter']} [{issue['type']}]: {issue['content']}")
+                for i in issue["issues"]:
+                    print(f"    → {i}")
+            print()
+    elif args.json:
+        print(json.dumps(bank, indent=2))
+    else:
+        print_bank(bank, args.chapter)

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

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+conflict_check.py — Check a chapter for continuity conflicts against the log
+
+Scans a chapter text file against the established facts, retired metaphors,
+and delivered insights in the continuity log. Surfaces potential conflicts.
+
+Usage:
+    python conflict_check.py <chapter_file> [--log log.json]
+    python conflict_check.py <chapter_file> [--log log.json] --json
+"""
+
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+
+DEFAULT_LOG = "continuity_log.json"
+
+# ─── Conflict Detection Rules ─────────────────────────────────────────────────
+
+# Known fact patterns that might be stated inconsistently
+NUMERICAL_PATTERN = re.compile(r'\b(\d+)\s+(years?|months?|days?|chapters?|books?|pages?)\b', re.IGNORECASE)
+NAME_PATTERN = re.compile(r'\b[A-Z][a-z]+ [A-Z][a-z]+\b')
+
+
+def load_log(log_path: str) -> dict:
+    path = Path(log_path)
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def check_retired_metaphors(chapter_text: str, retired: list) -> list:
+    """Find retired metaphors used again in this chapter."""
+    conflicts = []
+    chapter_lower = chapter_text.lower()
+    for metaphor in retired:
+        # Check key phrases from the metaphor
+        key_words = [w for w in metaphor.lower().split() if len(w) > 4]
+        matches = sum(1 for w in key_words if w in chapter_lower)
+        if matches >= 2:
+            conflicts.append({
+                "type": "repeated_metaphor",
+                "severity": "medium",
+                "detail": f'Retired metaphor may be reused: "{metaphor}"',
+                "suggestion": "Use a fresh image — this metaphor was already delivered in a prior chapter",
+            })
+    return conflicts
+
+
+def check_repeated_insights(chapter_text: str, insights: dict) -> list:
+    """Check if an insight already fully delivered is being re-delivered."""
+    conflicts = []
+    chapter_lower = chapter_text.lower()
+
+    for ch_num, insight in insights.items():
+        # Look for key phrase overlap
+        insight_words = [w for w in insight.lower().split() if len(w) > 5]
+        if not insight_words:
+            continue
+        matches = sum(1 for w in insight_words if w in chapter_lower)
+        overlap_ratio = matches / len(insight_words) if insight_words else 0
+
+        if overlap_ratio > 0.5:
+            conflicts.append({
+                "type": "repeated_insight",
+                "severity": "medium",
+                "detail": f'Insight from Ch.{ch_num} may be re-delivered: "{insight[:60]}..."',
+                "suggestion": "Build on this insight rather than restating it — add a new dimension",
+            })
+
+    return conflicts
+
+
+def check_fact_consistency(chapter_text: str, established_facts: list) -> list:
+    """Flag when numerical or named facts appear inconsistently."""
+    conflicts = []
+
+    # Extract numbers from chapter
+    chapter_numbers = NUMERICAL_PATTERN.findall(chapter_text)
+
+    for fact in established_facts:
+        # Check if fact contains numbers that contradict chapter
+        fact_numbers = NUMERICAL_PATTERN.findall(fact)
+        for fn_val, fn_unit in fact_numbers:
+            for cn_val, cn_unit in chapter_numbers:
+                if cn_unit.rstrip("s") == fn_unit.rstrip("s") and cn_val != fn_val:
+                    conflicts.append({
+                        "type": "numerical_inconsistency",
+                        "severity": "high",
+                        "detail": f'Number mismatch: fact says "{fn_val} {fn_unit}", chapter says "{cn_val} {cn_unit}"',
+                        "suggestion": f'Verify against established fact: "{fact[:80]}"',
+                    })
+
+    return conflicts
+
+
+def run_conflict_check(chapter_path: str, log_path: str) -> dict:
+    chapter_text = Path(chapter_path).read_text(encoding="utf-8")
+    log = load_log(log_path)
+
+    result = {
+        "chapter_file": chapter_path,
+        "log_file": log_path,
+        "conflicts": [],
+        "warnings": [],
+        "clean": True,
+    }
+
+    if not log:
+        result["warnings"].append("No continuity log found — run log_manager.py init first")
+        return result
+
+    # Run checks
+    retired = log.get("metaphors", {}).get("retired", [])
+    insights = log.get("insights", {})
+    facts = log.get("established_facts", [])
+
+    metaphor_conflicts = check_retired_metaphors(chapter_text, retired)
+    insight_conflicts = check_repeated_insights(chapter_text, insights)
+    fact_conflicts = check_fact_consistency(chapter_text, facts)
+
+    all_conflicts = metaphor_conflicts + insight_conflicts + fact_conflicts
+
+    result["conflicts"] = all_conflicts
+    result["clean"] = len(all_conflicts) == 0
+
+    return result
+
+
+def print_report(result: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  CONTINUITY CONFLICT CHECK")
+    print(f"  Chapter: {result['chapter_file']}")
+    print(f"  Log: {result['log_file']}")
+    print(f"{'═' * 60}")
+
+    if result.get("warnings"):
+        for w in result["warnings"]:
+            print(f"\n  ⚠ {w}")
+
+    if result["clean"]:
+        print(f"\n  ✓ No conflicts detected. Chapter is consistent with log.\n")
+        return
+
+    high = [c for c in result["conflicts"] if c["severity"] == "high"]
+    medium = [c for c in result["conflicts"] if c["severity"] == "medium"]
+
+    print(f"\n  Conflicts: {len(result['conflicts'])} ({len(high)} high, {len(medium)} medium)\n")
+
+    for i, conflict in enumerate(result["conflicts"], 1):
+        icon = "✗" if conflict["severity"] == "high" else "⚠"
+        print(f"  {icon} [{conflict['severity'].upper()}] {conflict['type'].replace('_', ' ').title()}")
+        print(f"     {conflict['detail']}")
+        print(f"     → {conflict['suggestion']}\n")
+
+    print(f"{'═' * 60}")
+    print(f"  Resolve conflicts before updating the continuity log.\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("chapter_file")
+    parser.add_argument("--log", default=DEFAULT_LOG)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    if not Path(args.chapter_file).exists():
+        print(f"Error: File not found: {args.chapter_file}", file=sys.stderr)
+        sys.exit(1)
+
+    result = run_conflict_check(args.chapter_file, args.log)
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print_report(result)

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