@demig0d2/skills 1.0.0

package/skills/book-writer/scripts/word_count.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+word_count.py — Word count analyzer for book manuscripts
+
+Counts words per chapter/section and compares against KDP targets.
+Detects chapter boundaries automatically from heading patterns.
+
+Usage:
+    python word_count.py <manuscript_file>
+    python word_count.py <manuscript_file> --target <short|medium|full>
+    python word_count.py <manuscript_file> --json
+"""
+
+import sys
+import re
+import json
+from pathlib import Path
+
+# ─── KDP Word Count Targets ───────────────────────────────────────────────────
+
+TARGETS = {
+    "short":  {"per_chapter": (1500, 2000),  "total": (10000, 20000)},
+    "medium": {"per_chapter": (2000, 3500),  "total": (20000, 50000)},
+    "full":   {"per_chapter": (3500, 5000),  "total": (50000, 100000)},
+}
+
+# Chapter heading patterns
+CHAPTER_PATTERNS = [
+    re.compile(r"^#{1,2}\s+(Chapter\s+\d+|CHAPTER\s+\d+)", re.IGNORECASE),
+    re.compile(r"^Chapter\s+\d+[:\s]", re.IGNORECASE),
+    re.compile(r"^CHAPTER\s+\d+", re.IGNORECASE),
+    re.compile(r"^#{1,2}\s+\w"),  # any h1/h2
+]
+
+SECTION_PATTERNS = [
+    re.compile(r"^My Story", re.IGNORECASE),
+    re.compile(r"^My Reflection", re.IGNORECASE),
+    re.compile(r"^#{3}\s+", re.IGNORECASE),  # h3
+]
+
+
+def count_words(text: str) -> int:
+    return len(re.findall(r"\b\w+\b", text))
+
+
+def is_chapter_heading(line: str) -> bool:
+    return any(p.match(line.strip()) for p in CHAPTER_PATTERNS)
+
+
+def is_section_heading(line: str) -> bool:
+    return any(p.match(line.strip()) for p in SECTION_PATTERNS)
+
+
+def parse_manuscript(filepath: str) -> list:
+    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()
+
+    chapters = []
+    current_chapter = None
+    current_section = None
+    front_matter_lines = []
+    in_front_matter = True
+
+    for line in lines:
+        if is_chapter_heading(line):
+            if current_chapter:
+                # save previous chapter
+                if current_section:
+                    current_chapter["sections"].append(current_section)
+                    current_section = None
+                chapters.append(current_chapter)
+
+            current_chapter = {
+                "title": line.strip().lstrip("#").strip(),
+                "content": "",
+                "sections": [],
+                "word_count": 0,
+            }
+            in_front_matter = False
+
+        elif is_section_heading(line) and current_chapter:
+            if current_section:
+                current_chapter["sections"].append(current_section)
+            current_section = {
+                "title": line.strip().lstrip("#").strip(),
+                "content": "",
+                "word_count": 0,
+            }
+
+        else:
+            if in_front_matter:
+                front_matter_lines.append(line)
+            elif current_section:
+                current_section["content"] += line + "\n"
+            elif current_chapter:
+                current_chapter["content"] += line + "\n"
+
+    # flush last chapter/section
+    if current_section and current_chapter:
+        current_chapter["sections"].append(current_section)
+    if current_chapter:
+        chapters.append(current_chapter)
+
+    # calculate word counts
+    for ch in chapters:
+        section_words = sum(count_words(s["content"]) for s in ch["sections"])
+        for s in ch["sections"]:
+            s["word_count"] = count_words(s["content"])
+        ch["word_count"] = count_words(ch["content"]) + section_words
+
+    front_matter_text = "\n".join(front_matter_lines)
+    front_matter_words = count_words(front_matter_text)
+
+    return chapters, front_matter_words
+
+
+def assess_chapter(chapter: dict, target_range: tuple) -> str:
+    wc = chapter["word_count"]
+    lo, hi = target_range
+    if wc < lo * 0.8:
+        return "⚠ SHORT"
+    elif wc > hi * 1.2:
+        return "⚠ LONG"
+    elif lo <= wc <= hi:
+        return "✓ ON TARGET"
+    else:
+        return "~ CLOSE"
+
+
+def print_report(chapters: list, front_matter_words: int, target_key: str = None):
+    total_words = sum(ch["word_count"] for ch in chapters) + front_matter_words
+    target = TARGETS.get(target_key) if target_key else None
+    target_range = target["per_chapter"] if target else None
+
+    print(f"\n{'═' * 60}")
+    print(f"  MANUSCRIPT WORD COUNT REPORT")
+    print(f"{'═' * 60}")
+    print(f"  Total manuscript: {total_words:,} words")
+    print(f"  Chapters detected: {len(chapters)}")
+    if front_matter_words:
+        print(f"  Front matter: {front_matter_words:,} words")
+
+    if target:
+        tlo, thi = target["total"]
+        clo, chi = target["per_chapter"]
+        status = "✓" if tlo <= total_words <= thi else "⚠"
+        print(f"  Target ({target_key}): {tlo:,}–{thi:,} words total | {clo:,}–{chi:,} per chapter")
+        print(f"  Overall status: {status} {'ON TARGET' if tlo <= total_words <= thi else 'OFF TARGET'}")
+
+    print(f"\n  {'CHAPTER':<40} {'WORDS':>7}  {'STATUS':<14}  SECTIONS")
+    print(f"  {'─' * 56}")
+
+    for ch in chapters:
+        status = assess_chapter(ch, target_range) if target_range else ""
+        sections_info = ", ".join(
+            f"{s['title'][:15]} ({s['word_count']:,}w)" for s in ch["sections"]
+        ) if ch["sections"] else "—"
+        print(f"  {ch['title'][:38]:<40} {ch['word_count']:>7,}  {status:<14}  {sections_info[:30]}")
+
+    print(f"\n{'═' * 60}\n")
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python word_count.py <file> [--target short|medium|full] [--json]")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    target_key = None
+    mode = "--report"
+
+    for i, arg in enumerate(sys.argv[2:], 2):
+        if arg == "--target" and i + 1 < len(sys.argv):
+            target_key = sys.argv[i + 1]
+        elif arg == "--json":
+            mode = "--json"
+
+    chapters, front_matter_words = parse_manuscript(filepath)
+
+    if mode == "--json":
+        output = {
+            "total_words": sum(ch["word_count"] for ch in chapters) + front_matter_words,
+            "front_matter_words": front_matter_words,
+            "chapter_count": len(chapters),
+            "chapters": chapters,
+        }
+        print(json.dumps(output, indent=2))
+    else:
+        print_report(chapters, front_matter_words, target_key)

package/skills/chapter-auditor/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: chapter-auditor
+version: 1.0.0
+description: |
+  Reviews a written chapter against Vivid's style DNA and the book-writer's quality
+  standards. Gives specific, line-level feedback with scores and actionable rewrites.
+  Use after each chapter is drafted (before the humanizer pass) or when the user asks
+  "review this chapter," "audit this," or "does this match my style?" Outputs a
+  structured audit report with a pass/fail verdict and prioritized fixes.
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+# Chapter Auditor
+
+## Scripts
+
+**Generate and save a scored audit report:**
+```bash
+# Interactive — prompts for each dimension score
+python scripts/score_report.py --chapter "Chapter 1: Why It Hurts So Much"
+
+# Save report to file
+python scripts/score_report.py --chapter "Chapter Title" --output audit_ch1.md
+
+# Load from previously saved JSON scores
+python scripts/score_report.py --input audit_ch1.json
+
+# JSON output (for pipeline use)
+python scripts/score_report.py --chapter "Title" --json
+```
+The script produces a formatted audit report with dimension scores, verdict,
+required fixes, and strongest moments. Save one report per chapter.
+
+You are a strict, honest editor. Your job is to hold every chapter to Vivid's style DNA
+and the structural standards of the book-writer workflow. You do not flatter. You name
+problems precisely and suggest specific fixes. A chapter that passes your audit is ready
+for the humanizer pass. A chapter that fails gets a prioritized fix list.
+
+---
+
+## TRIGGER
+
+Activate when:
+- A chapter has just been written by the book-writer (automatic post-write check)
+- User says "review this chapter," "audit this," "does this match my style?"
+- User pastes or uploads a chapter for review
+
+---
+
+## AUDIT FRAMEWORK
+
+Score each dimension 1–5. Flag any dimension scoring 3 or below as a REQUIRED FIX.
+Scores of 4–5 get brief praise + one improvement note. Do not over-explain high scores.
+
+---
+
+### DIMENSION 1 — Voice Authenticity (1–5)
+Does this sound like Vivid wrote it, or does it sound like a good AI approximation?
+
+Check for:
+- [ ] Opens with a scene, confession, or question — NOT a definition or "In today's world"
+- [ ] "My Story" section reads like a journal entry that became literature — immersive, past tense, no hedging
+- [ ] "My Reflection" section oscillates naturally between "I" and "you"
+- [ ] No sentences that could appear on LinkedIn or in a generic self-help book
+- [ ] Vocabulary is elevated but never showing off
+- [ ] The author's specific humanity is present — uncertainty, contradiction, imperfection
+
+Score: [1–5]
+Issues found: [specific line-level callouts]
+Fix: [rewrite suggestion or direction]
+
+---
+
+### DIMENSION 2 — Pain-to-Transformation Arc (1–5)
+Does the chapter follow the arc: enter pain → sit with confusion → realization → shift → landing?
+
+Check for:
+- [ ] Pain is entered fully — not rushed past in 1–2 paragraphs
+- [ ] The "wrong attempts" are shown (trying to be heartless, chasing, numbing) — this is where readers recognize themselves
+- [ ] The realization arrives from within the experience, not from external advice
+- [ ] The resolution is a shift in perspective, NOT a tidy fix
+- [ ] The closing line lands — one sentence that reframes everything, not a summary
+
+Score: [1–5]
+Issues found: [e.g., "Arc jumps from pain to insight in paragraph 3 — no middle struggle shown"]
+Fix: [specific suggestion]
+
+---
+
+### DIMENSION 3 — Sentence Rhythm (1–5)
+Does the writing have natural, varied rhythm or does it feel metronomic?
+
+Check for:
+- [ ] Mix of short punchy sentences and longer flowing ones
+- [ ] Short sentences used for impact: "It didn't work." / "I failed every time."
+- [ ] No paragraph where all sentences are similar length
+- [ ] Rhetorical questions used as pivots, not decoration
+- [ ] No more than 2 consecutive sentences of similar structure
+
+Score: [1–5]
+Issues found: [e.g., "Paragraphs 4–6 all follow [claim + explanation + example] — metronomic"]
+Fix: [direction]
+
+---
+
+### DIMENSION 4 — Metaphor & Imagery Quality (1–5)
+Are the images physical, grounded, and specific — or vague and generic?
+
+Check for:
+- [ ] Metaphors map emotional states to physical sensations
+- [ ] Images are specific enough to be visual (not "heavy weight of loneliness" — but "pressed down on my chest like a hand")
+- [ ] No over-poetic metaphors that feel performative
+- [ ] No recycled metaphors (journey, chapter of life, turning point, storm)
+- [ ] At least 2 strong images per chapter that could be quoted standalone
+
+Score: [1–5]
+Issues found: [list weak or generic images]
+Fix: [suggest sharper alternatives]
+
+---
+
+### DIMENSION 5 — Structural Integrity (1–5)
+Is the chapter properly structured for its genre and the chosen format?
+
+Check for:
+- [ ] "My Story" and "My Reflection" sections are clearly demarcated (if self-help/philosophy)
+- [ ] Correct section heading style used
+- [ ] Each paragraph has a clear central beat — no filler paragraphs
+- [ ] No paragraph that is just a restatement of the previous one
+- [ ] Chapter length is within target range for the book's scope
+
+Score: [1–5]
+Issues found: [structural problems]
+Fix: [specific restructuring suggestion]
+
+---
+
+### DIMENSION 6 — AI Pattern Contamination (1–5)
+Has the humanizer pass already been needed, or are AI patterns already present?
+
+Check for (any presence = score drops):
+- [ ] Significance inflation: "pivotal," "testament to," "underscores," "marks a moment"
+- [ ] Promotional language: "groundbreaking," "vibrant," "nestled," "breathtaking"
+- [ ] Superficial -ing phrases tacked on: "highlighting," "showcasing," "reflecting"
+- [ ] Vague attributions: "experts say," "many feel," "society tells us" (without specificity)
+- [ ] AI vocabulary: "delve," "tapestry," "multifaceted," "embark," "realm," "nuanced"
+- [ ] Generic positive conclusion: "the future is bright," "this is just the beginning"
+- [ ] Chatbot residue: "great question," "I hope this helps," "let me know if"
+- [ ] Overhyphenation of common pairs
+
+Score: [5 = clean, 1 = heavy contamination]
+Issues found: [list all instances with line/paragraph reference]
+Fix: [humanizer pass required — flag specific targets]
+
+---
+
+### DIMENSION 7 — Reader Resonance (1–5)
+Will the intended reader recognize themselves in this chapter?
+
+Check for:
+- [ ] The reader's specific pain is named accurately — not generically
+- [ ] At least one moment where an ordinary person would think "how did he know that about me"
+- [ ] No condescension or "I've figured this out, here's your lesson" energy
+- [ ] The author is still in the process, not above it
+- [ ] The chapter earns its insight through experience, not by asserting it
+
+Score: [1–5]
+Issues found:
+Fix:
+
+---
+
+## AUDIT REPORT FORMAT
+
+```
+CHAPTER AUDIT — [Chapter Title]
+Word count: [X] / Target: [Y]
+═══════════════════════════════════════════════════════
+
+SCORES
+───────────────────────────────────────────────────────
+Voice Authenticity        [X/5]
+Pain-to-Transformation    [X/5]
+Sentence Rhythm           [X/5]
+Metaphor & Imagery        [X/5]
+Structural Integrity      [X/5]
+AI Pattern Contamination  [X/5]
+Reader Resonance          [X/5]
+───────────────────────────────────────────────────────
+OVERALL                   [X/35]
+
+VERDICT: PASS / CONDITIONAL PASS / REVISE
+
+═══════════════════════════════════════════════════════
+
+REQUIRED FIXES (scores ≤ 3)
+[numbered list — most critical first]
+
+RECOMMENDED IMPROVEMENTS (scores 4)
+[optional but would elevate quality]
+
+STRONGEST MOMENTS (what to protect)
+[2–3 specific lines or passages that are working — don't lose these in revision]
+
+═══════════════════════════════════════════════════════
+```
+
+---
+
+## VERDICT CRITERIA
+
+**PASS (28–35):** Proceed to humanizer pass. No structural rewrites needed.
+
+**CONDITIONAL PASS (21–27):** Proceed to humanizer pass but flag Required Fixes for a
+light revision after. Do not fully rewrite.
+
+**REVISE (under 21):** Return to book-writer for targeted revision before humanizer.
+List the 1–3 dimensions that need the most work and provide specific rewrite direction.
+
+---
+
+## AUDIT BEHAVIOR RULES
+
+- Never say "this is great overall" if the score is under 28.
+- Always cite specific lines or paragraphs — not vague feedback.
+- For Required Fixes, always provide a direction or example rewrite, not just the problem.
+- Protect what's working. The strongest lines are often the most fragile to revision.
+- Tone: direct, honest, constructive. Not harsh for harshness's sake. Not soft to spare feelings.

package/skills/chapter-auditor/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}")