slidemind 0.3.13 → 0.3.14

package/src/builders/draft-check.mjs

@@ -0,0 +1,376 @@
+// Draft-check mechanics — the CLI-owned half of `slidemind view-draft`.
+//
+// The measured rules (fill bands, type scale, text overlap) are NOT here: they
+// live in the add-in and reach the CLI as the capture engine's `draftChecks`
+// export (`capture.mjs` → `loadDraftChecks`), so in-app see_draft and
+// view-draft run one rule set with one wording. What stays CLI-side is what
+// only exists in the CLI's world: the asset-plan.md inventory form, the
+// .draft-preview record and the gates it arms, and the 422 translate parser.
+// Images are never overlaid: a magenta proportion grid on the concept and the
+// render dominated both and hid whether the slide was built well.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export const ASSET_PLAN_FILE = "asset-plan.md";
+export const DRAFT_CHECK_FILE = path.join(".draft-preview", "draft-check.json");
+
+// ---------------------------------------------------------------------------
+// Inventory — asset-plan.md as a form the build reads (port of inventory.ts).
+// ---------------------------------------------------------------------------
+
+const SLIDE_HEADING_RE = /^## Slide (\d+)\b/;
+const SLIDE_FILE_NUMBER_RE = /^(\d{1,3})[-_.]/;
+const SECTION_RE = /^(regions|organisms|connectors|icons):/;
+const FETCHED_ASSET_RE = /^(engine|gen)-/;
+// "none", "(none)", "n/a", "no connectors …", "none authorable …" — an
+// explicit empty row, never a listed organism/connector.
+const NONE_RE = /^\(?\s*(none|n\/a|no\b)/i;
+
+const pad2 = (n) => String(n).padStart(2, "0");
+
+/** Seed the inventory form once (never overwrites a filled one). `images`: [{slideNumber,label}]. */
+export function seedAssetPlan(deckDir, images) {
+  const file = path.join(deckDir, ASSET_PLAN_FILE);
+  if (!images?.length || fs.existsSync(file)) return false;
+  const slides = [...images]
+    .sort((a, b) => a.slideNumber - b.slideNumber)
+    .map((img) =>
+      [
+        `## Slide ${pad2(img.slideNumber)} — ${img.label ?? `Slide ${img.slideNumber}`}`,
+        `jsx: slides/${pad2(img.slideNumber)}-<name>.jsx`,
+        "regions:",
+        "- ",
+        "organisms:",
+        "- ",
+        "connectors:",
+        "- ",
+        "icons:",
+        "- ",
+        "",
+      ].join("\n"),
+    );
+  fs.writeFileSync(
+    file,
+    [
+      "# Asset plan — concept inventory",
+      "",
+      "Fill this BEFORE writing any slide, from `concepts/concept-slide-NN.png` (the BODY region only —",
+      "chrome goes through layout props). One bullet per line; the",
+      "draft check counts `connectors:` against the JSX and every fetched asset against the slides.",
+      "",
+      "- regions: split of the content slot in percentages of its width/height, e.g. `hero left x0–60 y0–100`, `rail right x65–100`, `callout bottom y85–100`.",
+      "- organisms: every card, figure, badge, chip row, callout, loop, satellite — region, share, alignment.",
+      "- connectors: `from → to, straight|elbow|curved, arrow end|both|none, solid|dashed` — one per arrow/line in the mockup.",
+      "- icons: subject, prominence, engine query; append the fetched `assets/<file>` when sourced, or `(no result)`.",
+      "",
+      "After `slidemind view-draft`, under each slide add `draft-check:` followed by ONE tick line per",
+      "organism row: `- [x] <organism>` when it is in the render at the concept's position and share,",
+      "`- [ ] <organism> — <what differs>` when it is not. `review` refuses to open while a slide has",
+      "fewer ticks than organisms or any `[ ]` left — fix the miss in the JSX, re-render, re-tick.",
+      "",
+      ...slides,
+    ].join("\n"),
+  );
+  return true;
+}
+
+function parseAssetPlan(text) {
+  const out = new Map();
+  let current = null;
+  let section = "";
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    const heading = SLIDE_HEADING_RE.exec(line);
+    if (heading) {
+      current = { filled: false, connectors: 0, organisms: 0, icons: 0, iconsResolved: 0, verdict: null, ticked: 0, unticked: 0 };
+      out.set(Number(heading[1]), current);
+      section = "";
+      continue;
+    }
+    if (!current) continue;
+    if (/^draft-check:/i.test(line)) {
+      current.verdict = line.slice("draft-check:".length).trim();
+      section = "draft-check";
+      continue;
+    }
+    if (section === "draft-check") {
+      const tick = /^-\s*\[( |x|X)\]/.exec(line);
+      if (tick) {
+        if (tick[1] === " ") current.unticked += 1;
+        else current.ticked += 1;
+        continue;
+      }
+    }
+    const sec = SECTION_RE.exec(line);
+    if (sec) {
+      section = sec[1];
+      // Inline form (`connectors: a -> b, …; c -> d, …`) counts like bullets —
+      // agents write both shapes; only the seeded form uses bullets.
+      const inline = line.slice(sec[0].length).trim();
+      if (inline && !NONE_RE.test(inline)) {
+        if (section === "organisms" || section === "regions") current.filled = true;
+        if (section === "connectors") {
+          current.connectors += inline.split(";").filter((x) => x.trim()).length;
+        }
+      }
+      continue;
+    }
+    if (!line.startsWith("-")) continue;
+    const body = line.slice(1).trim();
+    if (!body || NONE_RE.test(body)) continue;
+    if (section === "organisms" || section === "regions") current.filled = true;
+    if (section === "organisms") current.organisms += 1;
+    if (section === "connectors") current.connectors += 1;
+    if (section === "icons") {
+      current.icons += 1;
+      // Resolved = a fetched file appended, or an explicit "(no result)".
+      if (/assets\/|\(no result\)/i.test(body)) current.iconsResolved += 1;
+    }
+  }
+  return out;
+}
+
+/**
+ * The asset plan as stage facts: per slide whether the inventory is filled,
+ * how many icon rows exist and how many are resolved. null without a plan.
+ */
+export function assetPlanSummary(deckDir) {
+  const planFile = path.join(deckDir, ASSET_PLAN_FILE);
+  if (!fs.existsSync(planFile)) return null;
+  let plan;
+  try {
+    plan = parseAssetPlan(fs.readFileSync(planFile, "utf8"));
+  } catch {
+    return null;
+  }
+  const out = { slides: plan.size, unfilled: 0, icons: 0, iconsResolved: 0 };
+  for (const inv of plan.values()) {
+    if (!inv.filled) out.unfilled += 1;
+    out.icons += inv.icons;
+    out.iconsResolved += inv.iconsResolved;
+  }
+  return out;
+}
+
+function countConnectors(jsx) {
+  const attached = (jsx.match(/data-connector\b/g) ?? []).length;
+  const markers = (jsx.match(/marker-(?:end|start)\s*=/g) ?? []).length;
+  return attached + markers;
+}
+
+/**
+ * `[inventory:warn]` lines for the deck: per authored slide (inventory empty,
+ * connectors listed > drawn) plus fetched assets no slide references. Empty
+ * when the deck has no asset-plan.md.
+ */
+export function inventoryWarnings(deckDir, jsxFiles = null) {
+  const planFile = path.join(deckDir, ASSET_PLAN_FILE);
+  if (!fs.existsSync(planFile)) return [];
+  let plan;
+  try {
+    plan = parseAssetPlan(fs.readFileSync(planFile, "utf8"));
+  } catch {
+    return [];
+  }
+  if (plan.size === 0) return [];
+  const slidesDir = path.join(deckDir, "slides");
+  const allJsx = fs.existsSync(slidesDir)
+    ? fs.readdirSync(slidesDir).filter((f) => f.endsWith(".jsx")).sort()
+    : [];
+  const files = jsxFiles ?? allJsx;
+  const lines = [];
+  for (const file of files) {
+    const num = SLIDE_FILE_NUMBER_RE.exec(file);
+    if (!num) continue;
+    const inv = plan.get(Number(num[1]));
+    if (!inv) continue;
+    const jsxPath = `slides/${file}`;
+    if (!inv.filled) {
+      lines.push(
+        `[inventory:warn] ${jsxPath} — asset-plan.md has no regions/organisms rows for this slide. Inventory its concept mockup (every organism, its region and share) and rebuild from that list, not from memory.`,
+      );
+      continue;
+    }
+    let jsx = "";
+    try {
+      jsx = fs.readFileSync(path.join(slidesDir, file), "utf8");
+    } catch {
+      continue;
+    }
+    const drawn = countConnectors(jsx);
+    if (inv.connectors > drawn) {
+      lines.push(
+        `[inventory:warn] ${jsxPath} — asset-plan.md lists ${inv.connectors} connector${inv.connectors === 1 ? "" : "s"} for this slide, the JSX draws ${drawn} (data-connector / marker-end). Draw the missing ones per workflow/authoring.md → Arrow contract; a mockup connector is never dropped.`,
+      );
+    }
+  }
+  // Fetched assets nobody references: the mockup staged them, the deck lost them.
+  const referenced = allJsx
+    .map((f) => {
+      try {
+        return fs.readFileSync(path.join(slidesDir, f), "utf8");
+      } catch {
+        return "";
+      }
+    })
+    .join("\n");
+  const assetsDir = path.join(deckDir, "assets");
+  const assets = fs.existsSync(assetsDir) ? fs.readdirSync(assetsDir).sort() : [];
+  const planText = fs.readFileSync(planFile, "utf8");
+  for (const file of assets) {
+    if (!FETCHED_ASSET_RE.test(file)) continue;
+    if (referenced.includes(file)) continue;
+    if (new RegExp(`${file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]*\\(unused\\)`).test(planText)) continue;
+    lines.push(
+      `[inventory:warn] assets/${file} was fetched for this deck but no slide references it — place it where the mockup stages that icon (\`<img src="./assets/${file}">\`), or mark it \`(unused)\` in asset-plan.md.`,
+    );
+  }
+  return lines;
+}
+
+// ---------------------------------------------------------------------------
+// The draft-check record — what `review` refuses on.
+// ---------------------------------------------------------------------------
+
+export function hashFile(file) {
+  return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+
+/** Persist the measured defects per slide, keyed by the jsx content hash. */
+export function saveDraftCheck(deckDir, slides) {
+  const file = path.join(deckDir, DRAFT_CHECK_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const record = { version: 1, at: new Date().toISOString(), slides: {} };
+  for (const s of slides) record.slides[s.fileName] = { hash: s.hash, defects: s.defects };
+  fs.writeFileSync(file, JSON.stringify(record, null, 2) + "\n");
+  return record;
+}
+
+export function loadDraftCheck(deckDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(deckDir, DRAFT_CHECK_FILE), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Standing measured defects: the last view-draft flagged them and the jsx has
+ * not changed since. null when nothing stands (no record, all fixed, or the
+ * slide was edited after the check — the next view-draft re-measures it).
+ */
+export function draftCheckBlocker(deckDir) {
+  const record = loadDraftCheck(deckDir);
+  if (!record?.slides) return null;
+  const standing = [];
+  for (const [fileName, entry] of Object.entries(record.slides)) {
+    if (!entry?.defects?.length) continue;
+    const file = path.join(deckDir, "slides", fileName);
+    if (!fs.existsSync(file)) continue;
+    if (hashFile(file) !== entry.hash) continue;
+    standing.push(...entry.defects);
+  }
+  if (standing.length === 0) return null;
+  return (
+    `the last draft check measured ${standing.length} defect${standing.length === 1 ? "" : "s"} that still stand ` +
+    `(the slide files are unchanged since). Fix them in the JSX, re-run \`slidemind view-draft\`, then \`review\`:\n` +
+    standing.map((l) => `  ${l}`).join("\n")
+  );
+}
+
+
+// ---------------------------------------------------------------------------
+// The self-check verdict — an inventory, not an opinion.
+//
+// Every `draft-check:` verdict on disk across 181 judged sessions reads
+// "matches" (15 of 15), including slides the judge scored 0.71 with eight
+// organisms missing. A verdict is free; a tick per organism is not — the
+// agent has to find each one in the render or say what differs.
+// ---------------------------------------------------------------------------
+
+/**
+ * Concept-seeded slides whose asset-plan.md section lists organisms but whose
+ * `draft-check:` is missing, ticks fewer organisms than listed, or leaves a
+ * `[ ]` standing. null when every such slide is fully ticked.
+ */
+export function verdictBlocker(deckDir) {
+  const planFile = path.join(deckDir, ASSET_PLAN_FILE);
+  if (!fs.existsSync(planFile)) return null;
+  let plan;
+  try {
+    plan = parseAssetPlan(fs.readFileSync(planFile, "utf8"));
+  } catch {
+    return null;
+  }
+  const slidesDir = path.join(deckDir, "slides");
+  const conceptsDir = path.join(deckDir, "concepts");
+  const files = fs.existsSync(slidesDir)
+    ? fs.readdirSync(slidesDir).filter((f) => f.endsWith(".jsx")).sort()
+    : [];
+  const problems = [];
+  for (const file of files) {
+    const num = SLIDE_FILE_NUMBER_RE.exec(file);
+    if (!num) continue;
+    const n = Number(num[1]);
+    const inv = plan.get(n);
+    if (!inv || inv.organisms === 0) continue;
+    if (!fs.existsSync(path.join(conceptsDir, `concept-slide-${pad2(n)}.png`))) continue;
+    const ticks = inv.ticked + inv.unticked;
+    if (inv.verdict === null) {
+      problems.push(`slides/${file}: no draft-check verdict — asset-plan.md lists ${inv.organisms} organisms; open the concept and the render together and tick each one`);
+    } else if (inv.unticked > 0) {
+      problems.push(`slides/${file}: ${inv.unticked} organism${inv.unticked === 1 ? "" : "s"} ticked [ ] (differs) — fix in the JSX, re-run view-draft, re-tick`);
+    } else if (ticks < inv.organisms) {
+      problems.push(`slides/${file}: asset-plan.md lists ${inv.organisms} organisms, the verdict ticks ${ticks} — one \`- [x]\`/\`- [ ]\` line per organism`);
+    }
+  }
+  if (problems.length === 0) return null;
+  return (
+    "the self-check is incomplete — a verdict is one tick per organism, not one word:\n" +
+    problems.map((l) => `  ${l}`).join("\n")
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Translate-gate errors — the server's slot-fit / diagram-geometry /
+// connector-endpoints verdicts, folded into the draft check so a builder
+// learns them on ITS slide before the deck-wide export, not five build-pptx
+// rounds later (x18: 17 of 39 minutes were that loop).
+// ---------------------------------------------------------------------------
+
+/**
+ * Split a translate 422 message into per-slide lines. The server writes
+ * `<file>.jsx: <rule>: <summary>` headers followed by `  [<rule>:error] <stem> — …`
+ * lines; both are kept, keyed by the jsx file name. Unattributed lines land
+ * under "" so nothing is lost.
+ */
+export function parseTranslateErrors(message) {
+  const out = new Map();
+  const add = (file, line) => {
+    if (!out.has(file)) out.set(file, []);
+    out.get(file).push(line);
+  };
+  const text = String(message ?? "").replace(/^[^\n]*\/translate:\s*/, "");
+  let current = "";
+  for (const raw of text.split("\n")) {
+    const line = raw.trimEnd();
+    if (!line.trim()) continue;
+    const head = /^\s*(\S+\.jsx):\s+([a-z-]+):\s+(.*)$/.exec(line);
+    if (head) {
+      current = head[1];
+      add(current, `[${head[2]}:error] ${head[1]} — ${head[3]}`);
+      continue;
+    }
+    const tagged = /^\s*\[([a-z-]+):error\]\s+(\S+)\s+—/.exec(line);
+    if (tagged) {
+      const stem = tagged[2];
+      const file = [...out.keys()].find((f) => f.replace(/\.jsx$/, "") === stem) ?? (current || stem + ".jsx");
+      add(file, line.trim());
+      continue;
+    }
+    add(current, line.trim());
+  }
+  return out;
+}

package/src/builders/lint.mjs

@@ -97,7 +97,8 @@ export async function lintSlidesOrThrow({ deckDir, slideFiles, layoutSources })
     primitives,
   });
 
-  for (const line of result.lines) {
+  const lines = collapseLintLines(result.lines);
+  for (const line of lines) {
     process.stderr.write(`${line}\n`);
   }
   if (!result.ok) {
@@ -106,7 +107,42 @@ export async function lintSlidesOrThrow({ deckDir, slideFiles, layoutSources })
       (result.warnings
         ? `, ${result.warnings} warning${result.warnings === 1 ? "" : "s"}`
         : "");
-    throw new Error(`${summary}\n${result.lines.join("\n")}`);
+    throw new Error(`${summary}\n${lines.join("\n")}`);
   }
   return result;
 }
+
+// The engine's lines, as an agent should read them: exact duplicates dropped,
+// and the one class it cannot act on — a connector ref whose id is built with
+// a template (`${…}`) and may well resolve at render time — folded into ONE
+// note per file. Verbatim, a 6-node loop printed twelve identical paragraphs
+// (one per data-from/data-to) that buried the single real warning under them.
+// The rule itself stays the add-in's; only the CLI's rendering changes.
+const DYNAMIC_ID_RE =
+  /^(\s*)\[lint:warn\] (\S+?):\d+ — `(data-(?:from|to)="[^"]*")` on a data-connector does not resolve against any static id on this slide, but the slide builds ids dynamically/;
+
+export function collapseLintLines(lines) {
+  const out = [];
+  const seen = new Set();
+  const dynamic = new Map(); // file → { indent, refs: [] }
+  for (const line of lines) {
+    if (seen.has(line)) continue;
+    seen.add(line);
+    const m = DYNAMIC_ID_RE.exec(line);
+    if (m) {
+      const entry = dynamic.get(m[2]) ?? { file: m[2], indent: m[1], refs: [] };
+      entry.refs.push(m[3].replace(/^data-(?:from|to)=/, ""));
+      if (!dynamic.has(m[2])) {
+        dynamic.set(m[2], entry);
+        out.push(entry); // placeholder keeps the file's position in the listing
+      }
+      continue;
+    }
+    out.push(line);
+  }
+  return out.map((item) =>
+    typeof item === "string"
+      ? item
+      : `${item.indent}[lint:note] ${item.file} — ${item.refs.length} connector ref${item.refs.length === 1 ? "" : "s"} (${[...new Set(item.refs)].slice(0, 4).join(", ")}${item.refs.length > 4 ? ", …" : ""}) use ids the slide builds with a template — they resolve at render time; check that each connector lands on its node in the draft render.`,
+  );
+}