slidemind 0.1.2 → 0.1.4

package/src/builders/review.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+// slidemind review <deck> — the spatial preview-review gate, CLI-owned.
+//
+// Builds the HTML preview, serves it from a tiny local HTTP server with the
+// comment overlay (review-overlay.js) injected, opens the browser, and BLOCKS
+// until the user approves or submits spatially-anchored comments in the page.
+// The browser POSTs the decision to /review, which unblocks this command — no
+// copy-paste round-trip. The verdict is printed to stdout for the harness:
+//   - approve  -> "DECISION: approved" (the agent then runs the export the user
+//                  asked for: slidemind push / build-pptx).
+//   - comments -> each comment with its slides/<f>.jsx:line:col, the source line,
+//                  the click position, and a readonly-layout note where relevant
+//                  (the agent edits the cited files and re-runs review).
+//
+// Host-free: it reviews the HTML preview BEFORE any .pptx render, so it needs a
+// previously-materialized bundle (like `slidemind build`) but no open host.
+// Each round's comments persist to <deck>/review.json so the next run shows them
+// as read-only "ghost" pins for 1:1 verification.
+
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { buildDeck, openInBrowser } from "./build.mjs";
+import { resolveSkillForDeck } from "./resolve-skill.mjs";
+import { resolveBrandAsset } from "../bridge/bundle.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const OVERLAY_PATH = path.join(__dirname, "review-overlay.js");
+const REVIEW_STATE_FILE = "review.json";
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};
+
+function clamp01(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function pct(n) {
+  return Math.round(clamp01(n) * 100);
+}
+function safeInlineJson(data) {
+  return JSON.stringify(data).replace(/<\/script>/g, "<\\/script>");
+}
+
+// "slides/01-cover.jsx:12:5" -> { jsxPath, line, col }
+export function parseLoc(loc) {
+  if (!loc) return null;
+  const m = String(loc).match(/^(.*):(\d+):(\d+)$/);
+  if (!m) return null;
+  return { jsxPath: m[1], line: Number(m[2]), col: Number(m[3]) };
+}
+
+// Read the cited source line so the harness sees exactly what to edit. Slides
+// live in the deck; layouts live in the materialized bundle (best-effort).
+function readSourceLine(deckDir, parsed) {
+  if (!parsed) return null;
+  let filePath = null;
+  if (parsed.jsxPath.startsWith("slides/")) {
+    filePath = path.join(deckDir, parsed.jsxPath);
+  } else if (parsed.jsxPath.startsWith("layouts/")) {
+    try {
+      const skill = resolveSkillForDeck(deckDir);
+      filePath = path.join(skill.layoutsDir, path.basename(parsed.jsxPath));
+    } catch {
+      filePath = null;
+    }
+  }
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const lines = fs.readFileSync(filePath, "utf8").split("\n");
+    const line = (lines[parsed.line - 1] || "").trim();
+    return line || null;
+  } catch {
+    return null;
+  }
+}
+
+// Render the comment round for the harness — ports the add-in's
+// formatPreviewCommentsForLlm, adapted to CLI commands.
+export function formatCommentsForHarness(deckDir, comments) {
+  const n = comments.length;
+  const out = [];
+  out.push("DECISION: comments");
+  out.push(
+    `The user left ${n} comment${n === 1 ? "" : "s"} on the preview. Nothing was exported.`,
+  );
+  out.push("");
+  comments.forEach((c, i) => {
+    const region = c.resolvedTarget || null;
+    const parsed = region ? parseLoc(region.loc) : null;
+    const head = `[${i + 1}] ${c.jsxPath} — `;
+    if (region && parsed) {
+      const cls = region.className ? ` class="${region.className}"` : "";
+      out.push(`${head}element <${region.tag}${cls}> at ${region.loc}`);
+      const srcLine = readSourceLine(deckDir, parsed);
+      if (srcLine) out.push(`    Source line ${parsed.line}: ${srcLine}`);
+      const b = region.bbox || { x: 0, y: 0, w: 0, h: 0 };
+      const exX = b.w > 0 ? pct((c.point.x - b.x) / b.w) : 50;
+      const exY = b.h > 0 ? pct((c.point.y - b.y) / b.h) : 50;
+      out.push(
+        `    Click position: ${exX}%/${exY}% within the element, ` +
+          `${pct(c.point.x)}%/${pct(c.point.y)}% of the slide.`,
+      );
+      if (parsed.jsxPath.startsWith("layouts/")) {
+        out.push(
+          `    Note: this element is rendered by the READONLY layout component — its ` +
+            `content comes from the props the slide passes. Apply the change in ` +
+            `${c.jsxPath} (the prop feeding this slot), not in the layout file.`,
+        );
+      }
+    } else {
+      out.push(
+        `${head}slide-level note at ${pct(c.point.x)}%/${pct(c.point.y)}% ` +
+          `of the slide (no specific element).`,
+      );
+    }
+    out.push(`    Comment: ${c.comment}`);
+    out.push("");
+  });
+  out.push(
+    `Address every comment by editing the cited slides/*.jsx file(s) at the given ` +
+      `line, then re-run: slidemind review ${path.basename(deckDir)}`,
+  );
+  return out.join("\n") + "\n";
+}
+
+function injectReview(html, previousComments, overlayJs, logoMark = null) {
+  const cfg = safeInlineJson({
+    endpoint: "/review",
+    previousComments,
+    logoMark,
+  });
+  const overlay = overlayJs.replace(/<\/script>/g, "<\\/script>");
+  const block =
+    `<script>window.__SLIDEMIND_REVIEW__ = ${cfg};</script>\n` +
+    `<script>\n${overlay}\n</script>\n</body>`;
+  return html.includes("</body>") ? html.replace("</body>", block) : html + block;
+}
+
+export function loadReviewState(deckDir) {
+  const f = path.join(deckDir, REVIEW_STATE_FILE);
+  if (!fs.existsSync(f)) return { version: 1, comments: [] };
+  try {
+    const data = JSON.parse(fs.readFileSync(f, "utf8"));
+    return { version: 1, comments: Array.isArray(data.comments) ? data.comments : [] };
+  } catch {
+    return { version: 1, comments: [] };
+  }
+}
+
+function saveReviewState(deckDir, state) {
+  fs.writeFileSync(
+    path.join(deckDir, REVIEW_STATE_FILE),
+    JSON.stringify(state, null, 2) + "\n",
+  );
+}
+
+// Start the local review server. Returns { url, port, waitForDecision, close }.
+// presentation.html must already exist in deckDir (build it first).
+export async function createReviewServer({
+  deckDir,
+  previousComments = [],
+  overlayJs,
+  logoMark = null,
+  port = 0,
+}) {
+  let resolveDecision;
+  const decisionPromise = new Promise((res) => {
+    resolveDecision = res;
+  });
+  const overlay =
+    overlayJs ?? fs.readFileSync(OVERLAY_PATH, "utf8");
+  const indexHtml = injectReview(
+    fs.readFileSync(path.join(deckDir, "presentation.html"), "utf8"),
+    previousComments,
+    overlay,
+    logoMark,
+  );
+  const deckRoot = path.resolve(deckDir);
+
+  const server = http.createServer((req, res) => {
+    const u = new URL(req.url, "http://127.0.0.1");
+    const pathname = decodeURIComponent(u.pathname);
+
+    if (req.method === "POST" && pathname === "/review") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+        if (body.length > 5e6) req.destroy();
+      });
+      req.on("end", () => {
+        let payload;
+        try {
+          payload = JSON.parse(body || "{}");
+        } catch {
+          payload = {};
+        }
+        res.writeHead(200, { "Content-Type": MIME[".json"] });
+        res.end(JSON.stringify({ ok: true }));
+        resolveDecision({
+          decision: payload.decision === "comments" ? "comments" : "approve",
+          comments: Array.isArray(payload.comments) ? payload.comments : [],
+        });
+      });
+      return;
+    }
+
+    if (req.method !== "GET") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+
+    if (
+      pathname === "/" ||
+      pathname === "/index.html" ||
+      pathname === "/presentation.html"
+    ) {
+      res.writeHead(200, { "Content-Type": MIME[".html"] });
+      res.end(indexHtml);
+      return;
+    }
+
+    const normalized = path.resolve(deckRoot, pathname.replace(/^\/+/, ""));
+    if (normalized !== deckRoot && !normalized.startsWith(deckRoot + path.sep)) {
+      res.writeHead(403);
+      res.end("forbidden");
+      return;
+    }
+    fs.readFile(normalized, (err, data) => {
+      if (err) {
+        res.writeHead(404);
+        res.end("not found");
+        return;
+      }
+      const ext = path.extname(normalized).toLowerCase();
+      res.writeHead(200, {
+        "Content-Type": MIME[ext] || "application/octet-stream",
+      });
+      res.end(data);
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve);
+  });
+  const addr = server.address();
+  const url = `http://127.0.0.1:${addr.port}/`;
+
+  return {
+    url,
+    port: addr.port,
+    waitForDecision({ timeoutMs } = {}) {
+      if (!timeoutMs) return decisionPromise;
+      return new Promise((resolve, reject) => {
+        const t = setTimeout(
+          () => reject(new Error("review timed out — no decision received")),
+          timeoutMs,
+        );
+        decisionPromise.then((d) => {
+          clearTimeout(t);
+          resolve(d);
+        });
+      });
+    },
+    close() {
+      try {
+        server.close();
+      } catch {
+        /* already closing */
+      }
+    },
+  };
+}
+
+export async function runReview({
+  deckDir,
+  open = true,
+  port = 0,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  await buildDeck(deckDir);
+  const prev = loadReviewState(deckDir);
+  // The review window's logo is the add-in's genuine per-brand orb: a PNG
+  // shipped on the bundle as a role-keyed asset (copied into the deck by
+  // buildDeck). The review UI is dark, so prefer the dark variant. When absent
+  // (brand predates the feature / bundle not re-materialized), the overlay shows
+  // a plain slide glyph — the CLI no longer re-derives an orb.
+  const mark = resolveBrandAsset(deckDir, ["logoMarkDark", "logoMark", "logoMarkLight"]);
+  const logoMark = mark ? "/assets/" + mark.filename : null;
+  const server = await createReviewServer({
+    deckDir,
+    previousComments: prev.comments || [],
+    logoMark,
+    port,
+  });
+  process.stderr.write(`Preview review ready at ${server.url}\n`);
+  if (open) {
+    openInBrowser(server.url);
+    process.stderr.write(
+      "Opened your browser — leave comments or approve, then return here.\n",
+    );
+  } else {
+    process.stderr.write("Open the URL above in your browser to review.\n");
+  }
+
+  let decision;
+  try {
+    decision = await server.waitForDecision({ timeoutMs });
+  } finally {
+    server.close();
+  }
+
+  saveReviewState(deckDir, {
+    version: 1,
+    decision: decision.decision,
+    comments: decision.comments,
+    at: new Date().toISOString(),
+  });
+
+  if (decision.decision === "approve") {
+    process.stdout.write(
+      "DECISION: approved\n" +
+        "The user approved the preview. Proceed to produce the output they asked " +
+        "for (slidemind push / slidemind build-pptx). One approval covers the task.\n",
+    );
+  } else {
+    process.stdout.write(formatCommentsForHarness(deckDir, decision.comments));
+  }
+  return decision;
+}
+
+function parseArgs(argv) {
+  const args = { deck: null, open: true, port: 0 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--deck" && i + 1 < argv.length) {
+      args.deck = argv[++i];
+    } else if (a === "--no-open") {
+      args.open = false;
+    } else if (a === "--port" && i + 1 < argv.length) {
+      args.port = parseInt(argv[++i], 10) || 0;
+    } else if (a === "-h" || a === "--help") {
+      process.stdout.write(
+        "Usage: slidemind review <deck> [--no-open] [--port <n>]\n" +
+          "       node src/builders/review.mjs --deck <deck> [--no-open] [--port <n>]\n",
+      );
+      process.exit(0);
+    } else {
+      process.stderr.write(`review: unexpected argument '${a}'\n`);
+      process.exit(2);
+    }
+  }
+  if (!args.deck) {
+    process.stderr.write("review: --deck is required\n");
+    process.exit(2);
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const deckDir = path.resolve(args.deck);
+  await runReview({ deckDir, open: args.open, port: args.port });
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((err) => {
+    process.stderr.write(`review: ${err.message || err}\n`);
+    process.exit(1);
+  });
+}

package/src/lib/reused-slides.mjs

@@ -0,0 +1,67 @@
+// Shared numeric-prefix + filename logic for folding reused slide-search
+// results into a deck as native one-slide .pptx (the "reuse → fold into a deck"
+// path). Both `slidemind add-slide` (bin/slidemind.mjs) and the
+// `slidemind_add_slide_to_deck` MCP tool (src/mcp/server.mjs) drive the SAME
+// math, so it lives here as one pure, tested unit — the callers keep the bridge
+// round-trip and the fs write.
+//
+// Play order over the CLI is filename order (see src/lib/slide-order.mjs): a
+// reused slide is named `NN-reused-<shortid>.pptx`, zero-padded to width 2, so
+// it interleaves with the deck's `NN-<topic>.jsx` slides by its numeric prefix.
+
+// A short, filesystem-safe id derived from the source slide id when the bridge
+// returns one, else a random fallback. Lowercase alphanumerics, ≤ 8 chars.
+export function shortIdFor(slideId) {
+  const fromSource = slideId
+    ? String(slideId)
+        .replace(/[^a-z0-9]/gi, "")
+        .slice(0, 8)
+        .toLowerCase()
+    : "";
+  return fromSource || randomShortId();
+}
+
+export function randomShortId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// Compute the starting numeric prefix for a batch of reused slides.
+//   - `existingNames`: the current entries in slides/ (any extension).
+//   - `at`: optional explicit prefix the FIRST added slide should take. When
+//     null/undefined, append after the last existing numeric prefix
+//     (maxPrefix + 1). Existing files are NOT renumbered (kept simple — the
+//     zero-padded width-2 namespace is wide enough).
+// Picks beyond the first follow at +1 each.
+export function startingPrefix(existingNames, at) {
+  const prefixes = (existingNames ?? [])
+    .map((f) => {
+      const m = /^(\d+)/.exec(f);
+      return m ? parseInt(m[1], 10) : null;
+    })
+    .filter((n) => n !== null);
+  const maxPrefix = prefixes.length > 0 ? Math.max(...prefixes) : 0;
+  return typeof at === "number" ? at : maxPrefix + 1;
+}
+
+// Given the existing slides/ filenames, the picked results (each carrying an
+// optional `slideId` from the bridge), and an optional `at`, return the target
+// filename for EACH pick in order: `NN-reused-<shortid>.pptx` (zero-padded
+// width 2), the first at `startingPrefix(...)`, each subsequent +1.
+//
+// `picks` is an array of objects shaped like the bridge's slide-extract result,
+// e.g. `[{ selection, slideId }]`. Only `slideId` is read here (for the short
+// id); pass the selection back yourself if you need it alongside the filename.
+// Returns `[{ filename, prefix, shortId }]`, aligned 1:1 with `picks`.
+export function reusedSlideTargets(existingNames, picks, at) {
+  let nextPrefix = startingPrefix(existingNames, at);
+  return (picks ?? []).map((pick) => {
+    const shortId = shortIdFor(pick?.slideId ?? null);
+    const prefix = nextPrefix;
+    nextPrefix += 1;
+    return {
+      prefix,
+      shortId,
+      filename: `${String(prefix).padStart(2, "0")}-reused-${shortId}.pptx`,
+    };
+  });
+}

package/src/lib/slide-order.mjs

@@ -3,7 +3,10 @@
 // such channel, so decks encode order with zero-padded numeric prefixes
 // (01-cover.jsx, 02-agenda.jsx, …) — see skills/create-slides/SKILL.md
 // (command mapping). The sort is numeric-aware so unpadded prefixes still
-// order correctly (2-foo.jsx before 10-bar.jsx).
+// order correctly (2-foo.jsx before 10-bar.jsx). Authored .jsx slides and
+// reused native .pptx slides share one play-order namespace — the collator
+// compares the whole filename, so a 02-…​.pptx interleaves with 01-/03-…​.jsx
+// by its numeric prefix regardless of extension.
 
 const collator = new Intl.Collator("en", { numeric: true });