slidemind 0.1.3 → 0.1.5

package/bin/slidemind.mjs

@@ -8,6 +8,7 @@
 //                                       (`install` is a back-compat alias)
 //   slidemind new <name>              scaffold ./decks/<name>/{plan.md,slides/}
 //   slidemind build <deck>            build self-contained HTML deck
+//   slidemind review <deck>           spatial preview-review gate (blocks for approve/comments)
 //   slidemind build-pptx <deck>       render the deck as native .pptx (via the add-in)
 //   slidemind uninstall --for <target>
 //   slidemind update [--for <target>] [--ref <version>]
@@ -44,12 +45,34 @@ function printHelp() {
       `Usage:\n` +
       `  slidemind new <name>             Scaffold ./decks/<name>/\n` +
       `  slidemind build <deck>           Build self-contained HTML\n` +
+      `  slidemind review <deck>          Open a spatial preview review; blocks until the user\n` +
+      `                                     approves or leaves comments (host-free)\n` +
+      `                                     --no-open       don't auto-open the browser\n` +
+      `                                     --port <n>      bind a fixed port (default: ephemeral)\n` +
       `  slidemind build-pptx <deck>      Export native .pptx via the add-in (requires an open host)\n` +
       `                                     --to <presId>   target a specific window (required if >1 open)\n` +
       `                                     --out <path>    output path (default <deck>/<deck>.pptx)\n` +
-      `  slidemind search "<query>"       Search the brand engine for icons/images (requires an open host)\n` +
-      `                                     --engine <id>   engine to search (default: first image engine)\n` +
+      `  slidemind search "<query>"       Search an engine for images or slides (requires an open host)\n` +
+      `                                     --engine <id>   engine to search (default: first image engine; required for slides)\n` +
+      `                                     --intent <i>    auto | content | visual (slide engines)\n` +
+      `                                     --top <N>       max results\n` +
       `                                     --to <presId>   target a specific window (required if >1 open)\n` +
+      `                                     --json          print the raw result payload\n` +
+      `  slidemind ls engines             List the live engine catalog for the active corporate design\n` +
+      `                                     --type <t>      collection | search\n` +
+      `                                     --subtype <s>   image | slide | template | content\n` +
+      `                                     --json          print the raw engine list\n` +
+      `  slidemind insert-slide [opts]    Insert reused slide search results live into a window (requires a host)\n` +
+      `                                     --search <id>   searchId from 'slidemind search'\n` +
+      `                                     --pick <n,..>   1-based selection number(s)\n` +
+      `                                     --to <presId>   target window (required if >1 open)\n` +
+      `                                     --at <N>        insert after slide N (0-based); default = append\n` +
+      `  slidemind add-slide [opts]       Fold reused slide search results into a deck as native .pptx\n` +
+      `                                     --search <id>   searchId from 'slidemind search'\n` +
+      `                                     --pick <n,..>   1-based selection number(s)\n` +
+      `                                     --deck <deck>   deck to add the slides to\n` +
+      `                                     --to <presId>   target the window the search ran on (required if >1 open)\n` +
+      `                                     --at <N>        numeric prefix to start at (default: append)\n` +
       `  slidemind download-bundle [deck] Materialize the active corporate design's bundle locally\n` +
       `                                     --to <presId>   target a specific window\n` +
       `                                     --force         re-download even if the cached bundle is current\n` +
@@ -65,8 +88,8 @@ function printHelp() {
       `  slidemind whoami                 Show every paired environment (* = default)\n` +
       `  slidemind use <url|env>          Set the default environment\n` +
       `  slidemind logout [url|env]       Unpair one environment (--all to unpair every one)\n` +
-      `  slidemind init --for <t>         Set up slidemind in a harness (registers the MCP server + skill)\n` +
-      `  slidemind uninstall --for <t>    Remove a previously-installed skill\n` +
+      `  slidemind init --for <t>         Set up slidemind in a harness (registers the MCP server + skill; clears the bundle cache)\n` +
+      `  slidemind uninstall --for <t>    Remove a previously-installed skill (clears the bundle cache)\n` +
       `  slidemind update [--for <t>]     Fetch the latest release and redeploy\n` +
       `                                     --for <t>     harness to redeploy into (default: all)\n` +
       `                                     --ref <ver>   pin to a release version (e.g. v0.1.0)\n` +
@@ -144,6 +167,42 @@ async function cmdBuild(rest) {
   ]);
 }
 
+async function cmdReview(rest) {
+  const { deck, passthrough } = splitDeckArg(rest, "review");
+  await runNode(path.join(BUILDERS_DIR, "review.mjs"), [
+    "--deck",
+    resolveDeckArg(deck),
+    ...passthrough,
+  ]);
+}
+
+// Live render progress for build-pptx/push (the job protocol streams it; the
+// sync fallback emits nothing). One stderr line per state change — works in
+// plain logs and TTYs alike.
+function renderProgressPrinter() {
+  let last = "";
+  let queuedAt = null;
+  return (p) => {
+    let line = null;
+    if (p.state === "queued") {
+      queuedAt ??= Date.now();
+      if (Date.now() - queuedAt > 5000) {
+        line = "  render queued behind another render…";
+      }
+    } else if (p.state === "restarted") {
+      line = "  render restarted (backend replica was replaced)…";
+    } else if (p.stage === "assembling") {
+      line = "  assembling deck…";
+    } else if (p.stage === "rendering" && typeof p.total === "number") {
+      line = `  rendering slide ${Math.min((p.done ?? 0) + 1, p.total)}/${p.total}…`;
+    }
+    if (line && line !== last) {
+      last = line;
+      process.stderr.write(`${line}\n`);
+    }
+  };
+}
+
 async function cmdBuildPptx(rest) {
   const { deck, passthrough } = splitDeckArg(rest, "build-pptx");
   let to = null;
@@ -175,6 +234,7 @@ async function cmdBuildPptx(rest) {
     deckDir,
     presentationId: to,
     outPath,
+    onProgress: renderProgressPrinter(),
   });
   process.stdout.write(
     `Wrote ${result.outPath} (${result.slideCount ?? "?"} slides) via the slidemind add-in\n`,
@@ -191,6 +251,8 @@ async function cmdSearch(rest) {
   let asJson = false;
   let to = null;
   let engineId = null;
+  let intent = null;
+  let top = null;
   const queryParts = [];
   for (let i = 0; i < rest.length; i++) {
     const a = rest[i];
@@ -199,9 +261,22 @@ async function cmdSearch(rest) {
     } else if (a === "--to") {
       to = rest[++i];
       if (!to) fail("--to expects a presId");
-    } else if (a === "--engine" || a === "-e") {
+    } else if (a === "--engine" || a === "-e" || a === "--engineId") {
       engineId = rest[++i];
       if (!engineId) fail("--engine expects an engineId");
+    } else if (a === "--intent") {
+      intent = rest[++i];
+      if (!intent) fail("--intent expects auto|content|visual");
+      if (!["auto", "content", "visual"].includes(intent)) {
+        fail(`--intent expects auto|content|visual, got '${intent}'`);
+      }
+    } else if (a === "--top") {
+      const next = rest[++i];
+      const n = parseInt(next, 10);
+      if (!Number.isFinite(n) || n <= 0) {
+        fail(`--top expects a positive integer, got '${next}'`);
+      }
+      top = n;
     } else if (a.startsWith("-")) {
       fail(`unknown flag: ${a}`);
     } else {
@@ -211,13 +286,12 @@ async function cmdSearch(rest) {
   const query = queryParts.join(" ").trim();
   if (!query) {
     fail(
-      `usage: slidemind search "<query>" [--engine <id>] [--to <presId>] [--json]`,
+      `usage: slidemind search "<query>" [--engine <id>] [--intent auto|content|visual] [--top <N>] [--to <presId>] [--json]`,
     );
   }
 
-  // Icon/image search now runs against the add-in's live brand engine over the
-  // bridge — an open host is required, and the engine comes from the active
-  // corporate design's bundle.
+  // Engine search runs against the add-in's live engine over the bridge — an
+  // open host is required.
   const client = await import(
     pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
   );
@@ -225,11 +299,32 @@ async function cmdSearch(rest) {
     pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
   );
   const registry = await client.requireHost();
-  const entry = client.pickPresentationEntry(registry, to);
+  // The engine is per-user, not window-bound — so search just attaches to any
+  // connected window (preferring a live one). No "which window?" prompt; pass
+  // --to only to pin a specific one. The chosen window is printed below so
+  // follow-up insert/add-slide can target the same pane the searchId lives on.
+  const entry = client.pickAnyPresentationEntry(registry, to);
   const presId = entry.presId;
   const backendURL = entry.backendURL ?? null;
 
+  // Slide search needs an explicit engine — the bundle's image-engine default
+  // only applies to image/visual intent. content/visual on a slide engine is
+  // the caller's choice via --engine.
+  const slideIntent = intent === "content" || intent === "visual";
+  // Thread the engine subtype on the wire whenever the CLI can determine it:
+  //   - the pickImageEngine default branch is, by construction, an image engine;
+  //   - an explicit slide intent (--intent content|visual) targets a slide
+  //     engine.
+  // This is belt-and-suspenders for an add-in regression where a missing
+  // subtype no longer defaulted to "image"; when the subtype is unknown we omit
+  // it and let the add-in resolve it from the snapshot.
+  let subtype = slideIntent ? "slide" : null;
   if (!engineId) {
+    if (slideIntent) {
+      fail(
+        "slide search requires --engine <id>. Run 'slidemind ls engines --type search --subtype slide' to find one.",
+      );
+    }
     const mat = await bundle.materializeBundle(presId, { backendURL });
     const pick = bundle.pickImageEngine(bundle.readEnginesFromDir(mat.dir));
     if (!pick) {
@@ -238,9 +333,23 @@ async function cmdSearch(rest) {
       );
     }
     engineId = pick.id;
+    subtype = "image";
   }
 
-  const res = await client.engineSearch({ presId, engineId, query, backendURL });
+  // Window-agnostic: tries the picked pane, then fails over to any other live
+  // window on the same backend if it's suspended/frozen. The answering window
+  // (res.presId) is what reuse must target — the searchId is bound to it.
+  const res = await client.engineSearchAnyPane({
+    registry,
+    explicitPresId: to,
+    engineId,
+    query,
+    subtype,
+    intent: intent ?? null,
+    top: top ?? null,
+  });
+  const ranPresId = res?.presId ?? presId;
+  const ranEntry = registry.find((p) => p.presId === ranPresId) ?? entry;
   if (asJson) {
     process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
     return;
@@ -249,15 +358,272 @@ async function cmdSearch(rest) {
     process.stderr.write(`search failed: ${res?.error ?? "unknown error"}\n`);
     return;
   }
-  const count = res.resultCount ?? (res.thumbnails?.length ?? 0);
+  // Prefer the new `results` array (image + slide engines); fall back to the
+  // legacy `thumbnails` shape older add-ins still return for image engines.
+  const results = Array.isArray(res.results)
+    ? res.results
+    : (res.thumbnails ?? []).map((t, i) => ({ selection: i + 1, title: t.title }));
+  const count = res.resultCount ?? results.length;
+  process.stdout.write(
+    `searchId ${res.searchId} — ${count} result(s) from engine ${engineId}` +
+      (res.intent ? ` (${res.intent})` : "") +
+      `\n`,
+  );
+  const isContent = res.intent === "content";
+  results.forEach((r, i) => {
+    const sel = r.selection ?? i + 1;
+    if (isContent) {
+      // Content results: per-result header + the bare extracted text block.
+      const score = typeof r.score === "number" ? ` · ${r.score.toFixed(3)}` : "";
+      process.stdout.write(`  ${sel}. ${r.title ?? "(untitled)"}${score}\n`);
+      if (r.text) {
+        for (const line of String(r.text).split("\n")) {
+          process.stdout.write(`     ${line}\n`);
+        }
+      }
+    } else {
+      // Visual / image results: the numbered list.
+      process.stdout.write(`  ${sel}. ${r.title ?? "(untitled)"}\n`);
+    }
+  });
+  // Tailor the next-step hint to the result kind: slide verbs (insert-slide /
+  // add-slide) for slide results, the image-download hint otherwise. The result
+  // subtype is authoritative; fall back to a per-result `kind` for older
+  // add-ins that don't echo a top-level subtype.
+  const isSlideResults =
+    res.subtype === "slide" || results.some((r) => r.kind === "slide");
+  const envTag = ranEntry.env ? ` [${ranEntry.env}]` : "";
+  if (isSlideResults) {
+    // The searchId is bound to the window the search ran on — reuse must target
+    // that same window, so spell out its presId in the next-step commands.
+    process.stdout.write(
+      `searchId ${res.searchId} ran on window ${ranPresId}${envTag} — reuse from THIS window:\n` +
+        `  slidemind insert-slide --search ${res.searchId} --pick <n> --to ${ranPresId}\n` +
+        `  slidemind add-slide --search ${res.searchId} --pick <n> --deck <deck> --to ${ranPresId}\n`,
+    );
+  } else {
+    process.stdout.write(
+      `Download an image result for a deck via the agent (slidemind_download_result, search_id ${res.searchId}).\n`,
+    );
+  }
+}
+
+async function cmdLs(rest) {
+  const [sub, ...subRest] = rest;
+  if (sub !== "engines") {
+    fail("usage: slidemind ls engines [--type collection|search] [--subtype image|slide|template|content] [--json]");
+  }
+  let type = null;
+  let subtype = null;
+  let to = null;
+  let asJson = false;
+  for (let i = 0; i < subRest.length; i++) {
+    const a = subRest[i];
+    if (a === "--type") {
+      type = subRest[++i];
+      if (!type) fail("--type expects collection|search");
+      if (!["collection", "search"].includes(type)) {
+        fail(`--type expects collection|search, got '${type}'`);
+      }
+    } else if (a === "--subtype") {
+      subtype = subRest[++i];
+      if (!subtype) fail("--subtype expects image|slide|template|content");
+      if (!["image", "slide", "template", "content"].includes(subtype)) {
+        fail(`--subtype expects image|slide|template|content, got '${subtype}'`);
+      }
+    } else if (a === "--to") {
+      // Accepted for symmetry with other commands; engines are backend-scoped,
+      // not presId-scoped, so it does not change the catalog.
+      to = subRest[++i];
+      if (!to) fail("--to expects a presId");
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+  void to;
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  const { engines } = await client.listEngines({ type, subtype });
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(engines, null, 2)}\n`);
+    return;
+  }
+  if (engines.length === 0) {
+    process.stderr.write("No engines available for the active corporate design.\n");
+    return;
+  }
+  // Show the env tag only when more than one environment contributed engines.
+  const multiEnv = new Set(engines.map((e) => e.env)).size > 1;
+  for (const e of engines) {
+    const kind = [e.type, e.subtype].filter(Boolean).join("/");
+    const env = multiEnv && e.env ? `[${e.env}] ` : "";
+    const desc = e.description ? ` — ${e.description}` : "";
+    process.stdout.write(`${env}${e.id} · ${e.label ?? e.id} · ${kind}${desc}\n`);
+  }
+}
+
+function parsePicks(raw, flag = "--pick") {
+  if (!raw) fail(`${flag} expects a comma-separated list of selection numbers`);
+  // Tolerate a trailing/empty segment ("1," or "1,,2") by dropping blank parts
+  // rather than turning them into NaN that fails the whole call; dedupe so the
+  // same selection isn't extracted twice.
+  const segments = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    fail(`${flag} expects a comma-separated list of selection numbers`);
+  }
+  const picks = [...new Set(segments.map((s) => parseInt(s, 10)))];
+  if (picks.some((n) => !Number.isFinite(n) || n <= 0)) {
+    fail(`${flag} expects positive selection numbers, got '${raw}'`);
+  }
+  return picks;
+}
+
+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") {
+      const next = rest[++i];
+      const n = parseInt(next, 10);
+      if (!Number.isFinite(n)) fail(`--search expects a searchId, got '${next}'`);
+      searchId = n;
+    } 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
+  );
+  const registry = await client.requireHost();
+  const entry = client.pickPresentationEntry(registry, to);
+  const res = await client.insertSlideLive({
+    presId: entry.presId,
+    searchId,
+    selections: picks,
+    at,
+    backendURL: entry.backendURL ?? null,
+  });
+  if (!res?.ok) {
+    fail(`insert-slide failed: ${res?.error ?? "unknown error"}`);
+  }
   process.stdout.write(
-    `searchId ${res.searchId} — ${count} result(s) from engine ${engineId}\n`,
+    `Inserted ${res.insertedCount ?? picks.length} slide(s) into presentation ${entry.presId}\n`,
   );
-  (res.thumbnails ?? []).forEach((t, i) => {
-    process.stdout.write(`  ${i + 1}. ${t.title ?? "(untitled)"}\n`);
+}
+
+async function cmdAddSlide(rest) {
+  let searchId = null;
+  let picks = null;
+  let deck = null;
+  let at = null;
+  let to = null;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--search") {
+      const next = rest[++i];
+      const n = parseInt(next, 10);
+      if (!Number.isFinite(n)) fail(`--search expects a searchId, got '${next}'`);
+      searchId = n;
+    } 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}`);
+    }
+  }
+  if (searchId === null || !picks || !deck) {
+    fail("usage: slidemind add-slide --search <id> --pick <n[,n,...]> --deck <deck> [--to <presId>] [--at <N>]");
+  }
+  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
+  );
+  const registry = await client.requireHost();
+  // 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 entry = client.pickPresentationEntry(registry, to);
+  const presId = entry.presId;
+  const backendURL = entry.backendURL ?? null;
+
+  // 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 is the single shared unit (src/lib/reused-slides.mjs) so the
+  // CLI and the MCP tool never diverge. Existing files are not renumbered.
+  const reused = await import(
+    pathToFileURL(path.join(SRC_DIR, "lib", "reused-slides.mjs")).href
+  );
+  const extracted = [];
+  for (const pick of picks) {
+    const res = await client.extractSlide({
+      presId,
+      searchId,
+      selection: pick,
+      backendURL,
+    });
+    if (!res?.ok || !res.base64) {
+      fail(`add-slide failed for selection ${pick}: ${res?.error ?? "no slide bytes returned"}`);
+    }
+    extracted.push({ selection: pick, slideId: res.slideId ?? null, base64: res.base64 });
+  }
+  const existing = fs
+    .readdirSync(slidesDir)
+    .filter((f) => f.endsWith(".jsx") || f.endsWith(".pptx"));
+  const targets = reused.reusedSlideTargets(existing, extracted, at);
+  const written = [];
+  extracted.forEach((slide, i) => {
+    const target = path.join(slidesDir, targets[i].filename);
+    fs.writeFileSync(target, Buffer.from(slide.base64, "base64"));
+    written.push(path.relative(process.cwd(), target));
   });
   process.stdout.write(
-    `Download a result by selection number via the agent (slidemind_download_result).\n`,
+    `Added ${written.length} reused slide(s) to ${path.relative(process.cwd(), deckDir)}:\n` +
+      written.map((w) => `  ${w}`).join("\n") +
+      `\nThey are native .pptx in slides/ — re-run 'slidemind build-pptx ${deck}' or 'slidemind push ${deck}' to render the deck with them spliced in.\n`,
   );
 }
 
@@ -284,8 +650,16 @@ async function cmdDownloadBundle(rest) {
   const bundle = await import(
     pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
   );
+  // When a deck is being (re-)bound, its existing bundle ref breaks ties for
+  // a presId open on several paired backends (prefer the one whose connected
+  // pane has THIS corporate design active).
+  const deckRef = positional[0]
+    ? bundle.readDeckBundleRef(resolveDeckArg(positional[0]))
+    : null;
   const registry = await client.requireHost();
-  const entry = client.pickPresentationEntry(registry, to);
+  const entry = client.pickPresentationEntry(registry, to, {
+    preferBrandId: deckRef?.presFP ?? null,
+  });
   const presId = entry.presId;
   const result = await bundle.materializeBundle(presId, {
     force,
@@ -303,8 +677,15 @@ async function cmdDownloadBundle(rest) {
     });
   }
   process.stdout.write(
-    `${result.cached ? "Bundle already current" : "Materialized bundle"} for ${result.presFP} (etag ${result.etag ?? "?"})\n  ${result.dir}\n`,
+    `Synced bundle for ${result.presFP} (etag ${result.etag ?? "?"}) — ` +
+      `${result.downloaded} downloaded, ${result.pruned} pruned\n  ${result.dir}\n`,
   );
+  if (result.engineUpdated) {
+    process.stdout.write("  lint engine updated\n");
+  }
+  if (result.captureEngineUpdated) {
+    process.stdout.write("  capture engine updated\n");
+  }
   // Asset downloads are best-effort (a signed URL may have expired); surface any
   // failures so the user knows the local preview bundle is incomplete.
   for (const w of result.warnings ?? []) {
@@ -543,6 +924,7 @@ async function cmdPush(rest) {
     insertAt: at,
     replace,
     slideIds: slides,
+    onProgress: renderProgressPrinter(),
   });
   for (const w of result.warnings ?? []) {
     process.stderr.write(`  warning: ${w}\n`);
@@ -631,6 +1013,22 @@ async function cmdInstall(rest) {
   const ui = await loadInstallerUi();
   ui.banner(readPackageJson().version, "init");
   await runInstaller(target, "install", rest);
+
+  // Force every design bundle to re-download from the add-in on the next
+  // build/push/download by wiping the materialized cache. init is the
+  // deliberate refresh point (and `slidemind update` redeploys through it), so
+  // a stale binary or an orphaned per-presentation dir never outlives a re-init.
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const cleared = bundle.clearBundleCache();
+  await ui.section("cache", "design bundles");
+  ui.step({
+    label: "clear",
+    value: cleared ? `${cleared} bundle${cleared === 1 ? "" : "s"}` : "empty",
+    note: "re-downloads on next build",
+  });
+
   ui.done(
     target === "all"
       ? "ready — ask your agent to plan, create, or edit a deck"
@@ -643,6 +1041,20 @@ async function cmdUninstall(rest) {
   const ui = await loadInstallerUi();
   ui.banner(readPackageJson().version, "uninstall");
   await runInstaller(target, "uninstall", rest);
+
+  // Drop the materialized bundle cache too — uninstall is a teardown, so leaving
+  // a per-presentation dir (with brand assets) behind would be stale residue.
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const cleared = bundle.clearBundleCache();
+  await ui.section("cache", "design bundles");
+  ui.step({
+    status: "remove",
+    label: "clear",
+    value: cleared ? `${cleared} bundle${cleared === 1 ? "" : "s"}` : "empty",
+  });
+
   ui.done(target === "all" ? "removed from all harnesses" : `removed from ${target}`);
 }
 
@@ -774,12 +1186,24 @@ async function main(rawArgv) {
     case "build":
       await cmdBuild(rest);
       return 0;
+    case "review":
+      await cmdReview(rest);
+      return 0;
     case "build-pptx":
       await cmdBuildPptx(rest);
       return 0;
     case "search":
       await cmdSearch(rest);
       return 0;
+    case "ls":
+      await cmdLs(rest);
+      return 0;
+    case "insert-slide":
+      await cmdInsertSlide(rest);
+      return 0;
+    case "add-slide":
+      await cmdAddSlide(rest);
+      return 0;
     case "download-bundle":
       await cmdDownloadBundle(rest);
       return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slidemind",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Connect Claude Code, Codex & opencode to the slidemind PowerPoint add-in — let your coding agent build and edit native, on-brand PowerPoint decks against your active corporate design, from the terminal.",
   "type": "module",
   "bin": {
@@ -30,13 +30,9 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@babel/parser": "^7.26.5",
-    "@babel/traverse": "^7.26.5",
-    "@babel/types": "^7.26.5",
     "@clack/prompts": "^1.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "js-yaml": "^4.1.1",
-    "recast": "^0.23.9",
+    "puppeteer": "24.43.0",
     "zod": "^3.23.8"
   },
   "engines": {