slidemind 0.3.13 → 0.3.14

package/src/cli/slide-reuse.mjs

@@ -0,0 +1,334 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, LOCAL_PPTX_RE, resolveDeckArg, SRC_DIR } from "./common.mjs";
+import { expiredSearchMessage, resolveEngineRouting, deckBrandId, loginRequiredMessage, failOnEngineBlocker, describeEngineByteFailure, parseSearchIdArg, parsePicks, describeInsertSlideFailure, writeAddSlideResult } from "./engine-helpers.mjs";
+
+export async function cmdInsertSlide(rest) {
+  let searchId = null;
+  let picks = null;
+  let to = null;
+  let at = null;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--search") {
+      searchId = parseSearchIdArg(rest[++i]);
+    } else if (a === "--pick") {
+      picks = parsePicks(rest[++i]);
+    } else if (a === "--to") {
+      to = rest[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--at") {
+      const next = rest[++i];
+      const n = parseInt(next, 10);
+      if (!Number.isFinite(n) || n < 0) {
+        fail(`--at expects a non-negative integer, got '${next}'`);
+      }
+      at = n;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  if (searchId === null || !picks) {
+    fail("usage: slidemind insert-slide --search <id> --pick <n[,n,...]> --to <presId> [--at <N>]");
+  }
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  // Live insert types into an OPEN presentation, so it stays window- and
+  // pane-bound even where the rest of the engine surface has moved off the pane.
+  const registry = await client.requirePaneHost();
+  const entry = client.pickPresentationEntry(registry, to);
+  // Window identity for the client's single retry: a pane reconnect mints a NEW
+  // presId for the same window, and the design fingerprint re-matches it — but
+  // only against windows we did NOT already see next to the target, or a second
+  // deck on the same corporate design would take the insert.
+  const identity = {
+    fileName: entry.fileName ?? entry.title ?? null,
+    brandId: entry.brandId ?? null,
+    otherPresIds: registry
+      .map((p) => p.presId)
+      .filter((id) => id && id !== entry.presId),
+  };
+  // WHERE the searchId lives decides how the reuse runs. A number came from
+  // that window's own pane search and the pane resolves it; an opaque id is the
+  // backend's (the pane-free search) and the pane has never seen it — so those
+  // picks are extracted pane-free and inserted as bytes instead.
+  //
+  // Which backend extracts them is the RECORD's, not the window's. Those are
+  // different environments as soon as two are connected, and spending a
+  // server-owned id against the window's origin 404s as `unknown_search` — read
+  // as "the search expired", which sends the agent round a re-search loop that
+  // can never resolve. The window stays the INSERT target either way.
+  let engineBackendURL = null;
+  if (client.isOpaqueSearchId?.(searchId)) {
+    try {
+      engineBackendURL = await client.resolveSearchBackend(searchId);
+    } catch (err) {
+      await failOnEngineBlocker(client, err, { to: entry.presId });
+    }
+    if (!engineBackendURL) fail(expiredSearchMessage(searchId));
+  }
+  let res;
+  try {
+    res = engineBackendURL
+      ? await client.insertSlidesFromSearch({
+          presId: entry.presId,
+          searchId,
+          selections: picks,
+          at,
+          backendURL: entry.backendURL ?? null,
+          engineBackendURL,
+          ...identity,
+        })
+      : await client.insertSlideLive({
+          presId: entry.presId,
+          searchId,
+          selections: picks,
+          at,
+          backendURL: entry.backendURL ?? null,
+          ...identity,
+        });
+  } catch (err) {
+    fail(
+      (await loginRequiredMessage(client, err, { to: entry.presId })) ??
+        describeInsertSlideFailure(err, searchId),
+    );
+  }
+  if (!res?.ok) {
+    fail(`insert-slide failed: ${res?.error ?? "unknown error"}`);
+  }
+  process.stdout.write(
+    `Inserted ${res.insertedCount ?? picks.length} slide(s) into presentation ${res.presId ?? entry.presId}\n`,
+  );
+}
+
+export async function cmdAddSlide(rest) {
+  let searchId = null;
+  let picks = null;
+  let deck = null;
+  let at = null;
+  let to = null;
+  let from = null;
+  let asJson = false;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--json") {
+      asJson = true;
+    } else if (a === "--search") {
+      searchId = parseSearchIdArg(rest[++i]);
+    } else if (a === "--from") {
+      from = rest[++i];
+      if (!from) fail("--from expects a path to a .pptx file");
+    } else if (a === "--pick") {
+      picks = parsePicks(rest[++i]);
+    } else if (a === "--deck") {
+      deck = rest[++i];
+      if (!deck) fail("--deck expects a deck name or path");
+    } else if (a === "--to") {
+      to = rest[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--at") {
+      const next = rest[++i];
+      const n = parseInt(next, 10);
+      if (!Number.isFinite(n) || n < 0) {
+        fail(`--at expects a non-negative integer, got '${next}'`);
+      }
+      at = n;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+
+  // Host-free local source: fold picked slides from a .pptx on disk (no bridge
+  // client, no requirePaneHost). Mutually exclusive with --search; --to is
+  // accepted-but-ignored here (symmetric with the other reuse commands — there's
+  // no window to target when the source is a local file).
+  if (from !== null) {
+    if (searchId !== null) fail("--from and --search are mutually exclusive");
+    if (!picks || !deck) {
+      fail("usage: slidemind add-slide --from <file.pptx> --pick <n[,n,...]> --deck <deck> [--at <N>]");
+    }
+    const fromPath = path.isAbsolute(from)
+      ? from
+      : path.resolve(process.cwd(), from);
+    let st = null;
+    try {
+      st = fs.statSync(fromPath);
+    } catch {
+      st = null;
+    }
+    if (!st || !st.isFile() || !LOCAL_PPTX_RE.test(fromPath)) {
+      fail(`--from: '${from}' is not an existing PowerPoint file (.pptx/.pptm/.potx/.potm/.ppsx/.ppsm)`);
+    }
+    const deckDir = resolveDeckArg(deck);
+    const slidesDir = path.join(deckDir, "slides");
+    fs.mkdirSync(slidesDir, { recursive: true });
+
+    const { foldPickedSlides } = await import(
+      pathToFileURL(path.join(SRC_DIR, "pptx", "slide-swap.mjs")).href
+    );
+    let results;
+    try {
+      results = foldPickedSlides(fs.readFileSync(fromPath), picks, {
+        sourceName: path.basename(fromPath),
+      });
+    } catch (err) {
+      fail(`add-slide failed: ${err.message}`);
+    }
+
+    // Same filename math + write loop as the --search branch; results already
+    // carry a `.slideId` and `.bytes` (a Uint8Array of a one-slide package).
+    const reused = await import(
+      pathToFileURL(path.join(SRC_DIR, "lib", "reused-slides.mjs")).href
+    );
+    const existing = fs
+      .readdirSync(slidesDir)
+      .filter((f) => f.endsWith(".jsx") || f.endsWith(".pptx"));
+    const targets = reused.reusedSlideTargets(existing, results, at);
+    const written = [];
+    const slides = [];
+    results.forEach((r, i) => {
+      const target = path.join(slidesDir, targets[i].filename);
+      fs.writeFileSync(target, Buffer.from(r.bytes));
+      written.push(path.relative(process.cwd(), target));
+      slides.push({
+        selection: picks[i] ?? null,
+        slideId: r.slideId ?? null,
+        file: path.relative(process.cwd(), target),
+      });
+    });
+    writeAddSlideResult({
+      asJson,
+      searchId: null,
+      deckDir,
+      deck,
+      written,
+      slides,
+    });
+    return;
+  }
+
+  if (searchId === null || !picks || !deck) {
+    fail("usage: slidemind add-slide (--search <id> | --from <file.pptx>) --pick <n[,n,...]> --deck <deck> [--to <presId>] [--at <N>] [--json]");
+  }
+  const deckDir = resolveDeckArg(deck);
+  const slidesDir = path.join(deckDir, "slides");
+  fs.mkdirSync(slidesDir, { recursive: true });
+
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  // Direct path: an opaque searchId routes to the environment that minted the
+  // record; the deck's bound design only decides when the id can't. Pane path:
+  // the searchId is presentation-scoped, so --to targets the window the search
+  // ran on (without it, a registry with >1 open window is a dead-end).
+  const routing = await resolveEngineRouting(client, {
+    to,
+    brandId: await deckBrandId(deckDir),
+    searchId,
+  });
+  const presId = routing.presId;
+  const backendURL = routing.backendURL;
+
+  // Extract each picked slide's bytes over the bridge, then let the shared
+  // helper compute the play-order filenames (NN-reused-<shortid>.pptx). The
+  // prefix math lives in one shared unit (src/lib/reused-slides.mjs). Existing
+  // files are not renumbered.
+  const reused = await import(
+    pathToFileURL(path.join(SRC_DIR, "lib", "reused-slides.mjs")).href
+  );
+  const { createTransferProgress } = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "engine-download.mjs")).href
+  );
+  // Stream each pick to a provisional file: the play-order filename can only be
+  // computed once every pick is in hand, and buffering a multi-megabyte slide in
+  // memory just to name it would defeat the streaming path.
+  const extracted = [];
+  const cleanupTemps = () => {
+    for (const s of extracted) {
+      if (s.tempPath) fs.rmSync(s.tempPath, { force: true });
+    }
+  };
+  // A searchId can be an opaque server id on the direct path — keep it usable as
+  // a file name component.
+  const searchKey = String(searchId).replace(/[^A-Za-z0-9._-]/g, "_");
+  try {
+    for (const pick of picks) {
+      const tempPath = path.join(slidesDir, `.reused-${searchKey}-${pick}.part`);
+      if (typeof client.extractSlideToFile === "function") {
+        try {
+          const res = await client.extractSlideToFile({
+            presId,
+            searchId,
+            selection: pick,
+            destPath: tempPath,
+            backendURL,
+            onProgress: createTransferProgress(`extracting slide ${pick}`),
+          });
+          if (!res?.bytesWritten) throw new Error("stream produced no bytes");
+          extracted.push({ selection: pick, slideId: res.slideId ?? null, tempPath });
+          continue;
+        } catch (err) {
+          fs.rmSync(tempPath, { force: true });
+          const stale = await loginRequiredMessage(client, err, { to });
+          if (stale) {
+            cleanupTemps();
+            fail(stale);
+          }
+          // Route absent (bodyless 404 / 501) → this add-in predates the streaming
+          // route; fall through to the capped base64 ack path below. On the
+          // pane-free path there is no ack path to fall back to.
+          const routeMissing =
+            (err?.status === 404 && !err?.code) || err?.status === 501;
+          if (!routeMissing || !presId) {
+            const described = await describeEngineByteFailure(client, err, {
+              backendURL,
+            });
+            cleanupTemps();
+            fail(`add-slide failed for selection ${pick}: ${described ?? err.message}`);
+          }
+        }
+      }
+      const res = await client.extractSlide({
+        presId,
+        searchId,
+        selection: pick,
+        backendURL,
+      });
+      if (!res?.ok || !res.base64) {
+        cleanupTemps();
+        fail(`add-slide failed for selection ${pick}: ${res?.error ?? "no slide bytes returned"}`);
+      }
+      extracted.push({ selection: pick, slideId: res.slideId ?? null, base64: res.base64 });
+    }
+  } catch (err) {
+    cleanupTemps();
+    throw err;
+  }
+  const existing = fs
+    .readdirSync(slidesDir)
+    .filter((f) => f.endsWith(".jsx") || f.endsWith(".pptx"));
+  const targets = reused.reusedSlideTargets(existing, extracted, at);
+  const written = [];
+  const slides = [];
+  extracted.forEach((slide, i) => {
+    const target = path.join(slidesDir, targets[i].filename);
+    if (slide.tempPath) {
+      fs.renameSync(slide.tempPath, target);
+    } else {
+      fs.writeFileSync(target, Buffer.from(slide.base64, "base64"));
+    }
+    written.push(path.relative(process.cwd(), target));
+    slides.push({
+      selection: slide.selection,
+      slideId: slide.slideId ?? null,
+      file: path.relative(process.cwd(), target),
+    });
+  });
+  writeAddSlideResult({ asJson, searchId, deckDir, deck, written, slides });
+}

package/src/cli/status.mjs

@@ -0,0 +1,118 @@
+// The deck's stage, read from disk — the one answer an agent needs after a
+// context summarization, an interruption, or a hand-over: where does this deck
+// stand and what is the next command. `ready <deck>` prints it (the skill
+// already names `ready` as the first command after any continuation), so the
+// stage → re-read table that used to live in the skill's prose is a line of
+// output instead. Pure disk: no bridge call, no bundle read.
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { BUILDERS_DIR } from "./common.mjs";
+
+const load = (name) => import(pathToFileURL(path.join(BUILDERS_DIR, name)).href);
+
+export async function deckStage(deckDir) {
+  const slug = path.basename(deckDir);
+  const [plan, review, check, families] = await Promise.all([
+    load("plan.mjs"),
+    load("review.mjs"),
+    load("draft-check.mjs"),
+    load("visual-families.mjs"),
+  ]);
+  const slidesDir = path.join(deckDir, "slides");
+  const files = fs.existsSync(slidesDir) ? fs.readdirSync(slidesDir).sort() : [];
+  const jsx = files.filter((f) => f.endsWith(".jsx"));
+  const native = files.filter((f) => /\.pptx$/i.test(f));
+  const numberOf = (f) => Number(/^(\d{1,3})[-_.]/.exec(f)?.[1]);
+  const authored = new Set([...jsx, ...native].map(numberOf).filter(Number.isFinite));
+
+  const planPath = path.join(deckDir, "plan.md");
+  const planExists = fs.existsSync(planPath);
+  const planMarkdown = planExists ? fs.readFileSync(planPath, "utf8") : "";
+  const planned = planExists ? [...families.plannedSlideNumbers(planMarkdown)].sort((a, b) => a - b) : [];
+  const planState = plan.loadPlanState(deckDir);
+  const planApproved = planExists && plan.requirePlanApproved(deckDir) === null;
+
+  const conceptsDir = path.join(deckDir, "concepts");
+  const concepts = fs.existsSync(conceptsDir)
+    ? fs.readdirSync(conceptsDir).filter((f) => /^concept-slide-\d+\.png$/.test(f)).length
+    : 0;
+  const assets = check.assetPlanSummary(deckDir);
+
+  const record = check.loadDraftCheck(deckDir);
+  const draftFresh =
+    Boolean(record?.slides) &&
+    jsx.every((f) => record.slides[f] && record.slides[f].hash === check.hashFile(path.join(slidesDir, f)));
+  const standing = check.draftCheckBlocker(deckDir) ? Object.values(record?.slides ?? {}).reduce((n, e) => n + (e.defects?.length ?? 0), 0) : 0;
+  const selfCheck = check.verdictBlocker(deckDir) ? "incomplete" : "ok";
+
+  const reviewState = review.loadReviewState(deckDir);
+  const reviewCurrent = review.requireReviewApproved(deckDir) === null;
+
+  const missing = planned.filter((n) => !authored.has(n));
+  let name;
+  let next;
+  // No plan.md and no slides: nothing exists yet. No plan.md but slides: an
+  // adopted or hand-made deck on the edit route — no plan, no concepts.
+  if (authored.size === 0 && (!planExists || planned.length === 0)) {
+    name = "intake";
+    next = `write ${slug}/plan.md (## Red thread + ## Per-slide storyboards), then \`slidemind plan ${slug}\``;
+  } else if (planExists && !planApproved) {
+    name = "plan gate";
+    next = planState.decision === "comments"
+      ? `apply the comments in ${slug}/plan-review.json to plan.md, then \`slidemind plan ${slug}\``
+      : `\`slidemind plan ${slug}\` (wait for DECISION: approved)`;
+  } else if (planExists && concepts === 0 && authored.size === 0) {
+    name = "concepts";
+    next = `\`slidemind concepts ${slug}\`, then Read every concepts/concept-slide-NN.png and fill asset-plan.md`;
+  } else if (assets && (assets.unfilled > 0 || assets.iconsResolved < assets.icons) && missing.length > 0) {
+    name = "sourcing";
+    next = assets.unfilled > 0
+      ? `fill the regions/organisms/connectors/icons rows in ${slug}/asset-plan.md from the concept PNGs (${assets.unfilled} slide section${assets.unfilled === 1 ? "" : "s"} still empty)`
+      : `search + download the ${assets.icons - assets.iconsResolved} unresolved icon row${assets.icons - assets.iconsResolved === 1 ? "" : "s"} in ${slug}/asset-plan.md (\`slidemind search\` → \`download-result\`), append each file to its row`;
+  } else if (missing.length > 0) {
+    name = "authoring";
+    next = `Read concepts/concept-slide-${String(missing[0]).padStart(2, "0")}.png (batches of ≤3), then write slides/${missing.map((n) => `${String(n).padStart(2, "0")}-*.jsx`).join(", ")}; then \`slidemind view-draft ${slug}\``;
+  } else if (!draftFresh || standing > 0 || selfCheck !== "ok") {
+    name = "draft check";
+    next = !draftFresh
+      ? `\`slidemind view-draft ${slug}\` (slides changed since the last check${record ? "" : ", or never checked"})`
+      : standing > 0
+        ? `fix the ${standing} measured defect${standing === 1 ? "" : "s"} in the JSX, then \`slidemind view-draft ${slug}\``
+        : `tick every organism under \`draft-check:\` in ${slug}/asset-plan.md (concept vs .draft-preview pair), then \`slidemind review ${slug}\``;
+  } else if (!reviewCurrent) {
+    name = "review";
+    next = reviewState.decision === "comments"
+      ? `edit the files cited in ${slug}/review.json, \`slidemind view-draft ${slug}\`, then \`slidemind review ${slug}\``
+      : `\`slidemind review ${slug}\` (wait for DECISION: approved)`;
+  } else {
+    name = "deliver";
+    next = `\`slidemind push ${slug}\` (into PowerPoint) or \`slidemind build-pptx ${slug}\` (to a file) — whichever target was agreed at intake; then stop`;
+  }
+
+  return {
+    name,
+    next,
+    plan: { exists: planExists, approved: planApproved, decision: planState.decision ?? null, planned: planned.length },
+    concepts,
+    assets,
+    slides: { jsx: jsx.length, native: native.length, missing },
+    draftCheck: { ran: Boolean(record), fresh: draftFresh, standingDefects: standing, selfCheck },
+    review: { decision: reviewState.decision ?? null, current: reviewCurrent },
+  };
+}
+
+export function stageHumanLines(stage) {
+  const a = stage.assets;
+  const parts = [
+    `plan: ${!stage.plan.exists ? "none" : stage.plan.approved ? "approved" : stage.plan.decision ?? "not gated"}`,
+    `concepts: ${stage.concepts}/${stage.plan.planned}`,
+    a
+      ? `asset plan: ${a.unfilled > 0 ? `${a.unfilled} section${a.unfilled === 1 ? "" : "s"} empty` : `${a.iconsResolved}/${a.icons} icon rows resolved`}`
+      : "asset plan: none",
+    `slides: ${stage.slides.jsx + stage.slides.native}/${stage.plan.planned}${stage.slides.native ? ` (${stage.slides.native} native)` : ""}`,
+    `draft check: ${!stage.draftCheck.ran ? "not run" : !stage.draftCheck.fresh ? "stale" : stage.draftCheck.standingDefects > 0 ? `${stage.draftCheck.standingDefects} defect${stage.draftCheck.standingDefects === 1 ? "" : "s"} standing` : stage.draftCheck.selfCheck === "ok" ? "clean" : "self-check incomplete"}`,
+    `review: ${stage.review.decision ? `${stage.review.decision}${stage.review.current ? "" : " (stale)"}` : "none"}`,
+  ];
+  return `  stage: ${stage.name} — ${parts.join(" · ")}\n  next: ${stage.next}\n`;
+}