create-religion 1.0.0 → 1.1.0

package/dist/lib/state.js

@@ -6,6 +6,7 @@
  * because the commands that use this are how someone finds out what is wrong.
  */
 import crypto from "node:crypto";
+import fs from "node:fs/promises";
 import { readIfPresent, statePath } from "./paths.js";
 const CHECKBOX = /^(\s*)- \[( |x|X)\]\s*(.*)$/;
 export function parsePlan(source) {
@@ -46,28 +47,184 @@ export function parseWork(source) {
     };
     if (!source || /_Nothing in progress\./.test(source))
         return empty;
-    const steps = [...source.matchAll(/^\s*- \[( |x|X)\]\s*(?:\*\*)?(.+?)(?:\*\*)?(?:\s+-\s|$)/gim)];
+    // The step's name is its bold text, which itself contains " - " in the template's shape.
+    // Spaces and tabs only: `\s` here crosses newlines, which made blank lines quadratic and
+    // joined consecutive unbolded steps into one.
+    const steps = [...source.matchAll(/^[ \t]*- \[( |x|X)\][ \t]*(?:\*\*(.+?)\*\*|(.+?)(?:[ \t]-[ \t]|$))/gim)];
     const done = steps.filter((s) => (s[1] ?? " ").toLowerCase() === "x").length;
+    const next = steps.find((s) => (s[1] ?? " ").toLowerCase() !== "x");
     return {
         active: true,
-        title: /^#\s+(.+)$/m.exec(source)?.[1]?.trim() ?? null,
-        type: /^\*\*Type:\*\*\s*(.+)$/m.exec(source)?.[1]?.trim() ?? null,
-        status: /^\*\*Status:\*\*\s*(.+)$/m.exec(source)?.[1]?.trim() ?? null,
+        title: field(source, "#"),
+        type: field(source, "Type"),
+        status: field(source, "Status"),
         stepsDone: done,
         stepsTotal: steps.length,
-        nextStep: steps.find((s) => (s[1] ?? " ").toLowerCase() !== "x")?.[2]?.trim() ?? null
+        nextStep: (next?.[2] ?? next?.[3])?.trim() ?? null
     };
 }
-export function parseFindings(source) {
+function field(source, name) {
+    const pattern = name === "#" ? /^#\s+(.+)$/m : new RegExp(`^\\*\\*${name}:\\*\\*\\s*(.+)$`, "m");
+    return pattern.exec(source)?.[1]?.trim() ?? null;
+}
+/** The active spec as written, for showing rather than deciding. Null when nothing is in progress. */
+export function parseSpec(source) {
+    if (!source || /_Nothing in progress\./.test(source))
+        return null;
+    const section = sections(source);
+    return {
+        title: field(source, "#"),
+        type: field(source, "Type"),
+        planItem: field(source, "From build plan")?.replace(/^item\s+/i, "") ?? null,
+        status: field(source, "Status"),
+        goal: (section.get("goal") ?? "").split(/\n\s*\n/).map(join).filter(Boolean),
+        inScope: bullets(section.get("in scope")),
+        outOfScope: bullets(section.get("out of scope")),
+        files: bullets(section.get("files and areas")),
+        steps: bullets(section.get("build steps"), true).map(parseStep)
+    };
+}
+/** Each heading's body, keyed by the lowercased heading; `levels` widens it to `###` too. */
+function sections(source, levels = "##") {
+    const found = new Map();
+    const parts = source.split(new RegExp(`^(?:${levels})\\s+(.+)$`, "m"));
+    for (let index = 1; index < parts.length; index += 2) {
+        found.set((parts[index] ?? "").trim().toLowerCase(), parts[index + 1] ?? "");
+    }
+    return found;
+}
+/** Top-level list items with their wrapped lines joined; with `checkbox`, only `- [ ]` items, tick kept. */
+function bullets(body, checkbox = false) {
+    if (!body)
+        return [];
+    const items = [];
+    for (const line of body.split(/\r?\n/)) {
+        if (/^- /.test(line))
+            items.push(line.slice(2));
+        else if (/^\s+\S/.test(line) && items.length > 0)
+            items[items.length - 1] += " " + line.trim();
+        else if (line.trim() !== "" && items.length > 0)
+            items.push("");
+    }
+    const kept = items.filter(Boolean).map((item) => item.trim());
+    return checkbox ? kept.filter((item) => /^\[( |x|X)\]/.test(item)) : kept;
+}
+function parseStep(item) {
+    const done = /^\[(x|X)\]/.test(item);
+    const text = item.replace(/^\[( |x|X)\]\s*/, "");
+    const bold = /^\*\*(.+?)\*\*\s*(?:-\s+)?([\s\S]*)$/.exec(text);
+    const name = bold?.[1] ?? text.split(" - ")[0] ?? "";
+    const rest = bold ? (bold[2] ?? "") : text.slice(name.length).replace(/^\s*-\s+/, "");
+    const [label, ...title] = name.split(" - ");
+    const [what, doneWhen] = rest.split(/\*Done when:\*\s*/);
+    return {
+        label: title.length > 0 ? (label ?? "").trim() : "",
+        title: (title.length > 0 ? title.join(" - ") : name).trim(),
+        what: (what ?? "").trim(),
+        doneWhen: doneWhen?.trim() ?? null,
+        done
+    };
+}
+export const HISTORY_KINDS = ["features", "fixes", "rollbacks", "refactors", "spikes"];
+/** One archive under `history/<kind>/`, named `NN-slug.md`. */
+export function parseArchive(kind, file, source) {
+    const spec = parseSpec(source);
+    const section = sections(source, "#{2,3}");
+    const repairs = spec?.steps.filter((step) => /^repair\b/i.test(step.label)).length ?? 0;
+    return {
+        kind,
+        file,
+        number: /^0*(\d+[a-z]?)-/i.exec(file)?.[1] ?? null,
+        title: spec?.title ?? null,
+        type: spec?.type ?? null,
+        status: spec?.status ?? null,
+        steps: (spec?.steps.length ?? 0) - repairs,
+        repairs,
+        commits: (labelled(source, "Commits") ?? "").split(/[\s,]+/).filter((sha) => /^[0-9a-f]{7,40}$/.test(sha)),
+        findings: [...source.matchAll(/^###\s+(?:[\w-]+\/)?(F-\d+)\s+\[(P[0-3])\]\s+(\w+)\s+-\s+(.+)$/gm)].map((m) => ({
+            id: m[1],
+            severity: m[2],
+            status: m[3],
+            title: (m[4] ?? "").trim()
+        })),
+        wentWrong: blocks(section.get("what went wrong on the way")),
+        deferred: blocks(section.get("deferred"))
+    };
+}
+/** Every archive, newest first within each kind; an absent folder contributes nothing. */
+export async function readHistory(root) {
+    const archives = [];
+    for (const kind of HISTORY_KINDS) {
+        let names;
+        try {
+            names = await fs.readdir(statePath(root, "history", kind));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names.filter((n) => n.endsWith(".md") && n !== "README.md").sort().reverse()) {
+            const source = await readIfPresent(statePath(root, "history", kind, name));
+            if (source !== null)
+                archives.push(parseArchive(kind, name, source));
+        }
+    }
+    return archives;
+}
+/** The inbox's one-line notes, `- 2026-09-05 - text`, with the date when one leads. */
+export function parseInbox(source) {
     if (!source)
         return [];
-    return [...source.matchAll(/^###\s+(F-\d+)\s+\[(P[0-3])\]\s+(\w+)\s+-\s+(.+)$/gim)].map((m) => ({
-        id: m[1],
-        severity: m[2],
-        status: m[3],
-        title: (m[4] ?? "").trim()
+    return [...source.matchAll(/^- (?:(\d{4}-\d{2}-\d{2}) - )?(.+)$/gm)].map((m) => ({
+        date: m[1] ?? null,
+        text: (m[2] ?? "").trim()
     }));
 }
+/** Paragraphs and list items, each as one line of text. */
+function blocks(body) {
+    if (!body)
+        return [];
+    return body
+        .split(/\n\s*\n/)
+        .flatMap((paragraph) => (/^\s*- /.test(paragraph) ? bullets(paragraph) : [join(paragraph)]))
+        .filter(Boolean);
+}
+function join(paragraph) {
+    return paragraph.split(/\r?\n/).map((line) => line.trim()).join(" ").trim();
+}
+export function parseFindings(source) {
+    if (!source)
+        return [];
+    const entries = source.split(/^(?=###\s)/m);
+    return entries.flatMap((entry) => {
+        const m = /^###\s+(F-\d+)\s+\[(P[0-3])\]\s+(\w+)\s+-\s+(.+)$/im.exec(entry);
+        if (!m)
+            return [];
+        // A finding raised while building has no lens: "2026-09-26 while writing the guide".
+        // Matching from the last parenthesis, with no two parts able to take the same spaces, keeps this linear.
+        const found = labelled(entry, "Found");
+        const paren = found ? found.lastIndexOf("(") : -1;
+        const lensed = found && paren >= 0 ? /^\((?:scope:[^;)]*;\s*)?lens:([^)]+)\)\s*$/.exec(found.slice(paren)) : null;
+        return [
+            {
+                id: m[1],
+                severity: m[2],
+                status: m[3],
+                title: (m[4] ?? "").trim(),
+                file: labelled(entry, "File"),
+                found: lensed && found ? found.slice(0, paren).trim() : found,
+                lens: lensed ? (lensed[1] ?? "").trim() : null,
+                why: labelled(entry, "Why it matters"),
+                fix: labelled(entry, "Suggested fix"),
+                resolution: labelled(entry, "Resolution")
+            }
+        ];
+    });
+}
+/** The text after `**Label:**` on its line, or null when the label is absent or empty. */
+function labelled(entry, label) {
+    const value = new RegExp(`^\\*\\*${label}:\\*\\*[ \\t]*(.*)$`, "m").exec(entry)?.[1]?.trim();
+    return value ? value : null;
+}
 export function parseOpenQuestions(overview) {
     if (!overview)
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-religion",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A file-backed, spec-driven AI development workflow. Spec before code, small reviewed diffs, and project state in markdown so a cleared context costs nothing.",
   "license": "MIT",
   "author": "Nate",