slidemind 0.2.3 → 0.3.0

package/src/pptx/fill/engine.mjs

@@ -17,6 +17,18 @@ import path from "node:path";
 
 import { unzip, zip, readText } from "../zip.mjs";
 import { slideOrderPaths, relsPathFor, resolvePartPath } from "../ooxml.mjs";
+import {
+  bakeSlideSourceTags,
+  encodeSourceTags,
+  mintSlideGuid,
+  referencedAssets,
+} from "../tags.mjs";
+import {
+  reconcileSlideGuids,
+  saveSlideGuids,
+  slideGuidEntry,
+} from "../../lib/slide-guids.mjs";
+import { readDeckBundleRef } from "../../bridge/bundle.mjs";
 import { parseSlideFile, layoutNumber } from "./parse-slides.mjs";
 import {
   setShapeText, setParagraphText, setShapeFill, deleteShapes, cloneShape,
@@ -35,69 +47,11 @@ export async function buildFillTemplateDeck({ deckDir, skill, outPath, onLog })
   const locale = skill.locale || "en";
   const fieldsByNo = pack.fields[locale] ?? {};
   const repeatsByNo = pack.repeats[locale] ?? {};
-
-  if (!skill.templatePath || !fs.existsSync(skill.templatePath)) {
-    throw new Error(
-      `template "${skill.templateKey}" not found in pack ${skill.skillDir} — check plan.md frontmatter and skill.json templates`,
-    );
-  }
-
-  // ---- deck reading ---------------------------------------------------------
-  const slidesDir = path.join(deckDir, "slides");
-  const entries = fs.readdirSync(slidesDir)
-    .filter((f) => f.endsWith(".jsx") || f.endsWith(".pptx"))
-    .sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
-  if (entries.length === 0) throw new Error(`no .jsx or .pptx slides in ${slidesDir}`);
-
-  const problems = [];
-  const warnings = [];
-  const sequence = []; // { kind: "master", no, props, file } | { kind: "insert", file, buf }
-
-  // In-deck freeform pairing: NN-name.jsx (create-slides source) renders to a
-  // sibling NN-name.pptx artifact — when both exist, the .pptx carries the
-  // slide and the .jsx is source only.
-  const renderedStems = new Set(
-    entries.filter((f) => f.endsWith(".pptx")).map((f) => f.replace(/\.pptx$/, "")),
-  );
-
-  for (const file of entries) {
-    if (file.endsWith(".pptx")) {
-      sequence.push({ kind: "insert", file, buf: fs.readFileSync(path.join(slidesDir, file)) });
-      continue;
-    }
-    if (renderedStems.has(file.replace(/\.jsx$/, ""))) continue;
-    const src = fs.readFileSync(path.join(slidesDir, file), "utf8");
-    let parsed;
-    try {
-      parsed = parseSlideFile(src, file);
-    } catch (err) {
-      problems.push(err.message);
-      continue;
-    }
-    const layout = layoutNumber(parsed.component, locale, pack.components);
-    if (!layout) {
-      problems.push(`${file}: <${parsed.component}> is a freeform (create-slides) slide with no ` +
-        `rendered artifact next to it — 'slidemind build-pptx' renders slides/${file.replace(/\.jsx$/, "")}.pptx ` +
-        `automatically when a paired add-in backend is reachable`);
-      continue;
-    }
-    if (layout.warn) warnings.push(`${file}: ${layout.warn}`);
-    const no = String(layout.no);
-
-    if ((pack.policy.freeform ?? []).includes(no)) {
-      if (Object.keys(parsed.props).length > 0) {
-        problems.push(`${file}: slide ${no} is a freeform placeholder — it takes no props. ` +
-          `Keep it bare to keep the master placeholder, or delete the file to drop the slide.`);
-        continue;
-      }
-      warnings.push(`${file}: keeping the master's slide-${no} placeholder (freeform replacement pending)`);
-    }
-
-    validateProps(parsed.props, fieldsByNo[no] ?? {}, repeatsByNo[no] ?? {}, pack.policy, no, file, problems);
-    sequence.push({ kind: "master", no: Number(no), props: parsed.props, file });
-  }
-
-  checkIdentities(sequence, warnings, problems);
+  const { sequence, warnings, problems } = inspectFillTemplateDeck({
+    deckDir,
+    skill,
+    includeBuffers: true,
+  });
   if (problems.length) {
     const err = new Error(`deck has ${problems.length} authoring error(s):\n  - ${problems.join("\n  - ")}`);
     err.problems = problems;
@@ -142,7 +96,7 @@ export async function buildFillTemplateDeck({ deckDir, skill, outPath, onLog })
     xml = applyDeckChrome(xml, fieldMap, skill.planMeta ?? {}, item.props, log);
     xml = applyHygiene(xml, pack.policy, item.no, log);
     files[part] = enc(xml);
-    output.push({ part, isNew: n > 1 });
+    output.push({ part, isNew: n > 1, sourceFile: item.file });
   }
 
   // Hygiene also applies to untouched (clone-only) slides that made it in.
@@ -161,6 +115,13 @@ export async function buildFillTemplateDeck({ deckDir, skill, outPath, onLog })
   // sweep them up as orphans.
   pruneOrphanParts(files, log);
 
+  // Deck-embedded source (spec §5.4): every declarative slide carries its
+  // slide-file source + a durable GUID as SLIDEMIND tags, so `adopt` can
+  // reconstruct the deck from the file alone. Freeform/native inserts arrive
+  // with their own tags (server-baked) and are left untouched. GUIDs persist
+  // in the deck's .slide-guids.json so a re-render keeps identities stable.
+  bakeDeclarativeSourceTags(files, output, deckDir, log);
+
   const integrity = checkIntegrity(files);
   for (const issue of integrity) warnings.push(`integrity: ${issue}`);
   if (integrity.length) {
@@ -174,6 +135,162 @@ export async function buildFillTemplateDeck({ deckDir, skill, outPath, onLog })
   return { outPath: finalOut, slideCount: output.length, warnings };
 }
 
+// Bake SLIDEMIND source tags for the deck's declarative slides. Best-effort:
+// an unreadable slide file skips only itself (the deck still builds).
+function bakeDeclarativeSourceTags(files, output, deckDir, log) {
+  const bundleRef = readDeckBundleRef(deckDir);
+  // Reconciled, not merely loaded: a renamed slide file keeps its GUID via the
+  // recorded content hash, and dead entries are pruned (see slide-guids.mjs).
+  const guids = reconcileSlideGuids(deckDir);
+  const minted = {};
+  const entries = [];
+  for (const { part, sourceFile } of output) {
+    if (!sourceFile || !sourceFile.endsWith(".jsx")) continue;
+    let jsx;
+    try {
+      jsx = fs.readFileSync(path.join(deckDir, "slides", sourceFile), "utf8");
+    } catch {
+      continue;
+    }
+    const key = `slides/${sourceFile}`;
+    const guid = guids[key] ?? minted[key]?.guid ?? mintSlideGuid();
+    minted[key] = slideGuidEntry(guid, jsx);
+    entries.push({
+      partName: part,
+      tags: encodeSourceTags({
+        name: sourceFile.replace(/\.jsx$/, ""),
+        jsx,
+        guid,
+        bundle: {
+          presFP: bundleRef?.presFP ?? "unknown",
+          etag: bundleRef?.etag ?? "",
+        },
+        renderer: "slidemind-cli-fill",
+        // Deck-local images the slide file references ride along (smallest-
+        // first within the budget, spec §2.2) so `adopt` rebuilds a deck that
+        // still has its pictures.
+        assets: referencedAssets(jsx, path.join(deckDir, "assets")),
+        pushedAt: new Date().toISOString(),
+        // Declarative slides are template fills, not freeform renders — the
+        // add-in's hydration treats them like any source (decoders ignore
+        // unknown meta properties).
+        metaExtra: { kind: "template-fill" },
+      }),
+    });
+  }
+  if (entries.length && bakeSlideSourceTags(files, entries)) {
+    saveSlideGuids(deckDir, minted);
+    log.slide?.(`embedded source tags on ${entries.length} slide(s)`);
+  }
+}
+
+// Parse and structurally validate a fill-template deck without mutating it.
+// External packs use this generic inspection surface to run their own domain
+// checks before invoking build-pptx. Buffers are opt-in because JSON callers
+// must receive a compact, serializable sequence.
+export function inspectFillTemplateDeck({
+  deckDir,
+  skill,
+  allowUnrenderedFreeform = false,
+  includeBuffers = false,
+}) {
+  const pack = loadPack(skill);
+  const locale = skill.locale || "en";
+  const fieldsByNo = pack.fields[locale] ?? {};
+  const repeatsByNo = pack.repeats[locale] ?? {};
+  const slidesDir = path.join(deckDir, "slides");
+  const problems = [];
+  const warnings = [];
+  const sequence = [];
+
+  if (!skill.templatePath || !fs.existsSync(skill.templatePath)) {
+    problems.push(
+      `template "${skill.templateKey}" not found in pack ${skill.skillDir} — check the pack manifest templates`,
+    );
+  }
+  if (!fs.existsSync(slidesDir) || !fs.statSync(slidesDir).isDirectory()) {
+    problems.push(`expected 'slides/' folder in ${deckDir}`);
+    return { sequence, warnings, problems, locale, templateKey: skill.templateKey };
+  }
+
+  const entries = fs.readdirSync(slidesDir)
+    .filter((f) => f.endsWith(".jsx") || f.endsWith(".pptx"))
+    .sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
+  if (entries.length === 0) {
+    problems.push(`no .jsx or .pptx slides in ${slidesDir}`);
+    return { sequence, warnings, problems, locale, templateKey: skill.templateKey };
+  }
+
+  const renderedStems = new Set(
+    entries.filter((f) => f.endsWith(".pptx")).map((f) => f.replace(/\.pptx$/, "")),
+  );
+
+  for (const file of entries) {
+    const full = path.join(slidesDir, file);
+    if (file.endsWith(".pptx")) {
+      sequence.push({
+        kind: "insert",
+        file,
+        ...(includeBuffers ? { buf: fs.readFileSync(full) } : {}),
+      });
+      continue;
+    }
+    if (renderedStems.has(file.replace(/\.jsx$/, ""))) continue;
+
+    const src = fs.readFileSync(full, "utf8");
+    const component = src.match(/<([A-Z][A-Za-z0-9]*)/)?.[1] ?? null;
+    let layout = null;
+    if (component) {
+      try {
+        layout = layoutNumber(component, locale, pack.components);
+      } catch (err) {
+        problems.push(err.message);
+        continue;
+      }
+    }
+
+    // A pack validator needs to see freeform source positions even before the
+    // paired add-in artifact exists. The build path still rejects such a
+    // source until ensureFreeformRenders has produced its .pptx sibling.
+    if (!layout && allowUnrenderedFreeform) {
+      sequence.push({ kind: "freeform", file, component });
+      warnings.push(`${file}: freeform source has no rendered .pptx artifact yet`);
+      continue;
+    }
+
+    let parsed;
+    try {
+      parsed = parseSlideFile(src, file);
+    } catch (err) {
+      problems.push(err.message);
+      continue;
+    }
+    layout = layoutNumber(parsed.component, locale, pack.components);
+    if (!layout) {
+      problems.push(`${file}: <${parsed.component}> is a freeform (create-slides) slide with no ` +
+        `rendered artifact next to it — render slides/${file.replace(/\.jsx$/, "")}.pptx ` +
+        `through the paired add-in before building`);
+      continue;
+    }
+    if (layout.warn) warnings.push(`${file}: ${layout.warn}`);
+    const no = String(layout.no);
+
+    if ((pack.policy.freeform ?? []).includes(no)) {
+      if (Object.keys(parsed.props).length > 0) {
+        problems.push(`${file}: slide ${no} is a freeform placeholder — it takes no props. ` +
+          `Keep it bare to keep the master placeholder, or delete the file to drop the slide.`);
+        continue;
+      }
+      warnings.push(`${file}: keeping the master's slide-${no} placeholder (freeform replacement pending)`);
+    }
+
+    validateProps(parsed.props, fieldsByNo[no] ?? {}, repeatsByNo[no] ?? {}, pack.policy, no, file, problems);
+    sequence.push({ kind: "master", no: Number(no), props: parsed.props, file });
+  }
+
+  return { sequence, warnings, problems, locale, templateKey: skill.templateKey };
+}
+
 // ---------------------------------------------------------------------------
 // Pack
 // ---------------------------------------------------------------------------
@@ -266,77 +383,6 @@ function editDistance(a, b) {
   return dp[a.length][b.length];
 }
 
-// ---------------------------------------------------------------------------
-// Cross-slide identities (the catalog's consistency table, as code)
-// ---------------------------------------------------------------------------
-
-const asLines = (v) => (Array.isArray(v) ? v : String(v ?? "").split("\n")).map((s) => s.trim()).filter(Boolean);
-
-function checkIdentities(sequence, warnings, problems) {
-  const slide = (no) => sequence.filter((s) => s.kind === "master" && s.no === no);
-  const approach = slide(10)[0];
-  const details = slide(11);
-  const gantt = slide(13)[0];
-  const calc = slide(16)[0];
-
-  const wpItems = approach?.props?.repeat?.workPackages ?? null;
-  const ganttItems = gantt?.props?.repeat?.workPackages ?? null;
-
-  if (wpItems && details.length && wpItems.length !== details.length) {
-    problems.push(`WP count mismatch: slide 10 declares ${wpItems.length} work packages but there are ${details.length} WP-detail files (slide 11)`);
-  }
-  // Every WP detail must carry FULL bullet lists — a section left empty (or a
-  // one-liner) is a defect in a client deliverable, not a style choice.
-  details.forEach((d, i) => {
-    for (const section of ["services", "assumptions", "deliverables"]) {
-      const lines = asLines(d.props?.[section]);
-      if (lines.length === 0) {
-        problems.push(`${d.file}: WP detail ${i + 1} has no "${section}" — every WP detail needs all three bullet lists filled`);
-      } else if (lines.length < 3) {
-        warnings.push(`${d.file}: "${section}" has only ${lines.length} bullet(s) — WP details expect full lists (3–5)`);
-      }
-    }
-  });
-  if (wpItems && ganttItems && wpItems.length !== ganttItems.length) {
-    problems.push(`WP count mismatch: slide 10 has ${wpItems.length} work packages, the project plan (13) has ${ganttItems.length} rows`);
-  }
-  if (ganttItems && details.length === ganttItems.length) {
-    ganttItems.forEach((item, i) => {
-      const canonical = asLines(details[i]?.props?.deliverables);
-      const row = asLines(item.deliverable);
-      if (canonical.length && row.length && canonical.join("\n") !== row.join("\n")) {
-        problems.push(`deliverables drift: gantt row ${i + 1} must repeat WP-${i + 1}'s deliverables verbatim (slide 11 owns them)`);
-      }
-    });
-  }
-  if (wpItems && ganttItems) {
-    ganttItems.forEach((item, i) => {
-      if (item.title && wpItems[i]?.title && item.title !== wpItems[i].title) {
-        problems.push(`WP name drift: slide 10 card ${i + 1} is "${wpItems[i].title}" but gantt row ${i + 1} is "${item.title}"`);
-      }
-    });
-  }
-  for (const [frameId, rows] of Object.entries(calc?.props?.tables ?? {})) {
-    if (!Array.isArray(rows) || !wpItems) continue;
-    const labels = rows.slice(1, -1).map((r) => String(r[0] ?? ""));
-    labels.forEach((label, i) => {
-      if (wpItems[i]?.title && label && label !== wpItems[i].title) {
-        problems.push(`WP name drift: calculation table ${frameId} row ${i + 1} is "${label}" but slide 10 card ${i + 1} is "${wpItems[i].title}"`);
-      }
-    });
-  }
-  // Price echo: the contracted total should appear in the management summary.
-  const costRows = calc?.props?.tables?.["15"];
-  if (Array.isArray(costRows)) {
-    const grand = String(costRows[costRows.length - 1]?.slice(-1)[0] ?? "");
-    const digits = grand.replace(/[^\d.,]/g, "");
-    const summary = slide(7)[0];
-    if (digits && summary?.props?.approach && !String(summary.props.approach).includes(digits)) {
-      warnings.push(`slide 7's approach paragraph does not mention the contracted total ${grand} from table 15`);
-    }
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Per-slide ops
 // ---------------------------------------------------------------------------

package/src/pptx/hidden-ole.mjs

@@ -1,9 +1,10 @@
 import { readText } from "./zip.mjs";
 import { relsFor, relsPathFor, resolvePartPath } from "./ooxml.mjs";
+import { slideHasForeignTags, slideReferencesEmbeddedWorkbook } from "./tags.mjs";
 
 const CONTENT_TYPES = "[Content_Types].xml";
 
-export function stripHiddenOleGraphicFrames(files) {
+export function stripHiddenOleGraphicFrames(files, { keepSlideOle = null } = {}) {
   let changed = false;
   const removedTargets = new Set();
   const candidates = Object.keys(files).filter((part) =>
@@ -14,6 +15,26 @@ export function stripHiddenOleGraphicFrames(files) {
     const before = readText(files, part);
     if (!before) continue;
 
+    // Coexistence rule C4 (intern-slidemind docs/deck-embedded-source-spec.md
+    // §13): a SLIDE that carries another add-in's state — foreign tags or an
+    // embedded workbook/OLE part (think-cell "slide workbook" pattern) — keeps
+    // its hidden OLE frames untouched; stripping them would destroy that
+    // add-in's data. Slidemind's own rendered/template output never has
+    // foreign tags, so the strip stays fully active there. Masters/layouts
+    // (template chain) keep the old behavior. The verdict is constant per
+    // slide CONTENT, so a caller running the strip once per pick over the
+    // same package (foldPickedSlides) precomputes it and passes `keepSlideOle`
+    // instead of paying the rels + tag-part parse again on every pick.
+    if (
+      part.startsWith("ppt/slides/") &&
+      (keepSlideOle
+        ? keepSlideOle(part)
+        : slideHasForeignTags(files, part) ||
+          slideReferencesEmbeddedWorkbook(files, part))
+    ) {
+      continue;
+    }
+
     const removedIds = new Set();
     const after = before.replace(
       /<p:graphicFrame\b[\s\S]*?<\/p:graphicFrame>/g,

package/src/pptx/slide-swap.mjs

@@ -31,6 +31,10 @@ import {
 } from "./ooxml.mjs";
 import { stripHiddenOleGraphicFrames } from "./hidden-ole.mjs";
 import { stripRiskyImageExtensions } from "./image-extensions.mjs";
+import {
+  slideHasForeignTags,
+  slideReferencesEmbeddedWorkbook,
+} from "./tags.mjs";
 
 // The four package parts we always keep and rewrite for standalone validity.
 const SKELETON = [
@@ -63,6 +67,19 @@ export function foldPickedSlides(buffer, picks, { sourceName = "reused" } = {})
   const lowest = firstSlidePath(files);
   const lowestRels = relsPathFor(lowest);
 
+  // The C4 keep-OLE verdict (foreign tags / embedded workbook) is per slide
+  // CONTENT and constant across picks — computed inside the strip it re-parsed
+  // every slide's rels and tag parts once per pick, O(picks × slides) on a big
+  // adopt. One pass here; the per-pick lookup follows the slide swap below
+  // (the lowest slot holds the picked slide's content).
+  const keepOleByPart = new Map(
+    order.map((part) => [
+      part,
+      slideHasForeignTags(files, part) ||
+        slideReferencesEmbeddedWorkbook(files, part),
+    ]),
+  );
+
   return picks.map((n) => {
     const picked = order[n - 1];
     const sldId = entries[n - 1] ? entries[n - 1].sldId : null;
@@ -89,7 +106,12 @@ export function foldPickedSlides(buffer, picks, { sourceName = "reused" } = {})
       copy[lowestRels] = stripNotesRel(copy[lowestRels]);
       notesStripped = true;
     }
-    const hiddenOleStripped = stripHiddenOleGraphicFrames(copy);
+    const hiddenOleStripped = stripHiddenOleGraphicFrames(copy, {
+      keepSlideOle: (part) =>
+        keepOleByPart.get(
+          part === lowest ? picked : part === picked ? lowest : part,
+        ) ?? false,
+    });
     const riskyImagesStripped = stripRiskyImageExtensions(copy);
 
     // Prune to the lowest slide's dependency closure + trimmed skeleton.