@caoscompanybr/merlin 3.5.0

package/.merlin-core/skills/general/blkskrn/scripts/canvas-manager.js

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+/**
+ * BLKSKRN Canvas Manager — CLI for local canvas CRUD
+ *
+ * Commands:
+ *   create <name> [--type presentation|board]
+ *   list
+ *   add-slide <canvas-id> <slide-html-path> [--title "..."]
+ *   build <canvas-id>
+ *   delete <canvas-id>
+ *   open <canvas-id>
+ *
+ * @module blkskrn/canvas-manager
+ * @version 2.13.1
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { execSync } = require("child_process");
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+function findProjectRoot(startDir) {
+  let dir = startDir || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (
+      fs.existsSync(path.join(dir, ".merlin-core")) ||
+      fs.existsSync(path.join(dir, ".git"))
+    ) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+const PROJECT_ROOT = findProjectRoot();
+const CANVAS_DIR = path.join(PROJECT_ROOT, ".merlin", "canvas");
+const BOARDS_DIR = path.join(CANVAS_DIR, "boards");
+const REGISTRY_PATH = path.join(CANVAS_DIR, "registry.json");
+const SKILL_DIR = path.resolve(__dirname, "..");
+const TEMPLATES_DIR = path.join(SKILL_DIR, "templates");
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+function ensureDirs() {
+  fs.mkdirSync(BOARDS_DIR, { recursive: true });
+}
+
+function loadRegistry() {
+  if (!fs.existsSync(REGISTRY_PATH)) {
+    return { version: "1.0", canvases: [] };
+  }
+  return JSON.parse(fs.readFileSync(REGISTRY_PATH, "utf-8"));
+}
+
+function saveRegistry(registry) {
+  ensureDirs();
+  fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
+}
+
+function validateCanvasId(canvasId) {
+  if (!canvasId || !/^[a-f0-9-]+$/i.test(canvasId)) {
+    console.error(
+      `Error: Invalid canvas ID "${canvasId}". Must be alphanumeric/hex.`,
+    );
+    process.exit(1);
+  }
+}
+
+function loadCanvas(canvasId) {
+  validateCanvasId(canvasId);
+  const canvasFile = path.join(BOARDS_DIR, canvasId, "canvas.json");
+  if (!fs.existsSync(canvasFile)) {
+    console.error(`Error: Canvas "${canvasId}" not found.`);
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(canvasFile, "utf-8"));
+}
+
+function saveCanvas(canvas) {
+  const canvasDir = path.join(BOARDS_DIR, canvas.id);
+  fs.mkdirSync(path.join(canvasDir, "slides"), { recursive: true });
+  canvas.updatedAt = new Date().toISOString();
+  fs.writeFileSync(
+    path.join(canvasDir, "canvas.json"),
+    JSON.stringify(canvas, null, 2),
+    "utf-8",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+function cmdCreate(name, type) {
+  ensureDirs();
+  const id = crypto.randomUUID().slice(0, 8);
+  const now = new Date().toISOString();
+  const boardDir = path.join(BOARDS_DIR, id);
+
+  fs.mkdirSync(path.join(boardDir, "slides"), { recursive: true });
+
+  const canvas = {
+    id,
+    name,
+    type: type || "presentation",
+    settings: { width: 1440, height: 810, theme: "dark", columns: 4 },
+    slides: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  fs.writeFileSync(
+    path.join(boardDir, "canvas.json"),
+    JSON.stringify(canvas, null, 2),
+    "utf-8",
+  );
+
+  // Update registry
+  const registry = loadRegistry();
+  registry.canvases.push({
+    id,
+    name,
+    type: canvas.type,
+    createdAt: now,
+    updatedAt: now,
+    slideCount: 0,
+    path: `boards/${id}/`,
+  });
+  saveRegistry(registry);
+
+  console.log(`Created canvas ${id} at .merlin/canvas/boards/${id}/`);
+  console.log(`  Name: ${name}`);
+  console.log(`  Type: ${canvas.type}`);
+  return id;
+}
+
+function cmdList() {
+  const registry = loadRegistry();
+  if (registry.canvases.length === 0) {
+    console.log(
+      "No canvases found. Create one with: canvas-manager create <name>",
+    );
+    return;
+  }
+
+  console.log("");
+  console.log("  Canvases");
+  console.log("  " + "=".repeat(70));
+
+  for (const c of registry.canvases) {
+    // Refresh slide count from canvas.json
+    const canvasFile = path.join(BOARDS_DIR, c.id, "canvas.json");
+    let slideCount = c.slideCount || 0;
+    if (fs.existsSync(canvasFile)) {
+      const data = JSON.parse(fs.readFileSync(canvasFile, "utf-8"));
+      slideCount = data.slides ? data.slides.length : 0;
+    }
+
+    const date = c.createdAt ? c.createdAt.slice(0, 10) : "unknown";
+    console.log(
+      `  ${c.id}  ${c.name.padEnd(30)}  ${String(slideCount).padStart(2)} slides  ${c.type.padEnd(14)}  ${date}`,
+    );
+  }
+  console.log("");
+}
+
+function cmdAddSlide(canvasId, slidePath, title) {
+  const canvas = loadCanvas(canvasId);
+
+  if (!fs.existsSync(slidePath)) {
+    console.error(`Error: Slide file not found: ${slidePath}`);
+    process.exit(1);
+  }
+
+  const slideContent = fs.readFileSync(slidePath, "utf-8");
+  const slideOrder = canvas.slides.length + 1;
+  const slideId = `slide-${String(slideOrder).padStart(2, "0")}`;
+  const fileName = `${String(slideOrder).padStart(2, "0")}-${slugify(title || `slide-${slideOrder}`)}.html`;
+  const destPath = path.join(BOARDS_DIR, canvasId, "slides", fileName);
+
+  fs.writeFileSync(destPath, slideContent, "utf-8");
+
+  canvas.slides.push({
+    id: slideId,
+    order: slideOrder,
+    title: title || `Slide ${slideOrder}`,
+    file: `slides/${fileName}`,
+    type: inferSlideType(slideContent),
+  });
+
+  saveCanvas(canvas);
+
+  // Update registry
+  const registry = loadRegistry();
+  const entry = registry.canvases.find((c) => c.id === canvasId);
+  if (entry) {
+    entry.slideCount = canvas.slides.length;
+    entry.updatedAt = canvas.updatedAt;
+    saveRegistry(registry);
+  }
+
+  console.log(
+    `Added slide ${slideOrder} "${title || fileName}" to canvas ${canvasId}`,
+  );
+}
+
+function cmdBuild(canvasId) {
+  const canvas = loadCanvas(canvasId);
+  const boardDir = path.join(BOARDS_DIR, canvasId);
+
+  if (canvas.slides.length === 0) {
+    console.error(
+      "Error: Canvas has no slides. Add slides first with add-slide.",
+    );
+    process.exit(1);
+  }
+
+  // Read presenter template
+  const templatePath = path.join(TEMPLATES_DIR, "presenter.html");
+  if (!fs.existsSync(templatePath)) {
+    console.error("Error: Presenter template not found at " + templatePath);
+    process.exit(1);
+  }
+  let template = fs.readFileSync(templatePath, "utf-8");
+
+  // Build slide sections (only for slides whose files exist)
+  const slideSections = [];
+  const validSlides = [];
+  for (let i = 0; i < canvas.slides.length; i++) {
+    const slide = canvas.slides[i];
+    const slideFile = path.join(boardDir, slide.file);
+    if (!fs.existsSync(slideFile)) {
+      console.warn(`Warning: Slide file missing: ${slide.file} — skipping`);
+      continue;
+    }
+    const content = fs.readFileSync(slideFile, "utf-8");
+    const idx = slideSections.length;
+
+    slideSections.push(
+      `  <div class="slide-section" data-slide="${idx}">\n` +
+        `    <iframe srcdoc="${escapeForSrcdoc(content)}" sandbox="allow-scripts"></iframe>\n` +
+        `  </div>`,
+    );
+    validSlides.push(slide);
+  }
+
+  // Build dots (matched to actual valid slides)
+  const dotsHtml = validSlides
+    .map(
+      (_, i) =>
+        `    <button class="dot" data-slide="${i}" aria-label="Slide ${i + 1}"></button>`,
+    )
+    .join("\n");
+
+  // Replace tokens
+  template = template.replace(/\{\{CANVAS_NAME\}\}/g, canvas.name);
+  template = template.replace(
+    /\{\{SLIDE_COUNT\}\}/g,
+    String(validSlides.length),
+  );
+  template = template.replace("{{SLIDES_CONTENT}}", slideSections.join("\n\n"));
+  template = template.replace("{{DOTS_HTML}}", dotsHtml);
+
+  // Write presenter
+  const outputPath = path.join(boardDir, "index.html");
+  fs.writeFileSync(outputPath, template, "utf-8");
+
+  // Also build viewer
+  buildViewer(canvas, boardDir);
+
+  console.log(
+    `Built presenter at .merlin/canvas/boards/${canvasId}/index.html`,
+  );
+  console.log(`Built viewer at .merlin/canvas/boards/${canvasId}/viewer.html`);
+  console.log(`  ${canvas.slides.length} slides assembled`);
+}
+
+function buildViewer(canvas, boardDir) {
+  const viewerTemplatePath = path.join(TEMPLATES_DIR, "viewer.html");
+  if (!fs.existsSync(viewerTemplatePath)) return;
+
+  let template = fs.readFileSync(viewerTemplatePath, "utf-8");
+
+  const thumbnails = [];
+  for (let i = 0; i < canvas.slides.length; i++) {
+    const slide = canvas.slides[i];
+    const slideFile = path.join(boardDir, slide.file);
+    if (!fs.existsSync(slideFile)) continue;
+
+    const content = fs.readFileSync(slideFile, "utf-8");
+
+    thumbnails.push(
+      `  <div class="slide-thumb" onclick="window.location.href='index.html#${i}'">\n` +
+        `    <iframe srcdoc="${escapeForSrcdoc(content)}" sandbox="allow-scripts"></iframe>\n` +
+        `    <div class="slide-label">\n` +
+        `      <span>${slide.title}</span>\n` +
+        `      <span class="num">${String(i + 1).padStart(2, "0")}</span>\n` +
+        `    </div>\n` +
+        `  </div>`,
+    );
+  }
+
+  template = template.replace(/\{\{CANVAS_NAME\}\}/g, canvas.name);
+  template = template.replace(
+    /\{\{SLIDE_COUNT\}\}/g,
+    String(canvas.slides.length),
+  );
+  template = template.replace("{{THUMBNAILS_HTML}}", thumbnails.join("\n\n"));
+
+  fs.writeFileSync(path.join(boardDir, "viewer.html"), template, "utf-8");
+}
+
+function cmdDelete(canvasId) {
+  validateCanvasId(canvasId);
+  const boardDir = path.join(BOARDS_DIR, canvasId);
+  if (!fs.existsSync(boardDir)) {
+    console.error(`Error: Canvas "${canvasId}" not found.`);
+    process.exit(1);
+  }
+
+  fs.rmSync(boardDir, { recursive: true, force: true });
+
+  const registry = loadRegistry();
+  registry.canvases = registry.canvases.filter((c) => c.id !== canvasId);
+  saveRegistry(registry);
+
+  console.log(`Deleted canvas ${canvasId}`);
+}
+
+function cmdOpen(canvasId) {
+  validateCanvasId(canvasId);
+  const indexPath = path.join(BOARDS_DIR, canvasId, "index.html");
+  if (!fs.existsSync(indexPath)) {
+    // Try building first
+    console.log("Presenter not built yet — building now...");
+    cmdBuild(canvasId);
+  }
+
+  const absPath = path.resolve(indexPath);
+  const platform = process.platform;
+
+  try {
+    if (platform === "win32") {
+      execSync(`start "" "${absPath}"`, { stdio: "ignore" });
+    } else if (platform === "darwin") {
+      execSync(`open "${absPath}"`, { stdio: "ignore" });
+    } else {
+      execSync(`xdg-open "${absPath}"`, { stdio: "ignore" });
+    }
+    console.log(`Opened ${absPath}`);
+  } catch {
+    console.log(`Open this file in your browser: ${absPath}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function escapeForSrcdoc(html) {
+  return html
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/<\/iframe/gi, "&lt;/iframe");
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 40);
+}
+
+function inferSlideType(html) {
+  const lower = html.toLowerCase();
+  if (lower.includes("hero-title") || lower.includes("logo-mark"))
+    return "title";
+  if (lower.includes("stat-card") || lower.includes("stat-value"))
+    return "stats";
+  if (lower.includes("grid-bg") || lower.includes("split"))
+    return "architecture";
+  if (lower.includes("feat-card")) return "feature-grid";
+  if (lower.includes("slide-footer")) return "closing";
+  return "content";
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0];
+  const positional = [];
+  const flags = {};
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const key = args[i].slice(2);
+      const val =
+        args[i + 1] && !args[i + 1].startsWith("--") ? args[++i] : true;
+      flags[key] = val;
+    } else {
+      positional.push(args[i]);
+    }
+  }
+
+  return { command, positional, flags };
+}
+
+function main() {
+  const { command, positional, flags } = parseArgs(process.argv);
+
+  switch (command) {
+    case "create":
+      if (!positional[0]) {
+        console.error(
+          "Usage: canvas-manager create <name> [--type presentation|board]",
+        );
+        process.exit(1);
+      }
+      cmdCreate(positional[0], flags.type);
+      break;
+
+    case "list":
+      cmdList();
+      break;
+
+    case "add-slide":
+      if (!positional[0] || !positional[1]) {
+        console.error(
+          'Usage: canvas-manager add-slide <canvas-id> <slide-path> [--title "..."]',
+        );
+        process.exit(1);
+      }
+      cmdAddSlide(positional[0], positional[1], flags.title);
+      break;
+
+    case "build":
+      if (!positional[0]) {
+        console.error("Usage: canvas-manager build <canvas-id>");
+        process.exit(1);
+      }
+      cmdBuild(positional[0]);
+      break;
+
+    case "delete":
+      if (!positional[0]) {
+        console.error("Usage: canvas-manager delete <canvas-id>");
+        process.exit(1);
+      }
+      cmdDelete(positional[0]);
+      break;
+
+    case "open":
+      if (!positional[0]) {
+        console.error("Usage: canvas-manager open <canvas-id>");
+        process.exit(1);
+      }
+      cmdOpen(positional[0]);
+      break;
+
+    default:
+      console.log("");
+      console.log("  Canvas Manager — Merlin Local Canvas CLI");
+      console.log("  =========================================");
+      console.log("");
+      console.log("  Commands:");
+      console.log(
+        "    create <name> [--type presentation|board]   Create a new canvas",
+      );
+      console.log(
+        "    list                                        List all canvases",
+      );
+      console.log(
+        '    add-slide <id> <path> [--title "..."]       Add a slide to canvas',
+      );
+      console.log(
+        "    build <id>                                  Build presenter HTML",
+      );
+      console.log(
+        "    delete <id>                                 Delete a canvas",
+      );
+      console.log(
+        "    open <id>                                   Open in browser",
+      );
+      console.log("");
+      break;
+  }
+}
+
+main();

package/.merlin-core/skills/general/blkskrn/scripts/presenter.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * BLKSKRN Presenter — Quick-launch a canvas presentation in the default browser
+ *
+ * Usage:
+ *   node presenter.js <canvas-id>
+ *   node presenter.js --viewer <canvas-id>    # Open grid viewer instead
+ *
+ * @module blkskrn/presenter
+ * @version 2.13.1
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+function findProjectRoot(startDir) {
+  let dir = startDir || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (
+      fs.existsSync(path.join(dir, ".merlin-core")) ||
+      fs.existsSync(path.join(dir, ".git"))
+    ) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function openInBrowser(filePath) {
+  const absPath = path.resolve(filePath);
+  const platform = process.platform;
+
+  try {
+    if (platform === "win32") {
+      execSync(`start "" "${absPath}"`, { stdio: "ignore" });
+    } else if (platform === "darwin") {
+      execSync(`open "${absPath}"`, { stdio: "ignore" });
+    } else {
+      execSync(`xdg-open "${absPath}"`, { stdio: "ignore" });
+    }
+    console.log(`Opened: ${absPath}`);
+  } catch {
+    console.log(`Open this file in your browser: ${absPath}`);
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let viewer = false;
+  let canvasId = null;
+
+  for (const arg of args) {
+    if (arg === "--viewer") {
+      viewer = true;
+    } else if (!arg.startsWith("-")) {
+      canvasId = arg;
+    }
+  }
+
+  if (!canvasId) {
+    console.error("Usage: presenter.js <canvas-id> [--viewer]");
+    process.exit(1);
+  }
+
+  const root = findProjectRoot();
+  const boardDir = path.join(root, ".merlin", "canvas", "boards", canvasId);
+
+  if (!fs.existsSync(boardDir)) {
+    console.error(`Canvas "${canvasId}" not found at ${boardDir}`);
+    process.exit(1);
+  }
+
+  const fileName = viewer ? "viewer.html" : "index.html";
+  const filePath = path.join(boardDir, fileName);
+
+  if (!fs.existsSync(filePath)) {
+    console.error(
+      `${fileName} not found. Run canvas-manager build ${canvasId} first.`,
+    );
+    process.exit(1);
+  }
+
+  openInBrowser(filePath);
+}
+
+main();