slidemind 0.3.20 → 0.4.1

package/src/builders/placement.mjs

@@ -0,0 +1,133 @@
+// Placement decisions the transcriber makes from the elements around a line:
+// the head its route carries (T28) and where a free line paints among the
+// shapes (T04).
+//
+// Shared by both clients; mirrored by scripts/sync-transcription-runtime.mjs —
+// no Node or CLI imports here (line-relations.mjs is mirrored alongside).
+
+import { isGround, routeSamples, stationsOf, touchedShape } from "./line-relations.mjs";
+
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+
+// ---- Heads (T28): PowerPoint draws a head 2/3/5 × the stroke, never scaled
+// from less than 2pt, and the render gate refuses a connector shorter than 2.5
+// of its heads (connector-derive.ts renderedArrowheadPx, MIN_CONNECTOR_ROUTE_HEADS).
+const HEAD_RATIO = { sm: 2, med: 3, lg: 5 };
+
+/** The shortest route a head of `size` fits on, on a `strokePx` stroke. */
+export const headRoutePx = (size, strokePx = 0) => 2.5 * HEAD_RATIO[size] * Math.max(strokePx, 8 / 3);
+
+/** The straight piece a cap at end `i` sits on, as the gate measures it; Infinity for a shape (not measured). */
+export function capRoutePx(n, i) {
+  const p = n?.object === "grp" ? n.children[i ? n.children.length - 1 : 0] : n;
+  return p?.object === "cxn" ? dist(p.start, p.end) : Infinity;
+}
+
+/** A free straight connector stretched about its midpoint to `len`, or null when it is glued or already that long. */
+export function stretched(n, len) {
+  if (n?.object !== "cxn" || n.prst !== "straightConnector1" || n.from?.node || n.to?.node) return null;
+  const d = dist(n.start, n.end);
+  if (!(d > 0) || d >= len) return null;
+  const k = (len - d) / 2 / d, dx = (n.end.x - n.start.x) * k, dy = (n.end.y - n.start.y) * k;
+  const start = { x: n.start.x - dx, y: n.start.y - dy }, end = { x: n.end.x + dx, y: n.end.y + dy };
+  return { ...n, start, end, from: { point: start }, to: { point: end } };
+}
+
+// ---- Paint order of a free line (T04). A rail, ring or divider runs BEHIND
+// the shapes on it (a timeline's stops, an orbit's satellites, the disc on a
+// divider) and above the panel it lies on. Painted last, it ran over its own
+// stations and the occlusion gate asked the agent to move them off it.
+
+/** Segment a→b passes through the inside of rect r (1px in): Liang–Barsky. */
+export function crosses(a, b, r) {
+  const x0 = r.x + 1, y0 = r.y + 1, x1 = r.x + r.w - 1, y1 = r.y + r.h - 1;
+  if (!(x1 > x0 && y1 > y0)) return false;
+  const dx = b.x - a.x, dy = b.y - a.y;
+  let t0 = 0, t1 = 1;
+  for (const [p, q] of [[-dx, a.x - x0], [dx, x1 - a.x], [-dy, a.y - y0], [dy, y1 - a.y]]) {
+    if (p === 0) {
+      if (q < 0) return false;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) t0 = Math.max(t0, t);
+    else t1 = Math.min(t1, t);
+    if (t0 > t1) return false;
+  }
+  return true;
+}
+/** Segment a→b runs through none of `elements` but those that hold all of it (its ground). */
+export const runsClear = (a, b, elements) => !elements.some((o) => o.w > 0 && o.h > 0 && !(holds(o, a) && holds(o, b)) && crosses(a, b, o));
+const holds = (r, p) => p.x >= r.x - 0.5 && p.y >= r.y - 0.5 && p.x <= r.x + r.w + 0.5 && p.y <= r.y + r.h + 0.5;
+
+const ROUND = new Set(["circle", "ellipse", "ring"]);
+// Marks a line measures (a target or threshold across bars): it stays above
+// them, as the image draws it. A filled path is no such mark here — on a ring
+// it is a band or a bead the ring passes behind.
+const MARKS = new Set(["bar"]);
+
+/** A written element as the line relation reads it (line-relations.mjs): its painted box. */
+export function shapeOf(el) {
+  const rect = { x: el.x, y: el.y, w: el.w, h: el.h };
+  const text = el.text != null && String(el.text).trim() !== "";
+  return {
+    rect,
+    outline: { ellipse: el.kind === "disc" || ROUND.has(el.shape), poly: null },
+    content: ["icon", "image", "chart"].includes(el.kind),
+    alpha: 1,
+    lines: text ? [rect] : [],
+  };
+}
+
+// The index of the first painted element the line must run behind — a
+// station of it (line-relations.mjs: an opaque node threaded near its centre,
+// the disc on a divider, a timeline's stop), or for a plain line a node one of
+// its ends sits in (it runs out from behind it) — that paints after
+// everything it must lie above: its ground (the shape under most of it), for
+// a headed line the nodes its ends sit in (a head stays on top), and the marks
+// it runs across (a threshold over its bars). Null: none, and it paints last,
+// above whatever else it crosses. One relation with the draft check: it reads
+// these same predicates off the render (connector-occlusion.ts), which leaves
+// a node holding an end free either way.
+function seatOf({ points, capped, strokePx = 0 }, placed) {
+  const segs = points.slice(1).map((b, i) => [points[i], b]);
+  const ends = [points[0], points.at(-1)];
+  const shapes = placed.map(({ el }) => shapeOf(el));
+  const endRects = ends.map((p) => ({ x: p.x, y: p.y, w: 0, h: 0 }));
+  for (const p of ends) {
+    const node = touchedShape(p, shapes, strokePx / 2 + 2);
+    if (node) endRects.push(node.rect);
+  }
+  // A bead reads as a dot on its line whichever paints first: drawn on it.
+  const stations = new Set(stationsOf(points, shapes, endRects));
+  const samples = routeSamples(points);
+  let after = -1;
+  const behind = [];
+  placed.forEach(({ el, at }, k) => {
+    const across = () => segs.some(([a, b]) => crosses(a, b, el));
+    const holdsEnd = ends.some((p) => holds(el, p));
+    if (isGround(shapes[k], points, false, samples) || (capped && holdsEnd) || (MARKS.has(el.kind) && across())) after = Math.max(after, at);
+    else if (stations.has(shapes[k]) || holdsEnd) behind.push(at);
+  });
+  const first = Math.min(...behind.filter((at) => at > after));
+  return Number.isFinite(first) ? first : null;
+}
+
+/**
+ * The slide's JSX lines with the line directives placed. `lines`: the written
+ * elements in paint order; `placed`: `[{ el, at }]` — each painted element's
+ * rect and the index of its first JSX line; `entries`: the line directives in
+ * order, `{ jsx, points, capped, strokePx }` for a free line (glued and headed
+ * relations, marks and plot strokes carry no `points`). A free line goes right
+ * before its first station; every other directive paints last, in order.
+ */
+export function seatLines(lines, placed, entries) {
+  const before = new Map();
+  const last = [];
+  for (const x of entries) {
+    const at = x.points?.length >= 2 ? seatOf(x, placed) : null;
+    if (at == null) last.push(x.jsx);
+    else before.set(at, [...(before.get(at) ?? []), x.jsx]);
+  }
+  return [...lines.flatMap((l, i) => [...(before.get(i) ?? []), l]), ...last];
+}

package/src/builders/plan-checks.mjs

@@ -0,0 +1,135 @@
+// The checks both harnesses run on a plan.md, with one wording: the
+// `## Deliverable` block and the red thread against the storyboards (the deck
+// frame, docs/slidemind-cli-connect/17-deck-frame.md), and the full content
+// draft every body slide owes after sign-off (workflow/plan.md). Both refuse to
+// open a NEW plan round on a failing plan — the CLI's `slidemind plan`, the
+// add-in's `present_plan_for_review` — and never re-check an answer the user
+// already gave. The content draft is checked where it is owed: the CLI's deck
+// stage and concepts refusal, the add-in's `use_design_worker`.
+//
+// Canonical here; the add-in ships a byte-identical mirror
+// (scripts/sync-transcription-runtime.mjs). Pure: no Node builtins, and what a
+// layout's job is stays with each harness — the caller passes it in.
+
+import { extractRedThreadMessages, splitPlanMarkdownIntoSegments } from "./storyboard-markdown.mjs";
+
+/** The head of a refused plan round; each harness adds its own next step. */
+export const PLAN_NOT_PRESENTED = "Not presented: the plan does not agree with itself or with the design.";
+
+/**
+ * What a body slide's content draft holds — one wording for every message
+ * that asks for it. The rule itself is workflow/plan.md's.
+ */
+export const CONTENT_DRAFT =
+  "each body slide's full content draft, written from its approved key points as one entry of connected prose that says everything the slide has to say: " +
+  "every key point as a plain sentence, in order, with the facts, figures, examples and caveats behind it and things it compares stated in the same terms — " +
+  "never the key points restated, a few words per point, headings, bullets or a line per point, and no word on presentation; " +
+  "drawn from the user's context, online research and your own knowledge in that order, every number from the user's context or your research (workflow/plan.md)";
+
+/** The `## Deliverable` block, read leniently: the agent writes it and the user edits it by hand. */
+export function parseDeliverable(markdown) {
+  const m = /^##\s+Deliverable\s*\n([\s\S]*?)(?=^##\s|(?![\s\S]))/m.exec(markdown ?? "");
+  if (!m) return null;
+  const get = (key) => {
+    const r = new RegExp(`^\\s*-?\\s*${key}\\s*:\\s*(.+)$`, "im").exec(m[1]);
+    return r ? r[1].trim() : null;
+  };
+  const shape = (get("shape") ?? "").toLowerCase().replace(/[^a-z]/g, "");
+  const body = Number.parseInt(get("body slides") ?? get("body") ?? "", 10);
+  const frameRaw = (get("frame") ?? "").toLowerCase();
+  const frame = /^(none|-|—|no)\b/.test(frameRaw)
+    ? []
+    : frameRaw.split(/[,;/·]+/).map((x) => x.trim().replace(/s$/, "")).filter(Boolean);
+  return {
+    shape: shape === "deck" || shape === "slides" ? shape : null,
+    bodySlides: Number.isFinite(body) ? body : null,
+    frame,
+    target: get("target"),
+  };
+}
+
+const pcWholeSlideRebuild = (data) =>
+  (data.assetUses ?? []).some((u) => u?.fidelity === "reconstruct" && u?.reconstructionScope === "slide");
+
+/**
+ * The body slides still owing their full content draft. A frame slide (chrome
+ * with text slots; `isFrameSlide` is the harness's rule) owes none, nor does a
+ * slide rebuilt whole from a supplied image: its words are the image's.
+ * `drafted` names slides whose draft travels beside the plan (the add-in's
+ * `slideContent`).
+ */
+export function bodySlidesWithoutContent(markdown, { isFrameSlide, drafted = new Set() }) {
+  return splitPlanMarkdownIntoSegments(markdown ?? "")
+    .filter((s) => s.type === "storyboard" && Number.isFinite(s.data?.slide))
+    .filter((s) => !isFrameSlide(s.data) && !pcWholeSlideRebuild(s.data) && !s.data.content?.length && !drafted.has(s.data.slide))
+    .map((s) => s.data.slide);
+}
+
+/**
+ * `[plan:error]` lines for a plan whose deliverable block, red thread and
+ * storyboards do not agree with each other or with the design's layouts — a
+ * plan round does not open while any stands. `slideJob(data)` is the slide's
+ * planned job (`content` or a frame kind), `isFrameJob(job)` the harness's
+ * frame test, `offeredJobs` every layout job the design offers.
+ */
+export function planCheckErrors(markdown, { slideJob, isFrameJob, offeredJobs = [] }) {
+  const out = [];
+  const beats = [];
+  for (const segment of splitPlanMarkdownIntoSegments(markdown ?? "")) {
+    if (segment.type !== "storyboard" || !segment.data) continue;
+    const data = segment.data;
+    if (!data.role) out.push(`[plan:error] slide ${data.slide} has no role: write \`"role": "body"\` or \`"role": "frame"\` with its frameKind.`);
+    if (data.role === "frame" && !data.frameKind) out.push(`[plan:error] frame slide ${data.slide} needs a frameKind: cover, agenda, divider or closing.`);
+    beats.push({ slide: data.slide, job: slideJob(data) });
+  }
+  if (beats.length === 0) return out;
+  const frameBeats = beats.filter((b) => isFrameJob(b.job));
+  const bodyBeats = beats.filter((b) => !isFrameJob(b.job));
+  // One move per body slide: the review's storyline rail pairs them one-to-one.
+  const moves = extractRedThreadMessages(markdown ?? "").length;
+  if (moves !== bodyBeats.length) {
+    out.push(
+      `[plan:error] the red thread has ${moves} move${moves === 1 ? "" : "s"} for ${bodyBeats.length} body slide${bodyBeats.length === 1 ? "" : "s"} — write one move per body slide under \`## Red thread\`; frame slides go on its \`Frame:\` line.`,
+    );
+  }
+  const d = parseDeliverable(markdown);
+  if (!d) {
+    out.push(
+      "[plan:error] the plan has no `## Deliverable` block (shape: deck | slides, body slides: N, frame: <kinds or none>, target). " +
+        "Without it the frame (cover, agenda, dividers, closing) is unspecified.",
+    );
+    return out;
+  }
+  const offered = [...new Set(offeredJobs.filter((job) => isFrameJob(job)))];
+  // A design with no frame layout ships a deck without a frame; the plan names what is left out.
+  if (d.shape === "deck" && frameBeats.length === 0 && offered.length > 0) {
+    out.push(
+      `[plan:error] shape is deck but no storyboard is a frame slide — this design offers ${offered.join(", ")}; a deck ships its frame (workflow/flow.md → Loose slides or a whole presentation).`,
+    );
+  }
+  if (d.shape === "slides" && frameBeats.length > 0 && d.frame.length === 0) {
+    out.push(
+      `[plan:error] shape is slides but slide${frameBeats.length > 1 ? "s" : ""} ${frameBeats.map((b) => b.slide).join(", ")} ${frameBeats.length > 1 ? "are frame slides" : "is a frame slide"} (${[...new Set(frameBeats.map((b) => b.job))].join(", ")}) — loose slides extend a deck that has its own frame; drop ${frameBeats.length > 1 ? "them" : "it"} or set shape: deck.`,
+    );
+  }
+  if (d.bodySlides != null && d.bodySlides !== bodyBeats.length) {
+    out.push(
+      `[plan:error] Deliverable says body slides: ${d.bodySlides}, the storyboards carry ${bodyBeats.length} body slide${bodyBeats.length === 1 ? "" : "s"} (frame slides excluded).`,
+    );
+  }
+  for (const want of d.frame) {
+    if (!isFrameJob(want)) continue;
+    if (!frameBeats.some((b) => b.job === want)) {
+      out.push(`[plan:error] frame lists ${want} but no storyboard declares that frameKind.`);
+    }
+  }
+  const cover = frameBeats.find((b) => b.job === "cover");
+  if (cover && beats.some((b) => b.slide < cover.slide)) {
+    out.push(`[plan:error] the cover is slide ${cover.slide} — a cover is slide 1.`);
+  }
+  const closing = frameBeats.find((b) => b.job === "closing");
+  if (closing && beats.some((b) => b.slide > closing.slide)) {
+    out.push(`[plan:error] the closing is slide ${closing.slide} but slides follow it — a closing is the last slide.`);
+  }
+  return out;
+}

package/src/builders/plan-comments.mjs

@@ -0,0 +1,19 @@
+// One bullet per plan-gate comment, exactly as the agent reads it:
+// `- [Slide 3: "Align the next outcome"] text` or `- [Whole story] text`.
+// Continuation lines are indented under their bullet so a multi-line note
+// cannot read as a second comment. The anchor words stay English in every UI
+// language: they are agent-facing.
+//
+// Canonical here; the add-in's plan review formats its comments with a
+// byte-identical mirror (scripts/sync-transcription-runtime.mjs), so the
+// in-app manager and the CLI agent read one format. Pure, browser-safe.
+
+/** `comment`: `{ scope: "slide" | "story", slideIndex, slideHeading, text }`. */
+export function planCommentBullet(comment) {
+  const anchor =
+    comment.scope === "slide"
+      ? `Slide ${comment.slideIndex ?? "?"}${comment.slideHeading ? `: "${comment.slideHeading}"` : ""}`
+      : "Whole story";
+  const [first, ...rest] = String(comment.text).split("\n");
+  return [`- [${anchor}] ${first}`, ...rest.map((line) => `  ${line}`)].join("\n");
+}

package/src/builders/plan-handlers.mjs

@@ -0,0 +1,95 @@
+// The generic plan view: plan.md as ONE Markdown value, read and saved by the
+// persistent workspace on a core-owned deck. The value is the complete file;
+// the hash is `sha256:` over its UTF-8 bytes, which is also the plan-approval
+// task subject (plan.mjs hashes the same bytes for plan-review.json). Markdown
+// has no fields to merge, so a save lands only when one side is unchanged since
+// the editor's base — otherwise it is a whole-file `local_conflict`.
+//
+// A deck whose plan page belongs to an extension (a pack's record) is refused
+// here with the command that opens it: the pack's adapter serves that plan.
+// Handlers return `{ status, body }` the way the pack's reviewHandlers do, so a
+// daemon route and a standalone shell reply identically.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+import { planPageOwner } from "../lib/deck-paths.mjs";
+import { writePlanPage } from "./plan.mjs";
+
+export const GENERIC_PLAN_ADAPTER = "core-plan";
+
+export function hashPlanText(value) {
+  return "sha256:" + crypto.createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+function refusal(status, code, message, details) {
+  return { status, body: { ok: false, error: { code, message, retryable: false, ...(details ? { details } : {}) } } };
+}
+
+function ownerRefusal(deckDir) {
+  const owner = planPageOwner(deckDir);
+  if (owner.owner === "core") return null;
+  return refusal(
+    409,
+    "extension_owned",
+    `the plan of this deck belongs to ${owner.owner}` +
+      (owner.reviewCommand ? ` — open it with \`${owner.reviewCommand}\`` : "; its owner is not installed here"),
+    { owner: owner.owner, reviewCommand: owner.reviewCommand, recordPath: owner.recordPath },
+  );
+}
+
+function readPlanFile(deckDir) {
+  try {
+    return fs.readFileSync(path.join(deckDir, "plan.md"), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+/** `{ value, hash, format, adapterId }` — or 404 `plan_missing` / 409 `extension_owned`. */
+export function readGenericPlan(deckDir) {
+  const blocked = ownerRefusal(deckDir);
+  if (blocked) return blocked;
+  const value = readPlanFile(deckDir);
+  if (value === null) return refusal(404, "plan_missing", "this deck has no plan.md yet");
+  return { status: 200, body: { value, hash: hashPlanText(value), format: "markdown", adapterId: GENERIC_PLAN_ADAPTER } };
+}
+
+/**
+ * Save the complete plan.md from an editor that loaded `base`. Whole-file
+ * three-way: the write lands when nobody else wrote since base, is a no-op
+ * when the editor changed nothing (or the file already holds its text), and
+ * is a 409 `local_conflict` carrying current/base/mine otherwise — nothing is
+ * written on a conflict. A real write re-renders plan.html like every other
+ * writer of the record.
+ */
+export function saveGenericPlan(deckDir, { base, value } = {}) {
+  const blocked = ownerRefusal(deckDir);
+  if (blocked) return blocked;
+  if (typeof value !== "string") return refusal(422, "validation_failed", "value must be the complete plan.md text");
+  if (!base || typeof base.value !== "string" || base.hash !== hashPlanText(base.value)) {
+    return refusal(422, "validation_failed", "base.hash does not match base.value");
+  }
+  const current = readPlanFile(deckDir) ?? "";
+  let next;
+  if (current === base.value) next = value;
+  else if (value === base.value || current === value) next = current;
+  else {
+    return refusal(409, "local_conflict", "plan.md changed since this editor loaded it", {
+      current: { value: current, hash: hashPlanText(current) },
+      base,
+      mine: { value, hash: hashPlanText(value) },
+    });
+  }
+  const changed = next !== current;
+  if (changed) {
+    const planPath = path.join(deckDir, "plan.md");
+    const tmp = `${planPath}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    fs.writeFileSync(tmp, next);
+    fs.renameSync(tmp, planPath);
+    writePlanPage(deckDir);
+  }
+  return { status: 200, body: { value: next, hash: hashPlanText(next), savedLocally: true, changed } };
+}

package/src/builders/plan-markdown-edit.mjs

@@ -11,9 +11,9 @@
  *
  * Pure string logic — no DOM, no Office (unit-testable).
  *
- * 1:1 port of the add-in's plan-markdown-edit.ts. Top-level helpers are
- * prefixed `pme…` to keep the single-IIFE browser bundle collision-free;
- * exported API names match the add-in verbatim.
+ * Canonical here; the add-in imports a byte-identical mirror
+ * (scripts/sync-transcription-runtime.mjs). Top-level helpers are prefixed
+ * `pme…` to keep the single-IIFE browser bundle collision-free.
  */
 
 export function isEditableKind(kind) {