slidemind 0.0.27

package/src/installers/opencode.mjs

@@ -0,0 +1,181 @@
+// Install slidemind into opencode.
+//
+// opencode auto-discovers user-level skills at
+// `~/.config/opencode/skills/<name>/SKILL.md` (parity with Claude Code's
+// `~/.claude/skills/` layout). We copy each skill there with the
+// `slidemind-` namespace prefix so opencode loads it via SKILL.md
+// frontmatter, exactly like the other harnesses.
+//
+// Layout after install:
+//   ~/.config/opencode/skills/slidemind-create-slides/SKILL.md  + assets
+//
+// Earlier versions modelled the skill as an opencode "agent" (because
+// opencode didn't have native skills at the time) and stashed the
+// payload at `~/.config/opencode/slidemind/`. We actively remove both
+// on every install so upgraders converge to the correct layout.
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  expandHome,
+  installDir,
+  isForce,
+  isLinkMode,
+  listSkills,
+  rmIfExists,
+  ui,
+} from "./lib.mjs";
+
+const NAMESPACE = "slidemind";
+
+function opencodeRoot() {
+  return expandHome("~/.config/opencode");
+}
+
+function skillsRoot() {
+  return path.join(opencodeRoot(), "skills");
+}
+
+function skillTarget(skillName) {
+  return path.join(skillsRoot(), `${NAMESPACE}-${skillName}`);
+}
+
+// Pre-skills layout. Removed on every install/uninstall.
+function legacySkillsRoot() {
+  return path.join(opencodeRoot(), NAMESPACE);
+}
+function legacyAgentDir() {
+  return path.join(opencodeRoot(), "agent");
+}
+function legacyCommandDir() {
+  return path.join(opencodeRoot(), "command");
+}
+
+function opencodeConfigFile() {
+  return path.join(opencodeRoot(), "opencode.json");
+}
+
+function loadOpencodeConfig() {
+  const file = opencodeConfigFile();
+  if (!fs.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8")) || {};
+  } catch {
+    throw new Error(`opencode config at ${file} is not valid JSON; refusing to overwrite.`);
+  }
+}
+
+function saveOpencodeConfig(cfg) {
+  const file = opencodeConfigFile();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+}
+
+function unregisterMcpServer() {
+  const file = opencodeConfigFile();
+  if (!fs.existsSync(file)) return;
+  const cfg = loadOpencodeConfig();
+  if (cfg.mcp && cfg.mcp[NAMESPACE]) {
+    delete cfg.mcp[NAMESPACE];
+    if (Object.keys(cfg.mcp).length === 0) delete cfg.mcp;
+    saveOpencodeConfig(cfg);
+  }
+}
+
+function registerMcpServer(packageRoot) {
+  const mcpServer = path.join(packageRoot, "src", "mcp", "server.mjs");
+  const cfg = loadOpencodeConfig();
+  if (!cfg["$schema"]) cfg["$schema"] = "https://opencode.ai/config.json";
+  cfg.mcp = cfg.mcp || {};
+  cfg.mcp[NAMESPACE] = {
+    type: "local",
+    command: ["node", mcpServer],
+    enabled: true,
+  };
+  saveOpencodeConfig(cfg);
+}
+
+function removeLegacyArtifacts() {
+  // Old `~/.config/opencode/slidemind/` payload directory.
+  if (fs.existsSync(legacySkillsRoot())) {
+    rmIfExists(legacySkillsRoot());
+    ui.step({ status: "remove", label: "legacy", value: legacySkillsRoot() });
+  }
+  // Old `~/.config/opencode/agent/slidemind-*.md` agent shims.
+  const agentDir = legacyAgentDir();
+  if (fs.existsSync(agentDir)) {
+    for (const entry of fs.readdirSync(agentDir)) {
+      if (entry.startsWith(`${NAMESPACE}-`) && entry.endsWith(".md")) {
+        const target = path.join(agentDir, entry);
+        rmIfExists(target);
+        ui.step({ status: "remove", label: "legacy agent", value: target });
+      }
+    }
+  }
+  // Old `~/.config/opencode/command/slidemind-*.md` command files.
+  const commandDir = legacyCommandDir();
+  if (fs.existsSync(commandDir)) {
+    for (const entry of fs.readdirSync(commandDir)) {
+      if (entry.startsWith(`${NAMESPACE}-`) && entry.endsWith(".md")) {
+        const target = path.join(commandDir, entry);
+        rmIfExists(target);
+        ui.step({ status: "remove", label: "legacy command", value: target });
+      }
+    }
+  }
+}
+
+export async function install({ packageRoot, flags }) {
+  const link = isLinkMode(flags);
+  const force = isForce(flags);
+
+  await ui.section("opencode", opencodeRoot());
+
+  // Drop pre-skills layout (agent shims, command files, the old
+  // ~/.config/opencode/slidemind/ payload) — opencode now scans
+  // ~/.config/opencode/skills/ natively.
+  removeLegacyArtifacts();
+
+  // Skill files: copy/symlink each skill into
+  // ~/.config/opencode/skills/slidemind-<name>/ so opencode auto-discovers
+  // them via SKILL.md frontmatter.
+  fs.mkdirSync(skillsRoot(), { recursive: true });
+  for (const skill of listSkills(packageRoot)) {
+    const dest = skillTarget(skill.name);
+    await ui.spin(
+      {
+        label: "skill",
+        value: dest,
+        note: link ? "linking" : "copying",
+        finalNote: link ? "linked" : "copied",
+      },
+      () => installDir({ src: skill.path, dest, link, force }),
+    );
+  }
+
+  // Register the slidemind MCP server so agents can list/push into open
+  // PowerPoint windows via slidemind_list_open_presentations / slidemind_push_deck.
+  registerMcpServer(packageRoot);
+  ui.step({ status: "ok", label: "mcp server", value: opencodeConfigFile() });
+}
+
+export async function uninstall() {
+  await ui.section("opencode", opencodeRoot());
+
+  removeLegacyArtifacts();
+
+  // Remove our installed skills (only the ones we own — leave other
+  // entries in ~/.config/opencode/skills/ alone).
+  if (fs.existsSync(skillsRoot())) {
+    for (const entry of fs.readdirSync(skillsRoot())) {
+      if (entry.startsWith(`${NAMESPACE}-`)) {
+        const target = path.join(skillsRoot(), entry);
+        rmIfExists(target);
+        ui.step({ status: "remove", label: "skill", value: target });
+      }
+    }
+  }
+
+  unregisterMcpServer();
+  ui.step({ status: "info", label: "mcp server", value: "unregistered" });
+}

package/src/installers/tui.mjs

@@ -0,0 +1,125 @@
+// Minimal clack-style TUI primitives, but with full colour control over
+// every glyph. Replaces @clack/prompts where we need to paint the rail
+// itself (gradient) and animate text mid-line (harness shimmer) — both
+// of which clack hides behind util.styleText named-colour calls.
+//
+// API mirrors the slice of clack we used:
+//   intro(text)
+//   message(text, { symbol })
+//   outro(text)
+// Plus internal row tracking so a top→bottom gradient can be applied to
+// the rail glyphs.
+
+import { brand } from "./brand-theme.mjs";
+
+const FORCE_COLOR =
+  process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true";
+const NO_COLOR =
+  !!process.env.NO_COLOR ||
+  (!FORCE_COLOR && (!process.stdout.isTTY || process.env.TERM === "dumb"));
+
+const FG_RESET = "\x1b[39m";
+const FADE_ROWS = 28; // rail finishes fading after this many emitted rows
+
+let _row = 0;
+
+// Linear interpolate between #9999FF (techBlue40) and #6C7D8C (slate).
+// Top of the rail is bright tech-blue, fading to brand slate as the
+// install progresses — feels like the deck's tech-blue gradation card.
+function railEscape(row) {
+  if (NO_COLOR) return "";
+  const t = Math.min(row / FADE_ROWS, 1);
+  const r = Math.round(153 + (108 - 153) * t);
+  const g = Math.round(153 + (125 - 153) * t);
+  const b = Math.round(255 + (140 - 255) * t);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function paint(row, glyph) {
+  return NO_COLOR ? glyph : railEscape(row) + glyph + FG_RESET;
+}
+
+export function rail(row = _row) {
+  return paint(row, "│");
+}
+
+export function getRow() {
+  return _row;
+}
+export function bumpRow(n = 1) {
+  _row += n;
+}
+
+export function intro(text) {
+  _row = 0;
+  process.stdout.write("\n" + paint(_row, "┌") + "  " + text + "\n");
+}
+
+// Each message starts with its own gradient-coloured rail spacer, then
+// the glyph + text. The caller supplies `symbol` for non-rail glyphs
+// (◆ ● ▲ ■ etc.); when omitted we fall back to a continuation rail.
+export function message(text, { symbol } = {}) {
+  _row += 1;
+  process.stdout.write(paint(_row, "│") + "\n");
+  _row += 1;
+  const sym = symbol ?? paint(_row, "│");
+  process.stdout.write(sym + "  " + text + "\n");
+}
+
+export function outro(text) {
+  _row += 1;
+  process.stdout.write(paint(_row, "│") + "\n");
+  _row += 1;
+  process.stdout.write(paint(_row, "└") + "  " + text + "\n\n");
+  _row = 0;
+}
+
+// Reserve the next two rows for a spin step: emits the rail spacer,
+// returns the row index the spinner is written on. Callers should
+// `process.stdout.write(...)` the spinner content themselves (without a
+// trailing `\n`) so they can overwrite it via `\r`. When the operation
+// completes they call `commitSpinRow()` after writing the final line.
+export function reserveSpinRows() {
+  _row += 1;
+  process.stdout.write(paint(_row, "│") + "\n");
+  _row += 1;
+  return _row;
+}
+
+const ANIMATE = !NO_COLOR && process.stdout.isTTY;
+
+// Sweep a brightness "highlight" left-to-right across `text`, settling
+// on `restColor(text)` at the end. The caller has already positioned
+// the cursor where the text should appear; this helper writes only the
+// text region (no rail, no symbol) and uses `\r\x1b[<col>G` to reset to
+// that column for each redraw.
+export async function shimmer(text, { startCol = 1, restColor }) {
+  const final = brand.bold(restColor(text));
+  if (!ANIMATE) {
+    process.stdout.write(final);
+    return;
+  }
+  const len = text.length;
+  const sweepRange = len + 6; // start the wave just before the text
+  const frames = 14;
+  const frameMs = 45;
+
+  for (let f = 0; f <= frames; f++) {
+    const pos = (f / frames) * sweepRange - 3;
+    let line = "";
+    for (let i = 0; i < len; i++) {
+      const dist = i - pos;
+      const a = Math.abs(dist);
+      let painter;
+      if (a <= 1) painter = brand.techBlue20;       // peak brightness
+      else if (a <= 2.5) painter = brand.techBlue40;
+      else if (a <= 4) painter = brand.slate;
+      else painter = (s) => brand.dim(brand.slate(s));
+      line += brand.bold(painter(text[i]));
+    }
+    process.stdout.write(`\x1b[${startCol}G\x1b[K` + line);
+    if (f < frames) await new Promise((r) => setTimeout(r, frameMs));
+  }
+  // Final settle.
+  process.stdout.write(`\x1b[${startCol}G\x1b[K` + final);
+}

package/src/mcp/recolor.mjs

@@ -0,0 +1,111 @@
+// Describe how an engine result can be recoloured, so the agent never has to
+// open the SVG to find out (the exact step that was wasting time: "let me
+// inspect two SVGs to confirm how recolouring works").
+//
+// The slidemind_download_result tool already has the chosen result's bytes in
+// hand (the bridge returns `svgMarkup` for SVG results), so we can classify it
+// once and report the answer instead of leaving the agent to guess.
+//
+//   mode:
+//     "currentColor" — paints with fill/stroke="currentColor". A CSS `color`
+//                      on the <img> tints it live in BOTH the HTML preview
+//                      (which inlines the SVG, see src/builders/build.mjs) and
+//                      the .pptx render (which substitutes currentColor). You
+//                      can also bake a fixed colour in with icon_color.
+//     "mono"         — a single hard-coded paint colour (or the SVG default,
+//                      black) and no currentColor. CSS `color` will NOT touch
+//                      it — recolour by re-downloading with icon_color, which
+//                      makes the bridge rewrite the fill.
+//     "multicolor"   — several distinct paint colours. Leave it as-is; passing
+//                      icon_color would flatten a deliberately multi-tone glyph.
+//     "raster"       — PNG/JPEG/etc. Colour is not applicable.
+
+function isSvg(mimeType, svgMarkup) {
+  if (typeof svgMarkup === "string" && /<svg[\s>]/i.test(svgMarkup)) return true;
+  return /svg/i.test(String(mimeType || ""));
+}
+
+// Collect the distinct, concrete paint colours an SVG declares — via fill="…"
+// / stroke="…" attributes and `fill:`/`stroke:` style properties. `none`,
+// `transparent`, and `currentColor` are not concrete colours and are excluded.
+function distinctPaints(svgMarkup) {
+  const colors = new Set();
+  const re =
+    /(?:fill|stroke)\s*[:=]\s*["']?\s*(#[0-9a-fA-F]{3,8}|rgba?\([^)]*\)|hsla?\([^)]*\)|[a-zA-Z]+)/g;
+  let m;
+  while ((m = re.exec(svgMarkup)) !== null) {
+    const raw = m[1].trim().toLowerCase();
+    if (raw === "none" || raw === "transparent" || raw === "currentcolor") {
+      continue;
+    }
+    // Bare keyword that isn't a real colour name (e.g. "url" from url(#grad))
+    // would over-count; only keep hex/rgb/hsl and a small set of plain names.
+    if (/^#|^rgb|^hsl/.test(raw) || NAMED_COLORS.has(raw)) {
+      colors.add(raw);
+    }
+  }
+  return colors;
+}
+
+const NAMED_COLORS = new Set([
+  "black", "white", "red", "green", "blue", "yellow", "orange", "purple",
+  "pink", "gray", "grey", "cyan", "magenta", "brown", "navy", "teal",
+  "silver", "gold", "maroon", "olive", "lime", "aqua", "fuchsia",
+]);
+
+function hasCurrentColor(svgMarkup) {
+  return /(?:fill|stroke)\s*[:=]\s*["']?\s*currentColor/i.test(svgMarkup);
+}
+
+// Build the descriptor attached to a download result. `appliedColor` is the
+// hex the caller asked the bridge to bake in (null if none) — when present the
+// returned bytes are already coloured.
+export function describeRecolor(svgMarkup, mimeType, appliedColor = null) {
+  const applied = Boolean(appliedColor) && isSvg(mimeType, svgMarkup);
+
+  if (!isSvg(mimeType, svgMarkup)) {
+    return {
+      recolorable: false,
+      mode: "raster",
+      applied: false,
+      color: null,
+      note: "Raster image — recolouring not applicable.",
+    };
+  }
+
+  const markup = typeof svgMarkup === "string" ? svgMarkup : "";
+  let mode;
+  if (hasCurrentColor(markup)) {
+    mode = "currentColor";
+  } else {
+    const paints = distinctPaints(markup);
+    mode = paints.size >= 2 ? "multicolor" : "mono";
+  }
+
+  const recolorable = mode === "currentColor" || mode === "mono";
+
+  let note;
+  if (applied) {
+    note =
+      `Saved already coloured ${appliedColor} — reference it directly; ` +
+      `the colour is baked into the file (correct in preview and render).`;
+  } else if (mode === "currentColor") {
+    note =
+      "Tintable: set CSS `color` on the <img> (honoured in both the HTML " +
+      "preview and the .pptx render), or pass icon_color to bake a fixed colour in.";
+  } else if (mode === "mono") {
+    note =
+      "Single-colour glyph: CSS `color` won't tint it — re-download with " +
+      "icon_color (a hex resolved from a corporate-design.css token) to recolour.";
+  } else {
+    note = "Multi-colour glyph: leave as-is; icon_color would flatten it.";
+  }
+
+  return {
+    recolorable,
+    mode,
+    applied,
+    color: applied ? appliedColor : null,
+    note,
+  };
+}