@demig0d2/skills 1.0.2 → 1.1.0

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

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+kdp_check.py — KDP pre-flight checker for manuscript DOCX files
+
+Validates a DOCX manuscript against KDP's technical requirements
+before upload. Checks margins, page size, fonts, images, and structure.
+
+Usage:
+    python kdp_check.py <manuscript.docx>
+    python kdp_check.py <manuscript.docx> --trim 6x9
+    python kdp_check.py <manuscript.docx> --json
+"""
+
+import sys
+import json
+import zipfile
+import re
+from pathlib import Path
+
+# ─── KDP Requirements ─────────────────────────────────────────────────────────
+
+# Trim sizes in EMU (914400 EMU = 1 inch)
+TRIM_SIZES = {
+    "5x8":    {"w": 4572000,  "h": 7315200},
+    "6x9":    {"w": 5486400,  "h": 8229600},
+    "8.5x11": {"w": 7772400,  "h": 10058400},
+}
+
+# Minimum margins in EMU (KDP requires at least 0.5" outside, 0.625" inside)
+MIN_MARGINS = {
+    "outside": 457200,   # 0.5 inch
+    "inside":  571500,   # 0.625 inch
+    "top":     457200,
+    "bottom":  457200,
+}
+
+# KDP safe fonts (always render correctly)
+SAFE_FONTS = {
+    "georgia", "times new roman", "garamond", "palatino linotype",
+    "arial", "helvetica", "calibri", "cambria", "courier new",
+    "book antiqua", "century", "trebuchet ms",
+}
+
+KDP_MIN_IMAGE_DPI = 300
+KDP_MAX_FILE_SIZE_MB = 650
+
+
+def check_file_size(filepath: str) -> dict:
+    size_mb = Path(filepath).stat().st_size / (1024 * 1024)
+    return {
+        "check": "File size",
+        "value": f"{size_mb:.1f} MB",
+        "pass": size_mb <= KDP_MAX_FILE_SIZE_MB,
+        "requirement": f"≤ {KDP_MAX_FILE_SIZE_MB} MB",
+        "note": "" if size_mb <= KDP_MAX_FILE_SIZE_MB else "File too large for KDP upload",
+    }
+
+
+def extract_docx_xml(filepath: str) -> dict:
+    """Extract relevant XML files from DOCX."""
+    xml_files = {}
+    try:
+        with zipfile.ZipFile(filepath, "r") as z:
+            for name in z.namelist():
+                if name in ("word/document.xml", "word/settings.xml",
+                            "word/styles.xml", "[Content_Types].xml"):
+                    xml_files[name] = z.read(name).decode("utf-8", errors="replace")
+    except zipfile.BadZipFile:
+        print(f"Error: Not a valid DOCX file: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    return xml_files
+
+
+def check_page_size(xml_files: dict, trim_key: str = None) -> dict:
+    doc_xml = xml_files.get("word/document.xml", "")
+    # Look for w:pgSz element
+    match = re.search(r'<w:pgSz[^>]+w:w="(\d+)"[^>]+w:h="(\d+)"', doc_xml)
+    if not match:
+        match = re.search(r'<w:pgSz[^>]+w:h="(\d+)"[^>]+w:w="(\d+)"', doc_xml)
+        if match:
+            w_dxa, h_dxa = int(match.group(2)), int(match.group(1))
+        else:
+            return {
+                "check": "Page size",
+                "pass": None,
+                "value": "Not detected",
+                "requirement": "Must match chosen trim size",
+                "note": "Could not read page dimensions from document",
+            }
+    else:
+        w_dxa, h_dxa = int(match.group(1)), int(match.group(2))
+
+    # DXA to inches (1440 DXA = 1 inch)
+    w_in = w_dxa / 1440
+    h_in = h_dxa / 1440
+
+    if trim_key and trim_key in TRIM_SIZES:
+        expected = TRIM_SIZES[trim_key]
+        # Convert EMU to DXA (914400 EMU = 1 inch = 1440 DXA, so EMU/635 = DXA)
+        exp_w_dxa = expected["w"] // 635
+        exp_h_dxa = expected["h"] // 635
+        passed = abs(w_dxa - exp_w_dxa) < 100 and abs(h_dxa - exp_h_dxa) < 100
+        req = f"{trim_key} ({exp_w_dxa/1440:.2f}\" × {exp_h_dxa/1440:.2f}\")"
+    else:
+        passed = any(
+            abs(w_dxa - ts["w"] // 635) < 100
+            for ts in TRIM_SIZES.values()
+        )
+        req = "One of: 5×8, 6×9, 8.5×11"
+
+    return {
+        "check": "Page size",
+        "pass": passed,
+        "value": f"{w_in:.2f}\" × {h_in:.2f}\"",
+        "requirement": req,
+        "note": "" if passed else f"Page size doesn't match expected trim",
+    }
+
+
+def check_margins(xml_files: dict) -> dict:
+    doc_xml = xml_files.get("word/document.xml", "")
+    match = re.search(
+        r'<w:pgMar[^>]+w:top="(\d+)"[^>]+w:right="(\d+)"[^>]+w:bottom="(\d+)"[^>]+w:left="(\d+)"',
+        doc_xml,
+    )
+    if not match:
+        return {
+            "check": "Margins",
+            "pass": None,
+            "value": "Not detected",
+            "requirement": "Min 0.5\" outside, 0.625\" inside",
+            "note": "Could not read margins from document",
+        }
+
+    top, right, bottom, left = (int(match.group(i)) for i in range(1, 5))
+
+    # KDP: inside margin (left for recto) must be at least 864 DXA (0.6")
+    # outside margin must be at least 720 DXA (0.5")
+    min_outside = 720  # DXA
+    min_inside = 864   # DXA
+
+    issues = []
+    if top < min_outside:
+        issues.append(f"Top margin {top/1440:.2f}\" < 0.5\"")
+    if bottom < min_outside:
+        issues.append(f"Bottom margin {bottom/1440:.2f}\" < 0.5\"")
+    if left < min_inside:
+        issues.append(f"Left margin {left/1440:.2f}\" < 0.6\"")
+    if right < min_outside:
+        issues.append(f"Right margin {right/1440:.2f}\" < 0.5\"")
+
+    return {
+        "check": "Margins",
+        "pass": len(issues) == 0,
+        "value": f"T:{top/1440:.2f}\" R:{right/1440:.2f}\" B:{bottom/1440:.2f}\" L:{left/1440:.2f}\"",
+        "requirement": "Min 0.5\" all sides, 0.6\" inside",
+        "note": "; ".join(issues) if issues else "",
+    }
+
+
+def check_fonts(xml_files: dict) -> dict:
+    styles_xml = xml_files.get("word/styles.xml", "")
+    fonts_found = set(re.findall(r'w:name="([^"]+)"', styles_xml))
+    # Filter to font-like names (not style names)
+    font_names = {f.lower() for f in fonts_found if len(f) > 3 and " " not in f or f.lower() in SAFE_FONTS}
+    unsafe = [f for f in font_names if f not in SAFE_FONTS and len(f) > 3]
+
+    return {
+        "check": "Fonts",
+        "pass": len(unsafe) == 0,
+        "value": f"{len(font_names)} font(s) detected",
+        "requirement": "Use standard embeddable fonts",
+        "note": f"Possibly non-standard: {', '.join(list(unsafe)[:3])}" if unsafe else "",
+    }
+
+
+def check_content_types(xml_files: dict) -> dict:
+    ct_xml = xml_files.get("[Content_Types].xml", "")
+    has_rels = "relationships" in ct_xml.lower()
+    has_doc = "wordprocessingml" in ct_xml.lower()
+    return {
+        "check": "Document structure",
+        "pass": has_rels and has_doc,
+        "value": "Valid DOCX structure" if (has_rels and has_doc) else "Invalid structure",
+        "requirement": "Valid OOXML structure",
+        "note": "" if (has_rels and has_doc) else "Document may be corrupted",
+    }
+
+
+def print_report(checks: list, filepath: str):
+    passed = sum(1 for c in checks if c["pass"] is True)
+    failed = sum(1 for c in checks if c["pass"] is False)
+    unknown = sum(1 for c in checks if c["pass"] is None)
+
+    print(f"\n{'═' * 60}")
+    print(f"  KDP PRE-FLIGHT CHECK")
+    print(f"  File: {filepath}")
+    print(f"{'═' * 60}")
+    print(f"  {'CHECK':<24} {'STATUS':<16} {'VALUE':<22} NOTE")
+    print(f"  {'─' * 56}")
+
+    for c in checks:
+        if c["pass"] is True:
+            status = "✓ PASS"
+        elif c["pass"] is False:
+            status = "✗ FAIL"
+        else:
+            status = "? UNKNOWN"
+        note = c.get("note", "")[:30]
+        print(f"  {c['check']:<24} {status:<16} {c['value']:<22} {note}")
+
+    print(f"\n  {'─' * 56}")
+    print(f"  Result: {passed} passed  {failed} failed  {unknown} unknown")
+    if failed == 0 and unknown == 0:
+        print(f"  ✓ Ready for KDP upload.")
+    elif failed > 0:
+        print(f"  ✗ Fix {failed} issue(s) before uploading.")
+    print(f"\n{'═' * 60}\n")
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python kdp_check.py <file.docx> [--trim 5x8|6x9|8.5x11] [--json]")
+        sys.exit(1)
+
+    filepath = sys.argv[1]
+    trim_key = None
+    mode = "--report"
+
+    for i, arg in enumerate(sys.argv[2:], 2):
+        if arg == "--trim" and i + 1 < len(sys.argv):
+            trim_key = sys.argv[i + 1]
+        elif arg == "--json":
+            mode = "--json"
+
+    if not Path(filepath).exists():
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+
+    xml_files = extract_docx_xml(filepath)
+
+    checks = [
+        check_file_size(filepath),
+        check_page_size(xml_files, trim_key),
+        check_margins(xml_files),
+        check_fonts(xml_files),
+        check_content_types(xml_files),
+    ]
+
+    if mode == "--json":
+        print(json.dumps({"file": filepath, "checks": checks}, indent=2))
+    else:
+        print_report(checks, filepath)

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

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+log_manager.py — Read, write, and update the continuity log
+
+The continuity log is stored as a JSON file alongside the manuscript.
+This script manages all log operations: init, update, read, and summary.
+
+Usage:
+    python log_manager.py init <book_title> [--log log.json]
+    python log_manager.py show [--log log.json]
+    python log_manager.py summary [--log log.json]
+    python log_manager.py add-chapter <N> <title> [--log log.json]
+    python log_manager.py add-fact <fact> [--log log.json]
+    python log_manager.py add-insight <chapter_n> <insight> [--log log.json]
+    python log_manager.py add-metaphor <chapter_n> <metaphor> [--log log.json]
+    python log_manager.py add-thread <thread> [--log log.json]
+    python log_manager.py close-thread <thread_index> [--log log.json]
+    python log_manager.py threads [--log log.json]
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+DEFAULT_LOG = "continuity_log.json"
+
+
+def load_log(log_path: str) -> dict:
+    path = Path(log_path)
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return None
+
+
+def save_log(log: dict, log_path: str):
+    Path(log_path).write_text(json.dumps(log, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def init_log(book_title: str, log_path: str) -> dict:
+    log = {
+        "book_title": book_title,
+        "created": datetime.now().isoformat(),
+        "last_updated": datetime.now().isoformat(),
+        "last_chapter": 0,
+        "commitments": [],
+        "established_facts": [],
+        "metaphors": {
+            "by_chapter": {},
+            "available": [],
+            "retired": [],
+        },
+        "insights": {},
+        "tone_decisions": {
+            "register": "",
+            "reader_address": "",
+            "author_position": "",
+            "emotional_ceiling": "",
+        },
+        "structural_patterns": {
+            "section_format": "",
+            "avg_chapter_words": 0,
+            "opening_style": "",
+            "closing_style": "",
+            "chapter_word_counts": [],
+        },
+        "open_threads": [],
+        "closed_threads": [],
+        "chapter_summaries": {},
+    }
+    save_log(log, log_path)
+    print(f"  ✓ Log initialized: {log_path}")
+    print(f"    Book: {book_title}")
+    return log
+
+
+def show_log(log: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  CONTINUITY LOG — {log['book_title']}")
+    print(f"  Last updated after Chapter {log['last_chapter']}")
+    print(f"{'═' * 60}")
+
+    if log["commitments"]:
+        print(f"\n  BOOK-LEVEL COMMITMENTS ({len(log['commitments'])}):")
+        for c in log["commitments"]:
+            print(f"    • {c}")
+
+    if log["established_facts"]:
+        print(f"\n  ESTABLISHED FACTS ({len(log['established_facts'])}):")
+        for f in log["established_facts"]:
+            print(f"    • {f}")
+
+    if log["metaphors"]["by_chapter"]:
+        print(f"\n  METAPHORS USED:")
+        for ch, mets in sorted(log["metaphors"]["by_chapter"].items(), key=lambda x: int(x[0])):
+            print(f"    Ch.{ch}: {', '.join(mets)}")
+        if log["metaphors"]["retired"]:
+            print(f"    Retired: {', '.join(log['metaphors']['retired'])}")
+
+    if log["insights"]:
+        print(f"\n  INSIGHTS DELIVERED:")
+        for ch, insight in sorted(log["insights"].items(), key=lambda x: int(x[0])):
+            print(f"    Ch.{ch}: {insight}")
+
+    open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+    if open_threads:
+        print(f"\n  OPEN THREADS ({len(open_threads)}):")
+        for i, t in enumerate(open_threads):
+            print(f"    [{i}] {t['thread']}")
+            if t.get("introduced_in"):
+                print(f"         Introduced: Ch.{t['introduced_in']}")
+
+    if log["chapter_summaries"]:
+        print(f"\n  CHAPTER SUMMARIES ({len(log['chapter_summaries'])}):")
+        for ch, summary in sorted(log["chapter_summaries"].items(), key=lambda x: int(x[0])):
+            title = summary.get("title", f"Chapter {ch}")
+            text = summary.get("summary", "")[:80]
+            print(f"    Ch.{ch} — {title}: {text}...")
+
+    print(f"\n{'═' * 60}\n")
+
+
+def summary_log(log: dict):
+    open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+    print(f"\n  {log['book_title']} — Continuity Summary")
+    print(f"  Chapters completed: {log['last_chapter']}")
+    print(f"  Facts established:  {len(log['established_facts'])}")
+    print(f"  Insights delivered: {len(log['insights'])}")
+    print(f"  Open threads:       {len(open_threads)}")
+    if open_threads:
+        print(f"  ⚠ Unresolved threads:")
+        for t in open_threads:
+            print(f"    · {t['thread'][:60]}")
+    print()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=[
+        "init", "show", "summary", "add-chapter", "add-fact",
+        "add-insight", "add-metaphor", "add-thread", "close-thread", "threads"
+    ])
+    parser.add_argument("args", nargs="*")
+    parser.add_argument("--log", default=DEFAULT_LOG)
+    parsed = parser.parse_args()
+
+    log_path = parsed.log
+    cmd = parsed.command
+    args = parsed.args
+
+    if cmd == "init":
+        title = " ".join(args) if args else "Untitled"
+        init_log(title, log_path)
+
+    elif cmd in ("show",):
+        log = load_log(log_path)
+        if not log:
+            print(f"  No log found at {log_path}. Run: python log_manager.py init <title>")
+            sys.exit(1)
+        show_log(log)
+
+    elif cmd == "summary":
+        log = load_log(log_path)
+        if not log:
+            print(f"  No log found at {log_path}")
+            sys.exit(1)
+        summary_log(log)
+
+    elif cmd == "add-chapter":
+        log = load_log(log_path)
+        if not log:
+            print("  No log found. Run init first.")
+            sys.exit(1)
+        n = int(args[0]) if args else log["last_chapter"] + 1
+        title = " ".join(args[1:]) if len(args) > 1 else f"Chapter {n}"
+        log["last_chapter"] = n
+        log["last_updated"] = datetime.now().isoformat()
+        if str(n) not in log["chapter_summaries"]:
+            log["chapter_summaries"][str(n)] = {"title": title, "summary": ""}
+        save_log(log, log_path)
+        print(f"  ✓ Chapter {n}: {title} added to log")
+
+    elif cmd == "add-fact":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        fact = " ".join(args)
+        log["established_facts"].append(fact)
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Fact added: {fact}")
+
+    elif cmd == "add-insight":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        ch = args[0] if args else str(log["last_chapter"])
+        insight = " ".join(args[1:]) if len(args) > 1 else ""
+        log["insights"][ch] = insight
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Insight for Ch.{ch} added")
+
+    elif cmd == "add-metaphor":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        ch = args[0] if args else str(log["last_chapter"])
+        metaphor = " ".join(args[1:]) if len(args) > 1 else ""
+        if ch not in log["metaphors"]["by_chapter"]:
+            log["metaphors"]["by_chapter"][ch] = []
+        log["metaphors"]["by_chapter"][ch].append(metaphor)
+        log["metaphors"]["retired"].append(metaphor)
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Metaphor added to Ch.{ch} and retired")
+
+    elif cmd == "add-thread":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        thread = " ".join(args)
+        log["open_threads"].append({
+            "thread": thread,
+            "introduced_in": str(log["last_chapter"]),
+            "closed": False,
+            "added": datetime.now().isoformat(),
+        })
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Thread added: {thread}")
+
+    elif cmd == "close-thread":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        idx = int(args[0]) if args else -1
+        open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+        if 0 <= idx < len(open_threads):
+            open_threads[idx]["closed"] = True
+            open_threads[idx]["closed_in"] = str(log["last_chapter"])
+            log["closed_threads"].append(open_threads[idx])
+            log["last_updated"] = datetime.now().isoformat()
+            save_log(log, log_path)
+            print(f"  ✓ Thread [{idx}] closed: {open_threads[idx]['thread'][:60]}")
+        else:
+            print(f"  ✗ Invalid thread index: {idx}")
+
+    elif cmd == "threads":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+        print(f"\n  Open threads ({len(open_threads)}):\n")
+        for i, t in enumerate(open_threads):
+            print(f"  [{i}] Introduced Ch.{t.get('introduced_in', '?')}: {t['thread']}")
+        print()