slidemind 0.1.3 → 0.1.4

package/src/builders/build.mjs

@@ -32,7 +32,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-import { lintSlidesOrThrow } from "./lint-slides.mjs";
+import { lintSlidesOrThrow } from "./lint.mjs";
 import { resolveSkillForDeck } from "./resolve-skill.mjs";
 import { slideOrderWarning, sortSlideFilenames } from "../lib/slide-order.mjs";
 
@@ -50,7 +50,10 @@ function safeInlineJson(data) {
   return JSON.stringify(data).replace(/<\/script>/g, "<\\/script>");
 }
 
-function stripImports(src) {
+// Exported for tests: the regex keeps the line's trailing newline, so line
+// numbers stay aligned to the author's pristine file — which the browser-side
+// data-sm-loc instrumentation depends on.
+export function stripImports(src) {
   // Remove `import ... from "..."` lines. Layouts live in global scope in
   // the generated HTML, so slide files never need to import them explicitly.
   return src.replace(
@@ -354,9 +357,49 @@ __RUNTIME_APPLIER__
         }).join("");
       }
 
+      // Stamp every intrinsic JSX element with data-sm-loc="<prefix>:<line>:<col>"
+      // so the preview-review overlay (review-overlay.js) can resolve a click back
+      // to the exact slide source location. Runs as a Babel plugin BEFORE the react
+      // preset (plugins run before presets) so it sees JSX nodes, not createElement
+      // calls. Inert without the overlay. Mirrors the add-in's instrument-source-loc.
+      function makeSourceLocPlugin(locPrefix) {
+        return function (babel) {
+          var t = babel.types;
+          return {
+            visitor: {
+              JSXOpeningElement: function (path) {
+                var node = path.node;
+                var nameNode = node.name;
+                // Intrinsic elements only: a lowercase JSXIdentifier. Skip
+                // components (<SlideCover>), member/namespaced names, fragments.
+                if (!nameNode || nameNode.type !== "JSXIdentifier") return;
+                if (!/^[a-z]/.test(nameNode.name)) return;
+                for (var i = 0; i < node.attributes.length; i++) {
+                  var a = node.attributes[i];
+                  if (a.type === "JSXAttribute" && a.name &&
+                      a.name.name === "data-sm-loc") return;
+                }
+                var start = node.loc && node.loc.start;
+                if (!start) return;
+                var value = locPrefix + ":" + start.line + ":" + (start.column + 1);
+                node.attributes.push(
+                  t.jsxAttribute(t.jsxIdentifier("data-sm-loc"),
+                    t.stringLiteral(value))
+                );
+              }
+            }
+          };
+        };
+      }
+
       function evalJsx(src, filename, extra) {
+        // The inliner wraps each source as "\\n" + src + "\\n" inside the <script>
+        // block; strip that one leading newline so Babel's line numbers (and thus
+        // data-sm-loc) align with the author's pristine workspace file.
+        if (src.charAt(0) === "\\n") src = src.slice(1);
         var result = Babel.transform(src, {
           presets: [["react", { runtime: "classic" }]],
+          plugins: [makeSourceLocPlugin(filename)],
           sourceType: "module",
           filename: filename
         });
@@ -466,7 +509,11 @@ __RUNTIME_APPLIER__
       document.querySelectorAll('script[data-kind="layout"]').forEach(function (s) {
         var name = s.dataset.binding || layoutBindingName(s.dataset.name);
         try {
-          LAYOUTS[name] = evalJsx(s.textContent, s.dataset.name + ".jsx", {});
+          LAYOUTS[name] = evalJsx(
+            s.textContent,
+            "layouts/" + s.dataset.name + ".jsx",
+            {}
+          );
           window[name] = LAYOUTS[name];
         } catch (err) {
           console.error("Layout " + name + " failed to load:", err);
@@ -481,7 +528,7 @@ __RUNTIME_APPLIER__
         try {
           var Component = evalJsx(
             s.textContent,
-            name + ".jsx",
+            "slides/" + name + ".jsx",
             LAYOUTS
           );
           slides[idx] = { name: name, Component: Component };
@@ -591,7 +638,7 @@ __RUNTIME_APPLIER__
 </html>
 `;
 
-export function buildDeck(deckDir, opts = {}) {
+export async function buildDeck(deckDir, opts = {}) {
   const skill = resolveSkillForDeck(deckDir);
   const slidesDir = path.join(deckDir, "slides");
   if (!fs.existsSync(slidesDir) || !fs.statSync(slidesDir).isDirectory()) {
@@ -640,17 +687,18 @@ export function buildDeck(deckDir, opts = {}) {
     throw new Error(`No layouts in ${skill.layoutsDir}`);
   }
 
-  // Merge the brand primitive registry with the active skill's registry so a
-  // sibling skill's aliases and the brand's freeform layouts can coexist in one
-  // deck. (With only the brand skill present this is a single registry.)
-  lintSlidesOrThrow(slideFiles, {
-    primitivesPath: skill.primitivesPath,
-    brandPrimitivesPath: skill.brand.primitivesPath,
-    // Derive valid layout component names from the materialized layouts/*.jsx so
-    // the lint recognizes the bundle's layouts without a primitives.json
-    // `layouts` list (the materialized bundle doesn't ship one).
-    layoutsDirs: layoutDirs,
-  });
+  // Lint with the add-in's engine from the materialized bundle (the CLI owns
+  // no lint source — see src/builders/lint.mjs). The registry derives layout
+  // component names from the RAW layout JSX (not the rewriteAssetsPath-mutated
+  // copy inlineLayout produces); the primitives registry rides next to the
+  // engine in the bundle cache.
+  const layoutSources = new Map(
+    [...layoutByStem].map(([stem, file]) => [
+      `${stem}.jsx`,
+      fs.readFileSync(file, "utf8"),
+    ]),
+  );
+  await lintSlidesOrThrow({ deckDir, slideFiles, layoutSources });
 
   copyDesignSystem(deckDir, skill);
 
@@ -673,13 +721,16 @@ export function buildDeck(deckDir, opts = {}) {
   return { out, slideCount: slideFiles.length };
 }
 
-function openInBrowser(file) {
+// Open a local file path OR an http URL in the user's default browser. The
+// platform openers (open / start / xdg-open) accept both, so review.mjs reuses
+// this to launch the local review server URL.
+export function openInBrowser(target) {
   const opener =
     process.platform === "darwin"
-      ? { cmd: "open", args: [file] }
+      ? { cmd: "open", args: [target] }
       : process.platform === "win32"
-        ? { cmd: "cmd", args: ["/c", "start", "", file] }
-        : { cmd: "xdg-open", args: [file] };
+        ? { cmd: "cmd", args: ["/c", "start", "", target] }
+        : { cmd: "xdg-open", args: [target] };
   spawn(opener.cmd, opener.args, { stdio: "ignore", detached: true }).unref();
 }
 
@@ -709,20 +760,18 @@ function parseArgs(argv) {
   return args;
 }
 
-function main() {
+async function main() {
   const args = parseArgs(process.argv.slice(2));
   const deckDir = path.resolve(args.deck);
-  const { out, slideCount } = buildDeck(deckDir);
+  const { out, slideCount } = await buildDeck(deckDir);
   const rel = path.relative(process.cwd(), out) || out;
   process.stdout.write(`Built ${rel}  (${slideCount} slides)\n`);
   if (args.open) openInBrowser(out);
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  try {
-    main();
-  } catch (err) {
+  main().catch((err) => {
     process.stderr.write(`build: ${err.message || err}\n`);
     process.exit(1);
-  }
+  });
 }

package/src/builders/lint.mjs

@@ -0,0 +1,112 @@
+// Slide lint — thin wrapper over the add-in's lint engine.
+//
+// This CLI owns NO lint source. The add-in is the single source of truth: its
+// capability-table engine (the same one that gates `build_and_push` server-
+// side) is served on the design-bundle wire as a self-contained ESM artifact
+// and materialized into the bundle cache as `lint-engine.mjs` next to its
+// `primitives.json` registry (see src/bridge/bundle.mjs). This module resolves
+// the deck's bundle, dynamic-imports the cached engine, and mirrors the old
+// lintSlidesOrThrow contract: findings to stderr, throw on errors.
+//
+// Lint therefore works fully offline once the bundle is materialized, and
+// rule changes propagate on the next bundle fetch — no CLI release needed.
+
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { resolveBundleDirForDeck } from "../bridge/bundle.mjs";
+
+// Resolve the cached engine for a deck and explain every miss actionably.
+// Returns { enginePath, version, primitives }.
+function resolveEngine(deckDir) {
+  const bundleDir = resolveBundleDirForDeck(deckDir);
+  if (!bundleDir) {
+    throw new Error(
+      `No materialized design bundle for deck ${path.basename(deckDir)}.\n` +
+        `  Run 'slidemind download-bundle ${path.basename(deckDir)}' first.`,
+    );
+  }
+  const enginePath = path.join(bundleDir, "lint-engine.mjs");
+  const metaPath = path.join(bundleDir, "bundle.json");
+  let meta = {};
+  try {
+    meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+  } catch {
+    /* treated as a pre-engine cache below */
+  }
+
+  if (!fs.existsSync(enginePath)) {
+    if (meta.lintEngineVersion === null) {
+      // The backend answered but served no engine: it predates the feature.
+      throw new Error(
+        `The paired slidemind add-in does not serve a lint engine yet.\n` +
+          `  Update/redeploy the add-in backend, then re-run ` +
+          `'slidemind download-bundle ${path.basename(deckDir)}'.`,
+      );
+    }
+    // Cache written before the engine existed (meta lacks the key), or the
+    // file went missing — refetch repairs both.
+    throw new Error(
+      `This bundle cache predates the lint engine.\n` +
+        `  Run 'slidemind download-bundle ${path.basename(deckDir)}'.`,
+    );
+  }
+
+  let primitives = {};
+  try {
+    primitives = JSON.parse(
+      fs.readFileSync(path.join(bundleDir, "primitives.json"), "utf8"),
+    );
+  } catch {
+    // The registry is closed and deliberately empty today — lint still works,
+    // but flag it so a broken materialization doesn't pass silently.
+    process.stderr.write(
+      "warning: bundle has no readable primitives.json — linting with an empty registry\n",
+    );
+  }
+
+  return { enginePath, version: meta.lintEngineVersion ?? "0", primitives };
+}
+
+// Lint slide files with the add-in's engine. `layoutSources` is the registry
+// input the engine derives layout component names from: Map<"Cover.jsx", raw
+// JSX source> — same shape the add-in's in-app lint feeds it.
+// Prints findings to stderr; throws when any [lint:error] is present.
+export async function lintSlidesOrThrow({ deckDir, slideFiles, layoutSources }) {
+  const { enginePath, version, primitives } = resolveEngine(deckDir);
+
+  // `?v=` busts Node's per-process module cache so a long-lived process (the
+  // MCP server) picks up a refreshed engine at the same path.
+  const engine = await import(
+    `${pathToFileURL(enginePath).href}?v=${encodeURIComponent(version)}`
+  );
+  if (typeof engine.lintSlidesInMemory !== "function") {
+    throw new Error(
+      `Cached lint engine is corrupt (no lintSlidesInMemory export).\n` +
+        `  Run 'slidemind download-bundle ${path.basename(deckDir)}'.`,
+    );
+  }
+
+  const slides = slideFiles.map((file) => ({
+    fileName: path.basename(file),
+    source: fs.readFileSync(file, "utf8"),
+  }));
+  const result = engine.lintSlidesInMemory(slides, {
+    layoutSources,
+    primitives,
+  });
+
+  for (const line of result.lines) {
+    process.stderr.write(`${line}\n`);
+  }
+  if (!result.ok) {
+    const summary =
+      `slide lint: ${result.errors} error${result.errors === 1 ? "" : "s"}` +
+      (result.warnings
+        ? `, ${result.warnings} warning${result.warnings === 1 ? "" : "s"}`
+        : "");
+    throw new Error(`${summary}\n${result.lines.join("\n")}`);
+  }
+  return result;
+}

package/src/builders/resolve-skill.mjs

@@ -1,6 +1,8 @@
 // Discover which skill a deck was authored against, and return the paths the
-// rest of the local preview pipeline (build.mjs, lint-slides.mjs) needs to
-// load layouts, tokens, primitives and assets from.
+// rest of the local preview pipeline (build.mjs) needs to load layouts,
+// tokens and assets from. (The lint registry's primitives.json now rides in
+// the materialized bundle next to the add-in's lint engine — see
+// src/builders/lint.mjs.)
 //
 // Post-connect, the corporate design (css, layouts, assets) is no longer
 // shipped inside the skill — it lives in the slidemind add-in and is
@@ -31,12 +33,6 @@ const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 
 const DEFAULT_SKILL = "create-slides";
 
-// Shipped fallback layout-contract registry for the LOCAL HTML preview.
-// The add-in derives layout contracts from the bundle's layouts directly, so
-// this is only consulted by the local preview when neither the deck nor the
-// materialized bundle carries its own primitives.json.
-const SHIPPED_PRIMITIVES = path.join(__dirname, "primitives.json");
-
 function firstExisting(candidates) {
   for (const c of candidates) {
     if (c && fs.existsSync(c)) return c;
@@ -104,9 +100,6 @@ export function resolveSkill(skillName, planMeta = {}, opts = {}) {
 
   const deckLayouts = opts.deckDir ? path.join(opts.deckDir, "layouts") : null;
   const deckAssets = opts.deckDir ? path.join(opts.deckDir, "assets") : null;
-  const deckPrimitives = opts.deckDir
-    ? path.join(opts.deckDir, "primitives.json")
-    : null;
 
   const cssFile = firstExistingOr(
     designRoots.map((r) => path.join(r, cssName)),
@@ -124,23 +117,26 @@ export function resolveSkill(skillName, planMeta = {}, opts = {}) {
     [deckAssets, ...designRoots.map((r) => path.join(r, "assets"))],
     path.join(designRoots[0], "assets"),
   );
-  const primitivesPath = firstExistingOr(
-    [
-      deckPrimitives,
-      ...designRoots.map((r) => path.join(r, "primitives.json")),
-      SHIPPED_PRIMITIVES,
-    ],
-    SHIPPED_PRIMITIVES,
+  // Brand assets ALWAYS resolve from the design root (the bundle): logos, decor,
+  // and the per-layout chrome backgrounds (`assets/chrome-*`). They must be
+  // resolved INDEPENDENTLY of the deck — `assetsDir` above prefers the deck's own
+  // `assets/` (engine downloads), so if `brand.assetsDir` mirrored it, a deck that
+  // already has any local asset would collapse both layers to the deck dir and
+  // copyDesignSystem would never copy the bundle's brand assets (chrome included)
+  // into the preview. Keeping the brand layer on the bundle lets the deck's assets
+  // layer ON TOP and override by name, without suppressing the brand chrome.
+  const brandAssetsDir = firstExistingOr(
+    designRoots.map((r) => path.join(r, "assets")),
+    path.join(designRoots[0], "assets"),
   );
   // One truth: brand paths mirror the resolved design roots (the bundle IS the
   // brand source; there is no separate brand skill anymore).
   const brand = {
     skillDir: designRoots[0],
-    assetsDir,
+    assetsDir: brandAssetsDir,
     cssFile,
     layoutsDir,
     layoutsCssFile,
-    primitivesPath,
   };
 
   // The PPTX slide-master template only fed the now-archived local exporter;
@@ -167,7 +163,6 @@ export function resolveSkill(skillName, planMeta = {}, opts = {}) {
     cssFile,
     layoutsDir,
     assetsDir,
-    primitivesPath,
     brand,
     templateKey,
     templatePath,