slidemind 0.3.19 → 0.4.0

package/src/builders/draft-lines.mjs

@@ -0,0 +1,369 @@
+// Transport-free draft diagnostics. Both clients use the same counts and asset rules.
+import { contains, pathDistance, pointRef, sanitizeTrace } from "./line-fit.mjs";
+import { fitNative, nodePreset, toleranceFor } from "./line-native.mjs";
+import { readLines } from "./concept-lines.mjs";
+import { connectorPaths, measuredFromRender } from "./settle.mjs";
+import { arrange, correspond, linesWithin, repeatGroups } from "./repeat-groups.mjs";
+import { fixedAspect } from "./concept-layout.mjs";
+
+// What each draft line asks for — one table for both clients (the add-in's
+// see_draft and build_and_push, the CLI's view-draft, review and delivery).
+// A DEFECT is a measured fault in what would ship: text on text, a word too
+// wide for its frame, one text split into boxes, a missing approved image or
+// asset, an element a preserved slide lost; any other `[<rule>:error]` is a
+// gate refusal. A defect holds the user's gate and delivery until a fresh
+// draft shows it fixed. An ADVISORY names a difference to check against the
+// concept and never holds anything (repairing every one was a second loop per
+// build). Lines outside the table are notes.
+export const DRAFT_DEFECT_TAGS = Object.freeze([
+  "overlap:warn",
+  "fit:warn",
+  "split:error",
+  "image:error",
+  "asset:error",
+  "preserve:warn",
+  "preserve:error",
+]);
+export const DRAFT_ADVISORY_TAGS = Object.freeze([
+  "fill:warn",
+  "type:warn",
+  "image:warn",
+  "image:note",
+  "repeat:warn",
+  "list:warn",
+  "split:warn",
+]);
+
+/** "defect", "advisory", or null for a line that is not a draft line. */
+export function draftLineTier(line) {
+  const tag = /^\s*\[([a-z-]+:[a-z]+)\]/.exec(String(line ?? ""))?.[1];
+  if (!tag) return null;
+  if (DRAFT_ADVISORY_TAGS.includes(tag)) return "advisory";
+  if (DRAFT_DEFECT_TAGS.includes(tag) || tag.endsWith(":error")) return "defect";
+  return null;
+}
+
+export function borrowedAssetOwner(stem, file) {
+  const owner = /^(\d\d)[-_.]/.exec(file)?.[1];
+  if (!owner) return null;
+  const mine = /^(\d\d)[-_.]/.exec(stem)?.[1];
+  if (!mine || mine === owner) return null;
+  return owner;
+}
+
+// An arrow is a line with a head (concept-lines.mjs counts the concept's the
+// same way). A render that carries no caps (the add-in's render evidence keeps
+// only `{ native }`) counts every line, as before.
+const HEAD = /^(?:triangle|stealth|arrow|diamond):/;
+const headed = (c) => !("capStart" in c || "capEnd" in c) || HEAD.test(c.capStart ?? "") || HEAD.test(c.capEnd ?? "");
+
+export const countRendered = (render) => {
+    const have = { arrows: 0, charts: 0, icons: 0 };
+    const walk = (box) => {
+      if (!box || typeof box !== "object") return;
+      if (box.connector && !box.connector.native && headed(box.connector)) have.arrows += 1;
+      if (box.chart) have.charts += 1;
+      if (box.imgSrc) have.icons += 1;
+      for (const c of box.children ?? []) walk(c);
+    };
+    for (const b of render?.boxes ?? []) walk(b);
+    return have;
+  };
+
+// What each line tells the agent to DO, per client: the diagnosis is shared,
+// the remedy names the tools that client's agent actually has. The defaults are
+// the CLI's commands.
+export const CLI_REMEDIES = {
+  sourceIcon: "search the image engine for the motif, then for what the element stands for (the step, label or claim it anchors), and attach the result that carries that meaning with `download-result --name <the referenced file>`",
+  specHint: "state/concept-specs/concept-slide-NN.json",
+  borrowed: (stem) => `download-result --name ${stem.slice(0, 2)}-<element id>.svg`,
+  missing: (file) => `Retry transcribe when the engine failed to answer; when it found no match, source another motif for what the element stands for (download-result --name ${file})`,
+};
+
+export function imageCountLines({ fileName, src, render, want, fromSpec = true, lowered = [], remedies = CLI_REMEDIES }) {
+    const source = fromSpec ? "the concept spec lists" : "the image shows";
+    const stem = fileName.replace(/\.[^.]+$/, "");
+    // Every line is a native line directive, glued or free; the render counts them.
+    const have = render?.boxes
+      ? countRendered(render)
+      : {
+          // Each line tag, then its cap attributes, in whatever order they come.
+          arrows: (src.match(/<[^<>]*\bdata-(?:connector|sm-line)\b[^<>]*>/g) ?? [])
+            .filter((tag) => [...tag.matchAll(/\sdata-cap-(?:start|end)="([^"]*)"/g)].some((m) => HEAD.test(m[1]))).length,
+          charts: (src.match(/<Chart\b/g) ?? []).length,
+          icons: (src.match(/<img\b/g) ?? []).length,
+        };
+    const label = { arrows: "rendered connector", charts: "rendered chart", icons: "rendered icon" };
+    const lines = [];
+    if (lowered.length) {
+      lines.push(
+        `[image:warn] ${stem} — the image line was lowered (${lowered.join(", ")}). The count is the image's, not the JSX's: the first count stands, add the missing elements.`,
+      );
+    }
+    for (const k of ["arrows", "charts", "icons"]) {
+      if (want[k] != null && have[k] < want[k]) {
+        // Icons come from an engine that may lack a motif (x29: two
+        // double-chevron glyphs no search returned), so an icon shortfall is
+        // a note; arrows and charts are drawn, so theirs is a warning
+        // (DRAFT_ADVISORY_TAGS: both are checked against the concept, neither
+        // holds a gate). A motif without a match is not a meaning without one:
+        // the remedy is another motif for the element's meaning, never a
+        // stand-in for the set (x114).
+        const advisory = k === "icons";
+        lines.push(
+          `[image:${advisory ? "note" : "warn"}] ${stem} — ${source} ${k}=${want[k]}, the render has ${have[k]} ${label[k]}${have[k] === 1 ? "" : "s"}. ${advisory ? `Each missing icon is a visible hole the reviewer will see: ${remedies.sourceIcon}. An engine that is unavailable or timed out has not answered — retry and keep the motif. Deleting the element, or setting a number, letter or plain shape in its place or across its set, does not fix it: every member keeps an asset in the set's one box, and only a brand with no image engine anchors a set typographically (composition.md → Icons and imagery).` : `Add the missing ${k}${fromSpec ? ` (${remedies.specHint} names each one)` : ""}.`}`,
+        );
+      }
+    }
+    return lines;
+}
+
+export function missingAssetLines({ fileName, src, hasAsset, hasBundleAsset = () => false, remedies = CLI_REMEDIES }) {
+    const stem = fileName.replace(/\.[^.]+$/, "");
+    const lines = [];
+    const seen = new Set();
+    for (const m of src.matchAll(/["'`]\.\/assets\/([^"'`{}\s]+)["'`]/g)) {
+      const file = m[1];
+      if (seen.has(file)) continue;
+      seen.add(file);
+      const owner = borrowedAssetOwner(stem, file);
+      if (owner) {
+        lines.push(
+          `[asset:error] ${stem} — ./assets/${file} was fetched for slide ${owner}, and its colour was chosen for that slide's background. Source the required motif with this slide's colour (${remedies.borrowed(stem)}). Do not substitute an unrelated same-slide icon or delete approved content to clear this diagnostic.`,
+        );
+        continue;
+      }
+      if (hasAsset(file)) continue;
+      // A brand chrome/master asset lives ONLY in the bundle cache — it is never
+      // copied into a deck. `rewriteBrandAssetRefs` (src/builders/build.mjs)
+      // redirects exactly these names to the brand URL when the deck does not
+      // own a file of that name, and the server resolves them from the design,
+      // so they are not missing. Mirror that rule rather than a bare prefix
+      // test: a deck that DOES own `assets/master-data.png` fell out above.
+      if (/^(?:chrome|master)-/.test(file) && hasBundleAsset(file)) continue;
+      lines.push(
+        `[asset:error] ${stem} — ./assets/${file} is referenced but not on disk. ${remedies.missing(file)}; do not delete approved content or substitute unrelated artwork.`,
+      );
+    }
+    return lines;
+}
+
+const ROUND = new Set(["circle", "ellipse", "ring"]);
+const MAX_LINE_SHAPE_LINES = 6;
+const SHAPE_WORD = { straight: "straight line", orthogonal: "elbow", curve: "curve", arc: "arc", polyline: "polyline" };
+// A fitted connector's shape attributes as the slide writes them.
+const shapeAttrs = (n) => [
+  ...(n.from?.node ? [] : [`data-from="${pointRef(n.start)}"`]),
+  ...(n.to?.node ? [] : [`data-to="${pointRef(n.end)}"`]),
+  `data-prst="${n.prst}"`,
+  ...(Object.keys(n.av ?? {}).length ? [`data-adj="${Object.entries(n.av).map(([k, v]) => `${k}:${Math.round(v)}`).join(",")}"`] : []),
+  ...(n.rot ? [`data-rot="${n.rot}"`] : []),
+  ...(n.from?.node ? [`data-from-site="${n.from.site}"`] : []),
+  ...(n.to?.node ? [`data-to-site="${n.to.site}"`] : []),
+].join(" ");
+
+/**
+ * Every rendered connector measured against the line the concept draws, the
+ * way the fitter measures it: the directive's own preset, adjusts, turn and
+ * sites (the slide source `src`) placed over the nodes as the render measured
+ * them, evaluated by the shared preset evaluator, compared with the spec's
+ * trace. A line beyond tolerance is named with its distance — the shape the
+ * reviewer will see is wrong even though the count is right.
+ */
+export function lineShapeLines({ fileName, spec, src, render }) {
+  if (!render?.boxes?.length || !spec || !src) return [];
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const byId = new Map((spec.elements ?? []).map((e) => [e.id, e]));
+  const round = (id) => { const e = byId.get(id); return e?.kind === "disc" || ROUND.has(e?.shape); };
+  // The concept was read onto a slot of the spec's size; a render on another
+  // (a layout canvas change) moves every line, which no shape knob undoes.
+  const slot = spec.slot;
+  const root = render.boxes[0]?.rect;
+  if (root && (Math.abs(root.w - slot.w) > 1 || Math.abs(root.h - slot.h) > 1)) return [];
+  const read = new Map(readLines(structuredClone(spec)).lines.map((l) => [l.id, l]));
+  const measured = measuredFromRender(render, spec.slot);
+  // A line drawn on a painted element (a mark on its disc) moves with it: its
+  // place is judged where that element renders, not where the sketch put it.
+  const carried = (line) => {
+    const el = byId.get(line?.source?.id);
+    const on = el?.parent ? byId.get(el.parent) : null;
+    const m = on?.fill && on.fill !== "none" && contains(on, el) ? measured.get(on.id) : null;
+    return m ? { x: m.x - on.x, y: m.y - on.y } : { x: 0, y: 0 };
+  };
+  // A free straight rule drawn inside a card (a divider under its title) is
+  // the card's layout, placed by the settle (text fit, one template per set),
+  // not a relationship the concept routes: its place is judged by the text
+  // and occlusion checks, never by the sketch's pixel position.
+  const rules = new Set((spec.elements ?? [])
+    .filter((e) => e.fill && e.fill !== "none" && !fixedAspect(e) && e.w > 0 && e.h > 0)
+    .flatMap((e) => linesWithin(spec, e))
+    .filter((c) => !c.from && !c.to && (c.route ?? "straight") === "straight")
+    .map((c) => c.id));
+  const out = [];
+  for (const c of connectorPaths(src, measured, spec)) {
+    if (rules.has(c.id)) continue;
+    const line = read.get(c.id);
+    const shift = carried(line);
+    const raw = (line?.path?.points ?? []).filter((p) => Number.isFinite(p?.x) && Number.isFinite(p?.y)).map((p) => ({ x: p.x + shift.x, y: p.y + shift.y }));
+    if (!(raw.length >= 2)) continue;
+    const trace = sanitizeTrace(raw, c.fromBox, c.toBox, { fromRound: round(c.fromEnd.node), toRound: round(c.toEnd.node) });
+    // The fitter's class: an end the concept glues keeps the glued tolerance
+    // after the fitter freed it onto the ink (no site near where it attaches).
+    const glued = Boolean(c.fromEnd.node || c.toEnd.node || line.ends?.some((e) => e.node));
+    const tolerance = toleranceFor(trace, glued);
+    const distance = pathDistance(c.points, trace);
+    if (!(Number.isFinite(distance) && distance > tolerance)) continue;
+    // The ONE directive the concept's shape names at these nodes: the fitter's
+    // own answer on the rendered geometry, never a search left to the agent.
+    const nodes = new Map(line.ends.filter((e) => e.node && measured.has(e.node)).map((e) => [e.node, nodePreset(byId.get(e.node), measured.get(e.node))]).filter(([, n]) => n));
+    const ends = line.ends.map((e) => ({ ...e, at: e.at && { x: e.at.x + shift.x, y: e.at.y + shift.y } }));
+    const fit = fitNative({ ...line, ends, path: { ...line.path, points: raw } }, nodes, null, { slot });
+    const shape = SHAPE_WORD[line.path?.kind] ?? "line";
+    const fix = fit?.object === "cxn" && fit.devPx <= tolerance && fit.devPx < distance - 1
+      ? `Set ${shapeAttrs(fit)} — the one directive that draws the concept's ${shape} here — and keep it.`
+      : `No directive at these nodes draws the concept's ${shape} closer: keep this one and name the difference in your reply.`;
+    out.push(`[image:warn] ${stem} — the line ${c.id} (${c.from} → ${c.to}) runs ${Math.round(distance)}px from the concept's line (tolerance ${Math.round(tolerance)}px). Judge its shape (straight, elbow, curve or arc), not its pixels: where you aligned or evened the nodes on purpose, the line follows them. ${fix} Never try presets or sites one by one to quiet this.`);
+  }
+  if (out.length > MAX_LINE_SHAPE_LINES) {
+    const more = out.length - MAX_LINE_SHAPE_LINES;
+    return [...out.slice(0, MAX_LINE_SHAPE_LINES), `[image:warn] ${stem} — ${more} more line${more === 1 ? "" : "s"} off the concept's shape.`];
+  }
+  return out;
+}
+
+const REPEAT_TOL = 3; // px: two members of one set may differ by rendering noise only (text tops round per line box)
+
+/**
+ * A set the reader declared (spec.repeats) as it renders now: one size, one
+ * inner layout, the arrangement's symmetry. The transcriber builds it that
+ * way; this names what an edit changed on one member and not the others. Text
+ * heights follow their copy and are not compared.
+ */
+export function repeatLines({ fileName, spec, render }) {
+  if (!render?.boxes?.length || !spec?.repeats?.length) return [];
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const m = measuredFromRender(render, spec.slot);
+  const rendered = { ...spec, elements: (spec.elements ?? []).map((e) => (m.has(e.id) ? { ...e, ...pick(m.get(e.id)) } : e)) };
+  const out = [];
+  const r = (n) => Math.round(n);
+  for (const g of repeatGroups(rendered)) {
+    // A virtual member (a row of loose parts) is its parts' box: rendered when they all are.
+    const members = g.members.filter((e) => (e.ids ? e.ids.every((id) => m.has(id)) : m.has(e.id)));
+    if (members.length < 2) continue;
+    const name = `${g.id} (${members.map((e) => (e.ids ? `(${e.ids.join(" + ")})` : e.id)).join(", ")})`;
+    // Its box follows its words, so only its inner layout is compared.
+    const loose = members.some((e) => e.virtual);
+    const size = (e) => `${r(e.w)}×${r(e.h)}px`;
+    // An engine icon's own aspect is kept by the equal box's `fit="contain"`,
+    // never by sizing each member's box to its asset.
+    const aspect = (els) => (els.some((e) => m.get(e.id)?.content) ? ` A picture keeps its own aspect inside an equal box (fit="contain").` : "");
+    const off = loose ? [] : members.filter((e) => Math.abs(e.w - members[0].w) > REPEAT_TOL || Math.abs(e.h - members[0].h) > REPEAT_TOL);
+    if (off.length) {
+      out.push(`[repeat:warn] ${stem} — ${name} is one organism but renders in ${[...new Set(members.map(size))].join(" and ")}. Give every member the same size.${aspect(members)}`);
+      continue;
+    }
+    const kids = correspond(rendered.elements, members);
+    for (const [k, first] of (kids?.[0] ?? []).entries()) {
+      const rel = kids.map((l, i) => ({ e: l[k], x: l[k].x - members[i].x, y: l[k].y - members[i].y }));
+      const text = first.kind === "text";
+      const odd = rel.find((q) => Math.abs(q.x - rel[0].x) > REPEAT_TOL || Math.abs(q.y - rel[0].y) > REPEAT_TOL
+        || Math.abs(q.e.w - rel[0].e.w) > REPEAT_TOL || (!text && Math.abs(q.e.h - rel[0].e.h) > REPEAT_TOL));
+      if (odd) out.push(`[repeat:warn] ${stem} — ${name}: #${odd.e.id} sits at ${r(odd.x)},${r(odd.y)} (${size(odd.e)}) in its card, #${rel[0].e.id} at ${r(rel[0].x)},${r(rel[0].y)} (${size(rel[0].e)}). One inner layout: change every member alike.${aspect([odd.e])}`);
+    }
+    const at = loose ? null : arrange({ ...g, members }, members[0].w, members[0].h);
+    const drift = at && members.map((e, i) => ({ e, d: Math.hypot(e.x + e.w / 2 - at[i].x, e.y + e.h / 2 - at[i].y) })).filter((q) => q.d > REPEAT_TOL);
+    if (drift?.length) out.push(`[repeat:warn] ${stem} — ${name} is a ${g.arrangement}${g.hub ? ` around #${g.hub.id}` : ""}, but ${drift.map((q) => `#${q.e.id} sits ${r(q.d)}px off it`).join(", ")}. Move the members together so the ${g.arrangement} stays even${g.arrangement === "ring" ? " and symmetric about its hub" : ""}.`);
+  }
+  return out;
+}
+
+const pick = (v) => ({ x: v.x, y: v.y, w: v.w, h: v.h });
+
+// The items the concept declares (concept-lists.mjs: `marker` on a text or
+// on a block's paragraphs) against the `<li>` the slide writes. x101–x105: 22
+// native lists left the first draft and came back as plain paragraphs or
+// typed glyphs — a flattened list the glyph lint alone cannot name when the
+// glyphs are gone too. A slide built from set components counts its template
+// once, so it is not compared.
+export function listLines({ fileName, spec, src }) {
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const source = String(src ?? "");
+  if (!source || /const Repeat\d+ = /.test(source)) return [];
+  const declared = (spec?.elements ?? []).reduce((n, e) => n + (e.paragraphs ? e.paragraphs.filter((p) => p.marker).length : e.marker ? 1 : 0), 0);
+  if (!declared) return [];
+  const written = (source.match(/<li[\s>]/g) ?? []).length;
+  if (written >= declared) return [];
+  return [`[list:warn] ${stem} — the concept declares ${declared} list item${declared === 1 ? "" : "s"}; the slide writes ${written} <li>. A flattened list: restore the <L> (bullet="✓" for ticks) with one <li> per item — a title that should not be bulleted becomes a <P>, never the whole list.`];
+}
+
+// ---------------------------------------------------------------------------
+// Preservation — what a preserved slide still owes, in one vocabulary and one
+// wording on both clients (the add-in's preservation-gate.ts / render-batch.ts,
+// the CLI's draft-check.mjs): `[preserve:warn]` an obligation this draft
+// breaks (a defect), `[preserve:error]` a record nobody can read (delivery
+// refuses until repaired). What no draft can answer is not a draft line: the
+// agent cannot act on it, and delivery names it as a limitation.
+// ---------------------------------------------------------------------------
+
+// Failures that mean the element itself is gone.
+const GONE = new Set(["removed_from_source", "absent_from_render", "absent_from_package"]);
+
+// What a required element showed, so a line names content, not a number.
+function shownAs(req) {
+  if (req?.excerpt) return ` "${req.excerpt}"`;
+  if (req?.mediaRef) return ` (picture ${req.mediaRef})`;
+  if (req?.kind === "native-object") return " (embedded object)";
+  if (req?.properties?.includes("chart")) return " (chart)";
+  return "";
+}
+
+const stemOf = (fileName) => String(fileName).replace(/\.[^.]+$/, "");
+
+/**
+ * One `[preserve:warn]` per element with a FAILED check, every failed check of
+ * it in one line. An element that is gone gets the one fix — its id back on the
+ * element that shows it (`data-sm-source-id={87}` for an imported shape); any
+ * other failure is restored in the slide's file. `supersede` is the client's
+ * way to declare an intended removal (the CLI's scoped revision), or null where
+ * the agent has none of its own.
+ */
+export function preservationFailureLines({ fileName, checks, active, supersede = null }) {
+  const byElement = new Map();
+  for (const c of checks ?? []) {
+    if (c?.status !== "failed") continue;
+    byElement.set(c.elementId ?? null, [...(byElement.get(c.elementId ?? null) ?? []), c]);
+  }
+  const stem = stemOf(fileName);
+  const or = supersede ? `, or ${supersede}` : "";
+  const refuses = "; a final replacement refuses while it stands.";
+  return [...byElement].map(([elementId, failed]) => {
+    const req = (active ?? []).find((r) => r?.elementId === elementId);
+    const where = elementId != null ? `#${elementId}${shownAs(req)}` : "the slide";
+    if (elementId != null && req?.kind !== "connection" && failed.every((c) => GONE.has(c.reason ?? ""))) {
+      const why = [...new Set(failed.map((c) => c.reason))].join(", ");
+      const idAttr = /^\d+$/.test(String(elementId)) ? `data-sm-source-id={${elementId}}` : `id="${elementId}"`;
+      return `[preserve:warn] ${stem} — ${where}: no longer on the slide (${why}) — it must stay: put ${idAttr} on the element that shows it${or}${refuses}`;
+    }
+    const what = failed
+      .map((c) => {
+        const detail = String(c.detail ?? "");
+        const said = elementId != null && detail.startsWith(`${elementId} `) ? detail.slice(String(elementId).length + 1) : detail;
+        return `${c.reason ?? "no reason given"}${c.scope ? ` (${c.scope})` : ""}${said ? ` — ${said}` : ""}`;
+      })
+      .join("; ");
+    return `[preserve:warn] ${stem} — ${where}: ${what} — restore it in slides/${fileName}${or}${refuses}`;
+  });
+}
+
+/**
+ * `[preserve:error]` — the deck's preservation record cannot be read, so
+ * nothing about what its slides must keep can be verified and delivery
+ * refuses until it is repaired. The record is not the agent's to edit.
+ */
+export function preservationUnreadableLine({ fileName, detail = null }) {
+  return (
+    `[preserve:error] ${stemOf(fileName)} — this deck's preservation record could not be read` +
+    `${detail ? ` (${detail})` : ""}; nothing could be verified about what its slides must keep, and delivery ` +
+    `refuses until it is repaired. This is not a slide defect: never edit that file — name the problem in your reply.`
+  );
+}

package/src/builders/edit-route.mjs

@@ -0,0 +1,29 @@
+// Which route a deck is on, read from disk. Its own module because BOTH gates
+// ask it — plan.mjs imports review.mjs, so the predicate cannot live in either
+// without a cycle.
+import fs from "node:fs";
+import path from "node:path";
+
+import { splitPlanMarkdownIntoSegments } from "./storyboard-markdown.mjs";
+import { readRevision } from "../lib/revision.mjs";
+
+/**
+ * A deck that already EXISTS — adopted from someone's .pptx — with no storyboard
+ * in its plan.md is on the EDIT route, not the authoring route. Neither gate
+ * applies: there is no plan to sign off (the deck is the plan, and the
+ * storyboard gate exists to approve a story before it is built), and no preview
+ * to approve (the .pptx was the user's before any agent touched it, and changes
+ * go straight into it — the same rule as an authored deck after its one
+ * review). Manufacturing an approval for either would be a checkmark nobody gave.
+ */
+export function isEditRouteDeck(deckDir) {
+  const revision = readRevision(deckDir);
+  if (revision?.origin?.kind !== "adopted") return false;
+  let markdown = "";
+  try {
+    markdown = fs.readFileSync(path.join(deckDir, "plan.md"), "utf8");
+  } catch {
+    return true;
+  }
+  return splitPlanMarkdownIntoSegments(markdown).every((s) => s.type !== "storyboard");
+}