ghostwriter-muse-pages 10.0.0 → 12.0.0

package/build_pages.py

@@ -1,29 +1,32 @@
 #!/usr/bin/env python3
-"""Build the book's pages (Overview, Book Setup, Voice, Stories, Notes, Outline, Manuscript, Ghostwriter).
+"""Build the book's pages (Overview, Book Setup, Voice, Stories, Notes, Outline, Manuscript, Cover, Ghostwriter).
 
 Reads   <book>/Dashboard/book.json          the status and outline, written by the ghostwriter
+        <book>/START-HERE.md                only its "Method:" line, when book.json does not say which version is in use
         <book>/2-Plan/01-book-setup.md      the Book Setup page, read as it is
         <book>/2-Plan/02-voice-profile.md   the Voice page, with 05-style-sheet.md, read as they are
         <book>/2-Plan/04-story-bank.md      the Stories page, read as it is
         <book>/2-Plan/00-notes.md           the notes board, read as it is
         <book>/5-Manuscript/*.md            the chapters, read as they are
-Writes  <book>/Dashboard/Overview.html, Setup.html, Voice.html, Stories.html, Notes.html, Outline.html, Manuscript.html, Ghostwriter.html
+        <book>/2-Plan/cover/cover.json      the Cover page, with the picture it names if the author brought one
+Writes  <book>/Dashboard/Overview.html, Setup.html, Voice.html, Stories.html, Notes.html, Outline.html, Manuscript.html, Cover.html, Ghostwriter.html
+        <book>/Dashboard/cover-picture.*   a copy of the author's own cover picture, for the pages in the folder
         <book>/Dashboard/_live/         only with --live: book-dashboard.html to publish, plus data/*.json to load into it
 
 Usage:  python3 build_pages.py --book "/path/to/Book Folder" [--live]
         python3 build_pages.py --version
-Python 3 standard library only. This one file is the whole builder: the design of the pages is not in it.
+Python 3 standard library only (a large cover picture is made smaller when the Pillow library happens to be installed). This one file is the whole builder: the design of the pages is not in it.
 Every page it writes is a few lines that load the page code, at one exact version, from the address in KIT_URL.
 """
 import argparse, json, os, re, sys
 
-BUILDER = "0.8.0"          # this builder's own version
-KIT_VERSION = "10.0.0"     # the exact version of the page code every page loads
+BUILDER = "0.9.0"          # this builder's own version
+KIT_VERSION = "12.0.0"     # the exact version of the page code every page loads
 KIT_URL = "https://cdn.jsdelivr.net/npm/ghostwriter-muse-pages@" + KIT_VERSION + "/kit.js"
 FONTS_URL = "https://fonts.googleapis.com/css2?family=Caveat:wght@600;700&family=Inter:wght@400;500;600&family=Lora:ital,wght@0,400;0,500;0,600;1,400&display=swap"
 GHOSTWRITERS = {"lawrence", "kenji", "saira", "octavio", "zora", "boo", "imani", "indigo", "idris", "ryu", "marcus-aurelius", "frederick-douglass", "jane-austen",
                 "li-bai", "mary-shelley", "murasaki-shikibu", "phillis-wheatley", "rumi", "sor-juana", "william-shakespeare"}
-PAGES = {"overview": "Overview.html", "setup": "Setup.html", "voice": "Voice.html", "stories": "Stories.html", "notes": "Notes.html", "outline": "Outline.html", "manuscript": "Manuscript.html", "ghostwriter": "Ghostwriter.html"}
+PAGES = {"overview": "Overview.html", "setup": "Setup.html", "voice": "Voice.html", "stories": "Stories.html", "notes": "Notes.html", "outline": "Outline.html", "manuscript": "Manuscript.html", "cover": "Cover.html", "ghostwriter": "Ghostwriter.html"}
 STAGE_COUNT = 10
 PAGE_KIT = int(KIT_VERSION.split(".")[0])  # the page version written beside the live link in START-HERE.md
 STORY_FIELDS = {"home": "home", "role": "role", "when": "when", "narrative": "narrative", "how it ended": "ended", "teaching point": "point", "people": "people",
@@ -36,6 +39,8 @@ WHEN = re.compile(r"^(worked out\s+|about\s+|around\s+|circa\s+|c\.\s*|~\s*)?(\d
 STATUSES = {"done", "waiting", "current", "todo"}
 PROPOSED = re.compile(r"\s*\(proposed[^)]*\)\s*\.?\s*$", re.I)
 MARKER = re.compile(r"^\[(AUTHOR TO CONFIRM|STORY NEEDED):\s*(.*?)\]?$")
+VERSION = re.compile(r"^\d+(\.\d+){1,2}$")
+DAY = re.compile(r"^\d{4}-\d{2}-\d{2}$")
 
 
 OLD_STAGES = []
@@ -371,6 +376,186 @@ def read_stories(plan, problems):
     return {"status": status, "confirmed": confirmed, "items": items}
 
 
+COVER_LAYOUTS = ("paper", "bold", "quiet")
+COVER_FONTS = {"Fraunces", "Cormorant Garamond", "Playfair Display", "DM Serif Display", "Libre Baskerville", "Lora", "Archivo Black", "Archivo", "Bebas Neue", "Oswald", "Space Grotesk", "Inter"}
+HEX = re.compile(r"^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$")
+VIEWBOX = re.compile(r"^\s*-?\d+(?:\.\d+)?(?:[\s,]+-?\d+(?:\.\d+)?){3}\s*$")
+COVER_ID = re.compile(r"^[a-z0-9][a-z0-9-]{0,40}$")
+SVG_BAD = re.compile(r"<\s*(?:script|foreignObject|image|use|a|text|tspan|style|iframe|animate\w*|set|svg)\b|\bon[a-z]+\s*=|href\s*=|javascript:|<!|<\?", re.I)
+PART = 180000        # letters of a picture carried by one document on the live page
+PICTURE_MAX = 1500000  # bytes: the largest picture the pages carry
+
+
+def picture_kind(data):
+    if data[:3] == b"\xff\xd8\xff":
+        return "image/jpeg", "jpg"
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png", "png"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp", "webp"
+    if data[:4] == b"GIF8":
+        return "image/gif", "gif"
+    return None, None
+
+
+def shrink(data, mime):
+    """Make a large picture smaller, if this computer happens to have the Pillow library. Without it the picture is used as it is."""
+    if mime == "image/gif":
+        return data, mime
+    try:
+        import io
+        from PIL import Image, ImageOps
+        im = Image.open(io.BytesIO(data))
+        if max(im.size) <= 1500 and len(data) <= 350000:
+            return data, mime
+        im = ImageOps.exif_transpose(im)
+        im.thumbnail((1500, 1500))
+        buf = io.BytesIO()
+        im.convert("RGB").save(buf, "JPEG", quality=86, optimize=True)
+        return (buf.getvalue(), "image/jpeg") if len(buf.getvalue()) < len(data) else (data, mime)
+    except Exception:
+        return data, mime
+
+
+def cover_lettering(src, where, problems):
+    """The typefaces, colors, and line breaks of one cover. Anything not on the lists is left out, and the page uses its own choice."""
+    out = {}
+    for k in ("titleFont", "textFont"):
+        if src.get(k):
+            if src[k] in COVER_FONTS:
+                out[k] = src[k]
+            else:
+                problems.append('cover.json: %s names the typeface "%s", which the pages do not carry. It is left out. Use one of: %s.' % (where, src[k], ", ".join(sorted(COVER_FONTS))))
+    if isinstance(src.get("titleLines"), list) and 1 <= len(src["titleLines"]) <= 6:
+        out["titleLines"] = [str(x) for x in src["titleLines"]]
+    if isinstance(src.get("caps"), bool):
+        out["caps"] = src["caps"]
+    return out
+
+
+def read_cover(book_dir, dash, problems):
+    """The Cover page is built from 2-Plan/cover/cover.json, written by the ghostwriter, and from the picture it names, if the
+    author brought one. Returns (the cover as the folder pages carry it, the cover as the live page carries it, the picture's parts)."""
+    path = os.path.join(book_dir, "2-Plan", "cover", "cover.json")
+    if not os.path.exists(path):
+        return None, None, []
+    try:
+        raw = json.load(open(path, encoding="utf-8"))
+    except (ValueError, UnicodeDecodeError) as e:
+        problems.append("2-Plan/cover/cover.json is not valid JSON (%s), so the Cover page is not built. Fix the file and build again." % e)
+        return None, None, []
+    if not isinstance(raw, dict):
+        problems.append("2-Plan/cover/cover.json must be one object. See the cover reference.")
+        return None, None, []
+    out, seen = {"concepts": []}, set()
+    for c in raw.get("concepts") or []:
+        if not isinstance(c, dict) or not COVER_ID.match(str(c.get("id", ""))) or c.get("id") == "own" or not str(c.get("name", "")).strip():
+            problems.append('cover.json: each direction needs an id (small letters, digits, hyphens; not "own") and a name. One was left out.')
+            continue
+        if c["id"] in seen:
+            problems.append('cover.json: two directions share the id "%s". The second one was left out.' % c["id"])
+            continue
+        if len(out["concepts"]) == 4:
+            problems.append("cover.json: the Cover page shows at most four directions. The rest were left out.")
+            break
+        seen.add(c["id"])
+        where = 'the direction "%s"' % c["name"]
+        d = {"id": c["id"], "name": str(c["name"]).strip(), "why": str(c.get("why", "")).strip(), "layout": c.get("layout") if c.get("layout") in COVER_LAYOUTS else "paper"}
+        if c.get("layout") not in COVER_LAYOUTS:
+            problems.append("cover.json: %s has no layout, or one the pages do not know. It is drawn as \"paper\". Use one of: %s." % (where, ", ".join(COVER_LAYOUTS)))
+        colors = {k: v for k, v in (c.get("colors") or {}).items() if k in ("paper", "ink", "accent") and HEX.match(str(v))} if isinstance(c.get("colors"), dict) else {}
+        if len(colors) < 3:
+            problems.append("cover.json: %s needs three colors, paper, ink, and accent, each written like #1F3B2D. The page fills in the missing ones." % where)
+        d["colors"] = colors
+        d.update(cover_lettering(c, where, problems))
+        m = c.get("motif")
+        if isinstance(m, dict) and str(m.get("svg", "")).strip():
+            svg = str(m["svg"]).strip()
+            if len(svg) > 20000 or SVG_BAD.search(svg) or not VIEWBOX.match(str(m.get("viewBox", ""))):
+                problems.append("cover.json: the drawing for %s was left out. A drawing is plain shapes only (path, rect, circle, ellipse, line, polygon, polyline, g, and gradients), at most 20,000 letters, with a viewBox of four numbers, and no words, pictures, links, or scripts." % where)
+            else:
+                d["motif"] = {"viewBox": str(m["viewBox"]).strip(), "svg": svg}
+        out["concepts"].append(d)
+    out["prompts"] = [{"label": str(x.get("label", "")).strip(), "why": str(x.get("why", "")).strip(), "say": str(x["say"]).strip()}
+                      for x in (raw.get("prompts") or []) if isinstance(x, dict) and str(x.get("say", "")).strip()][:6]
+    b = raw.get("back")
+    if isinstance(b, dict) and (b.get("headline") or b.get("text")):
+        text = b.get("text") if isinstance(b.get("text"), list) else [b.get("text")] if b.get("text") else []
+        status = str(b.get("status", "")).strip()
+        d = re.search(r"\d{4}-\d{2}-\d{2}", status)
+        out["back"] = {"status": "confirmed" if status.upper().startswith("CONFIRMED") else "draft", "confirmed": d.group(0) if d else "",
+                       "headline": str(b.get("headline", "")).strip(), "text": [str(x).strip() for x in text if str(x).strip()][:8], "bio": str(b.get("bio", "")).strip()}
+    live, parts, own = dict(out), [], raw.get("own")
+    if isinstance(own, dict) and str(own.get("file", "")).strip():
+        rel = str(own["file"]).strip().replace("\\", "/")
+        src = os.path.normpath(os.path.join(book_dir, rel))
+        data = None
+        if not src.startswith(book_dir + os.sep) or not os.path.isfile(src):
+            problems.append('cover.json: the picture "%s" is not in the book folder, so the author\'s own cover is not shown. Give its place inside the book folder, for example 2-Plan/cover/my-cover.jpg.' % rel)
+        else:
+            data = open(src, "rb").read()
+            mime, ext = picture_kind(data)
+            if not mime:
+                problems.append('cover.json: "%s" is not a JPEG, PNG, WebP, or GIF picture, so it is not shown. Ask the author for one of those, or save a copy as JPEG.' % rel)
+                data = None
+            else:
+                data, mime = shrink(data, mime)
+                ext = picture_kind(data)[1]
+                if len(data) > PICTURE_MAX:
+                    problems.append('cover.json: the picture "%s" is %.1f MB, which is more than the pages can carry (1.5 MB). Save a smaller copy beside it (1,500 pixels tall is plenty, as a JPEG), name that copy in own.file, and build again.' % (rel, len(data) / 1e6))
+                    data = None
+        if data is not None:
+            import base64, hashlib
+            name = "cover-picture." + ext
+            open(os.path.join(dash, name), "wb").write(data)
+            b64, sig = base64.b64encode(data).decode("ascii"), hashlib.sha256(data).hexdigest()[:12]
+            chunks = [b64[i:i + PART] for i in range(0, len(b64), PART)]
+            parts = [{"sig": sig, "i": i, "of": len(chunks), "data": ch} for i, ch in enumerate(chunks)]
+            base = {"words": own.get("words") is not False, "note": str(own.get("note", "")).strip()}
+            if not base["words"]:
+                base["lettering"] = cover_lettering(own.get("lettering") if isinstance(own.get("lettering"), dict) else {}, "the author's own picture", problems)
+                ink = (own.get("lettering") or {}).get("ink") if isinstance(own.get("lettering"), dict) else None
+                if HEX.match(str(ink or "")):
+                    base["lettering"]["ink"] = ink
+            out["own"] = dict(base, src=name)
+            live["own"] = dict(base, sig=sig, parts=len(chunks), type=mime, bytes=len(data))
+    chosen = str(raw.get("chosen", "") or "").strip()
+    if chosen and not (chosen in seen or (chosen == "own" and "own" in out)):
+        problems.append('cover.json: chosen is "%s", which is not one of the directions%s. No cover is marked as chosen.' % (chosen, "" if "own" in out else ", and there is no picture of the author's own"))
+        chosen = ""
+    out["chosen"] = live["chosen"] = chosen
+    return out, live, parts
+
+
+def read_version(book_dir, state, problems):
+    """The version marker in the top bar of every page. The ghostwriter writes state.version at each refresh:
+    {"method": "0.8.1", "plugin": "0.8.0", "checked": "2026-10-10"}. Anything that is not a plain version or date is dropped.
+    When the method version is missing, it is read from the Method line of START-HERE.md."""
+    given = state.get("version") if isinstance(state.get("version"), dict) else {}
+    out = {}
+    for k in ("method", "plugin"):
+        if VERSION.match(str(given.get(k, "")).strip()):
+            out[k] = str(given[k]).strip()
+    if DAY.match(str(given.get("checked", "")).strip()):
+        out["checked"] = str(given["checked"]).strip()
+    if "method" not in out:
+        try:
+            for line in open(os.path.join(book_dir, "START-HERE.md"), encoding="utf-8"):
+                m = re.match(r"^\s*Method:\s*(\d+(?:\.\d+){1,2})\b", line)
+                if m:
+                    out["method"] = m.group(1)
+                    break
+        except (OSError, UnicodeDecodeError):
+            pass
+        problems.append('book.json has no state.version, so the version marker at the top of the pages %s. Write state.version at every refresh (see the pages reference).'
+                        % ('shows the Method line of START-HERE.md (%s) and no date' % out["method"] if "method" in out else "is left off"))
+    elif "checked" not in out:
+        problems.append("state.version has no checked date (YYYY-MM-DD), so the pages cannot say when the version was last confirmed.")
+    out["builder"], out["pages"] = BUILDER, KIT_VERSION
+    state["version"] = out
+    return out
+
+
 def untag(text):
     """Take a closing '(proposed)' or '(proposed, please check)' off a value, so the author reads a clean line."""
     return PROPOSED.sub("", text or "").strip()
@@ -420,15 +605,17 @@ def main():
     board = read_notes(os.path.join(book_dir, "2-Plan", "00-notes.md"), notes)
     plan = os.path.join(book_dir, "2-Plan")
     setup, voice, stories = read_setup(plan), read_voice(plan), read_stories(plan, notes)
+    cover, cover_live, cover_parts = read_cover(book_dir, dash, notes)
     if OLD_STAGES:
         notes.append("book.json lists 11 steps. The Proposal is no longer a step: write state.stages with 10 values and state.stage from 1 to 10 (see references/pages.md). This build dropped the sixth value for you.")
 
     if state.get("ghostwriter") not in GHOSTWRITERS:
         state["ghostwriter"] = "lawrence"
+    version = read_version(book_dir, state, notes)
     title = state["title"].replace("&", "&amp;").replace("<", "").replace(">", "")
 
     # 1. The pages for the book folder: one small file per page, carrying the book's data with it.
-    snap = {"state": state, "outline": outline, "manuscript": manuscript, "notes": board, "setup": setup, "voice": voice, "stories": stories}
+    snap = {"state": state, "outline": outline, "manuscript": manuscript, "notes": board, "setup": setup, "voice": voice, "stories": stories, "cover": cover}
     for key, fname in PAGES.items():
         doc = ('<!doctype html>\n<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">'
                "<style>img{max-width:100%}[hidden]{display:none!important}</style></head><body>\n"
@@ -438,7 +625,7 @@ def main():
     # 2. The live page and its data, for sessions that can publish it.
     live = os.path.join(dash, "_live")
     if a.live:
-        write_live(live, title, state, outline, manuscript, board, setup, voice, stories)
+        write_live(live, title, state, outline, manuscript, board, setup, voice, stories, cover_live, cover_parts)
 
     # 3. Say what was built, in numbers the ghostwriter can check against the folder.
     total = 0
@@ -447,6 +634,8 @@ def main():
         state["stage"], state["ghostwriter"], len(state.get("prompts", [])),
         "" if state.get("prompts") else " (none written: the Overview falls back to the older next-step fields)",
         ", live files in Dashboard/_live" if a.live else ""))
+    print("  version shown at the top of the pages: %s%s%s" % (
+        version.get("method", "none"), (", plugin " + version["plugin"]) if "plugin" in version else "", (", the latest as of " + version["checked"]) if "checked" in version else ""))
     for c in (outline or {}).get("chapters", []):
         ch = manuscript.get(c["key"])
         w = sum(s["words"] for s in ch["sections"]) if ch else 0
@@ -461,11 +650,20 @@ def main():
         ("%d lines, %s" % (len(setup["items"]), setup["status"])) if setup else "not written yet",
         ("%d lines, %s" % (len(voice["items"]) + len((voice.get("style") or {}).get("items", [])), voice["status"])) if voice else "not written yet",
         ("%d, %s" % (len(stories["items"]), stories["status"])) if stories else "not written yet"))
+    if cover is None:
+        print("  cover: not started")
+    else:
+        own = (cover_live or {}).get("own")
+        names = {c["id"]: c["name"] for c in cover["concepts"]}
+        print("  cover: %d direction%s (%d with a drawing); the author's own picture: %s; chosen: %s" % (
+            len(cover["concepts"]), "" if len(cover["concepts"]) == 1 else "s", sum(1 for c in cover["concepts"] if "motif" in c),
+            ("%d KB, carried as coverimg/p-00%s" % (round(own["bytes"] / 1000), " to p-%02d" % (own["parts"] - 1) if own["parts"] > 1 else "")) if own else "none",
+            "the author's own picture" if cover["chosen"] == "own" else names.get(cover["chosen"], "nothing yet")))
     for n in notes:
         print("NOTE " + n)
 
 
-def write_live(live, title, state, outline, manuscript, board, setup, voice, stories):
+def write_live(live, title, state, outline, manuscript, board, setup, voice, stories, cover=None, cover_parts=()):
     os.makedirs(os.path.join(live, "data", "manuscript"), exist_ok=True)
     open(os.path.join(live, "book-dashboard.html"), "w", encoding="utf-8").write(shell(title + " Dashboard"))
     json.dump(state, open(os.path.join(live, "data", "state.json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
@@ -479,6 +677,17 @@ def write_live(live, title, state, outline, manuscript, board, setup, voice, sto
         json.dump(body, open(os.path.join(live, "data", "notes", note["id"] + ".json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
     for key, ch in manuscript.items():
         json.dump(ch, open(os.path.join(live, "data", "manuscript", key + ".json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
+    if cover is not None:
+        json.dump(cover, open(os.path.join(live, "data", "cover.json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
+    cdir = os.path.join(live, "data", "coverimg")
+    if cover_parts or os.path.isdir(cdir):
+        os.makedirs(cdir, exist_ok=True)
+        for part in cover_parts:
+            json.dump(part, open(os.path.join(cdir, "p-%02d.json" % part["i"]), "w", encoding="utf-8"))
+        for name in sorted(os.listdir(cdir)):  # parts left from an earlier, larger picture are emptied: nothing in the folder is ever deleted
+            m = re.match(r"^p-(\d\d)\.json$", name)
+            if m and int(m.group(1)) >= len(cover_parts):
+                json.dump({"sig": "", "i": int(m.group(1)), "of": 0, "data": ""}, open(os.path.join(cdir, name), "w", encoding="utf-8"))
 
 
 if __name__ == "__main__":