@a-company/paradigm 3.21.0 → 3.23.0

package/dist/graph-5VSRBRKZ.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/graph.ts
+import chalk from "chalk";
+import * as fs from "fs";
+import * as pathMod from "path";
+async function graphCommand(path, options) {
+  const projectDir = path || process.cwd();
+  const port = parseInt(options.port || "3841", 10);
+  const shouldOpen = options.open !== false;
+  console.log(chalk.cyan("\nStarting Symbol Graph...\n"));
+  try {
+    const { startGraphServer } = await import("./graph-server-BZ73HTAT.js");
+    console.log(chalk.gray(`Project: ${projectDir}`));
+    console.log(chalk.gray(`Port: ${port}`));
+    console.log();
+    await startGraphServer({ port, projectDir, open: shouldOpen });
+    console.log(chalk.green(`
+Symbol Graph is running at http://localhost:${port}`));
+    console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    if (error.code === "EADDRINUSE") {
+      console.error(chalk.red(`
+Error: Port ${port} is already in use.`));
+      console.log(chalk.gray(`Try: paradigm graph --port ${port + 1}
+`));
+    } else {
+      console.error(chalk.red("\nFailed to start Symbol Graph:"), error);
+    }
+    process.exit(1);
+  }
+}
+var GRAPHS_DIR = ".paradigm/graphs";
+var CATEGORY_PREFIXES = {
+  component: "#",
+  flow: "$",
+  gate: "^",
+  signal: "!",
+  aspect: "~"
+};
+var NODE_W = 200;
+var NODE_H = 60;
+var NODE_GAP = 20;
+var GPAD = 40;
+var GHEADER = 50;
+var GGAP = 60;
+var SCAN_CATEGORY_MAP = {
+  components: "component",
+  flows: "flow",
+  gates: "gate",
+  signals: "signal",
+  aspects: "aspect"
+};
+function loadSymbolsFromIndex(projectDir) {
+  const indexPath = pathMod.join(projectDir, ".paradigm", "scan-index.json");
+  if (!fs.existsSync(indexPath)) return [];
+  const raw = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+  const out = [];
+  for (const [sectionKey, categoryName] of Object.entries(SCAN_CATEGORY_MAP)) {
+    const section = raw[sectionKey];
+    if (!section || typeof section !== "object") continue;
+    for (const [id, sym] of Object.entries(section)) {
+      const s = sym;
+      out.push({ id, name: id, category: categoryName, prefix: CATEGORY_PREFIXES[categoryName] || "#", description: s.description, path: s.path });
+    }
+  }
+  return out;
+}
+function resolveSymbol(name, all) {
+  const stripped = name.replace(/^[#$^!~]/, "");
+  return all.find((s) => s.id === stripped || s.name === stripped || s.id === name || s.name === name);
+}
+function cliBuildGraphState(projectDir, symbolFilter, groups, links, graphName = "Generated Graph") {
+  const allSymbols = loadSymbolsFromIndex(projectDir);
+  let included = symbolFilter && symbolFilter.length > 0 ? symbolFilter.map((n) => resolveSymbol(n, allSymbols)).filter(Boolean) : allSymbols;
+  const nodes = [];
+  const edges = [];
+  const groupIdMap = /* @__PURE__ */ new Map();
+  const assigned = /* @__PURE__ */ new Set();
+  let nextX = 0;
+  if (groups && groups.length > 0) {
+    for (const g of groups) {
+      const gid = `group-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+      groupIdMap.set(g.label, gid);
+      const members = g.symbols.map((n) => resolveSymbol(n, included)).filter(Boolean);
+      const cols = Math.max(Math.ceil(Math.sqrt(members.length)), 1);
+      const rows = Math.max(Math.ceil(members.length / cols), 1);
+      for (let i = 0; i < members.length; i++) {
+        const sym = members[i];
+        const c = i % cols, r = Math.floor(i / cols);
+        nodes.push({ id: `sym-${sym.id}`, type: "symbolNode", position: { x: GPAD + c * (NODE_W + NODE_GAP), y: GHEADER + GPAD + r * (NODE_H + NODE_GAP) }, parentId: gid, data: { type: "symbol", symbol: sym, label: `${CATEGORY_PREFIXES[sym.category] || "#"}${sym.name}` } });
+        assigned.add(sym.id);
+      }
+      const gw = GPAD * 2 + cols * NODE_W + (cols - 1) * NODE_GAP;
+      const gh = GHEADER + GPAD * 2 + rows * NODE_H + (rows - 1) * NODE_GAP;
+      nodes.unshift({ id: gid, type: "groupNode", position: { x: nextX, y: 0 }, style: { width: gw, height: gh }, data: { type: "group", label: g.label } });
+      nextX += gw + GGAP;
+    }
+  }
+  const ungrouped = included.filter((s) => !assigned.has(s.id));
+  if (ungrouped.length > 0) {
+    const startY = groups && groups.length > 0 ? 400 : 0;
+    const cols = Math.max(Math.ceil(Math.sqrt(ungrouped.length)), 1);
+    for (let i = 0; i < ungrouped.length; i++) {
+      const sym = ungrouped[i];
+      const c = i % cols, r = Math.floor(i / cols);
+      nodes.push({ id: `sym-${sym.id}`, type: "symbolNode", position: { x: c * (NODE_W + NODE_GAP), y: startY + r * (NODE_H + NODE_GAP) }, data: { type: "symbol", symbol: sym, label: `${CATEGORY_PREFIXES[sym.category] || "#"}${sym.name}` } });
+    }
+  }
+  if (links && links.length > 0) {
+    for (const l of links) {
+      const src = groupIdMap.get(l.source), tgt = groupIdMap.get(l.target);
+      if (src && tgt) edges.push({ id: `e-${src}-${tgt}`, source: src, target: tgt, type: "default", label: l.label, data: { label: l.label } });
+    }
+  }
+  return { version: "1.0", name: graphName, projectId: pathMod.basename(projectDir), lastModified: (/* @__PURE__ */ new Date()).toISOString(), nodes, edges };
+}
+async function graphGenerateCommand(name, path, options) {
+  const projectDir = path || process.cwd();
+  const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  try {
+    const symbolFilter = options.symbols ? options.symbols.split(",").map((s) => s.trim()) : void 0;
+    const groups = options.group?.map((g) => {
+      const colonIdx = g.indexOf(":");
+      if (colonIdx === -1) {
+        console.error(chalk.red(`Invalid group format: "${g}". Expected "Label:#sym1,#sym2"`));
+        process.exit(1);
+      }
+      return { label: g.slice(0, colonIdx), symbols: g.slice(colonIdx + 1).split(",").map((s) => s.trim()) };
+    });
+    const links = options.link?.map((l) => {
+      const arrowIdx = l.indexOf(">");
+      if (arrowIdx === -1) {
+        console.error(chalk.red(`Invalid link format: "${l}". Expected "Source>Target:label"`));
+        process.exit(1);
+      }
+      const source = l.slice(0, arrowIdx);
+      const rest = l.slice(arrowIdx + 1);
+      const colonIdx = rest.indexOf(":");
+      return { source, target: colonIdx === -1 ? rest : rest.slice(0, colonIdx), label: colonIdx === -1 ? void 0 : rest.slice(colonIdx + 1) };
+    });
+    const state = cliBuildGraphState(projectDir, symbolFilter, groups, links, name);
+    const json = JSON.stringify(state, null, 2);
+    const graphsDir = pathMod.join(projectDir, GRAPHS_DIR);
+    if (!fs.existsSync(graphsDir)) fs.mkdirSync(graphsDir, { recursive: true });
+    const outPath = pathMod.join(graphsDir, `${slug}.graph.json`);
+    fs.writeFileSync(outPath, json, "utf8");
+    console.log(chalk.green(`Graph saved to ${outPath}`));
+    console.log(chalk.gray(`${state.nodes.length} nodes, ${state.edges.length} edges, ${(json.length / 1024).toFixed(1)} KB`));
+    console.log(chalk.gray(`
+View: paradigm graph`));
+  } catch (error) {
+    console.error(chalk.red("Failed to generate graph:"), error.message);
+    process.exit(1);
+  }
+}
+export {
+  graphCommand,
+  graphGenerateCommand
+};

package/dist/graph-server-BZ73HTAT.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/graph-server/index.ts
+import express from "express";
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+
+// src/graph-server/routes/symbols.ts
+import { Router } from "express";
+import * as fs from "fs";
+import * as path from "path";
+function createSymbolsRouter(projectDir) {
+  const router = Router();
+  router.get("/", (_req, res) => {
+    const indexPath = path.join(projectDir, ".paradigm", "scan-index.json");
+    if (!fs.existsSync(indexPath)) {
+      res.status(404).json({
+        error: "scan-index.json not found",
+        hint: "Run `paradigm scan` to generate the symbol index."
+      });
+      return;
+    }
+    try {
+      const raw = fs.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(raw);
+      const categoryMap = {
+        components: "component",
+        features: "component",
+        flows: "flow",
+        state: "component",
+        gates: "gate",
+        signals: "signal",
+        aspects: "aspect",
+        screens: "component"
+      };
+      const prefixMap = {
+        component: "#",
+        flow: "$",
+        gate: "^",
+        signal: "!",
+        aspect: "~"
+      };
+      const symbols = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const [sectionKey, category] of Object.entries(categoryMap)) {
+        const entries = index[sectionKey];
+        if (!entries || typeof entries !== "object") continue;
+        const items = Array.isArray(entries) ? entries : Object.values(entries);
+        for (const entry of items) {
+          const name = entry.name || entry.id || "";
+          if (!name || seen.has(name)) continue;
+          seen.add(name);
+          symbols.push({
+            id: name,
+            name,
+            category,
+            prefix: prefixMap[category] || "#",
+            description: entry.description || "",
+            path: entry.path || entry.file || "",
+            tags: entry.tags || [],
+            related: entry.related || []
+          });
+        }
+      }
+      res.json({
+        symbols,
+        meta: {
+          total: symbols.length,
+          projectDir,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } catch (err) {
+      res.status(500).json({
+        error: "Failed to read scan-index.json",
+        details: err.message
+      });
+    }
+  });
+  return router;
+}
+
+// src/graph-server/routes/graphs.ts
+import { Router as Router2 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var GRAPHS_DIR = ".paradigm/graphs";
+function createGraphsRouter(projectDir) {
+  const router = Router2();
+  const graphsPath = path2.join(projectDir, GRAPHS_DIR);
+  router.get("/", (_req, res) => {
+    if (!fs2.existsSync(graphsPath)) {
+      res.json({ graphs: [] });
+      return;
+    }
+    try {
+      const files = fs2.readdirSync(graphsPath).filter((f) => f.endsWith(".graph.json"));
+      const graphs = files.map((file) => {
+        const filePath = path2.join(graphsPath, file);
+        const stat = fs2.statSync(filePath);
+        const slug = file.replace(/\.graph\.json$/, "");
+        let name = slug;
+        let nodeCount = 0;
+        let edgeCount = 0;
+        try {
+          const raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+          name = raw.name || slug;
+          nodeCount = Array.isArray(raw.nodes) ? raw.nodes.length : 0;
+          edgeCount = Array.isArray(raw.edges) ? raw.edges.length : 0;
+        } catch {
+        }
+        return {
+          slug,
+          file,
+          name,
+          nodes: nodeCount,
+          edges: edgeCount,
+          size: stat.size,
+          modified: stat.mtime.toISOString()
+        };
+      });
+      graphs.sort((a, b) => b.modified.localeCompare(a.modified));
+      res.json({ graphs });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list graphs", details: err.message });
+    }
+  });
+  router.get("/:slug", (req, res) => {
+    const slug = req.params.slug;
+    const filePath = path2.join(graphsPath, `${slug}.graph.json`);
+    if (!fs2.existsSync(filePath)) {
+      res.status(404).json({ error: `Graph "${slug}" not found` });
+      return;
+    }
+    try {
+      const raw = fs2.readFileSync(filePath, "utf8");
+      res.type("application/json").send(raw);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read graph", details: err.message });
+    }
+  });
+  return router;
+}
+
+// src/graph-server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.blue("i")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.green("+")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.yellow("!")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk.red("x")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function createGraphApp(options) {
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    if (_req.method === "OPTIONS") {
+      res.sendStatus(204);
+      return;
+    }
+    next();
+  });
+  app.use("/api/symbols", createSymbolsRouter(options.projectDir));
+  app.use("/api/graphs", createGraphsRouter(options.projectDir));
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  let uiDistPath = path3.join(__dirname, "..", "graph-ui", "dist");
+  if (!fs3.existsSync(uiDistPath)) {
+    uiDistPath = path3.join(__dirname, "..", "..", "graph-ui", "dist");
+  }
+  if (fs3.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path3.join(uiDistPath, "index.html"));
+      }
+    });
+  } else {
+    app.get("/", (_req, res) => {
+      res.send(`
+        <html>
+        <head><title>Paradigm Graph</title></head>
+        <body style="background:#0a0a0f;color:#e2e8f0;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
+          <div style="text-align:center">
+            <h1>Paradigm Graph</h1>
+            <p style="color:#94a3b8">UI not built yet. Run <code style="background:#1e293b;padding:4px 8px;border-radius:4px">cd graph-ui && npx vite build</code></p>
+            <p style="color:#94a3b8">API available at <a href="/api/symbols" style="color:#7dd3fc">/api/symbols</a></p>
+          </div>
+        </body>
+        </html>
+      `);
+    });
+  }
+  return app;
+}
+async function startGraphServer(options) {
+  const app = createGraphApp(options);
+  log.component("graph-server").info("Starting server", { port: options.port });
+  log.component("graph-server").info("Project directory", { path: options.projectDir });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(options.port, () => {
+      log.component("graph-server").success("Server running", { url: `http://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log.component("graph-server").info("Opened browser");
+        }).catch(() => {
+          log.component("graph-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.component("graph-server").error("Port already in use", { port: options.port });
+      } else {
+        log.component("graph-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+export {
+  createGraphApp,
+  startGraphServer
+};

package/dist/index.js

@@ -660,6 +660,14 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
   const { loreServeCommand } = await import("./serve-DIALBCTU.js");
   await loreServeCommand(void 0, options);
 });
+var graphCmd = program.command("graph").description("Interactive symbol relationship graph").argument("[path]", "Project directory", void 0).option("-p, --port <port>", "Port to run on", "3841").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
+  const { graphCommand } = await import("./graph-5VSRBRKZ.js");
+  await graphCommand(path2, options);
+});
+graphCmd.command("generate").description("Generate a named graph file in .paradigm/graphs/").argument("<name>", "Graph name (used as filename: {name}.graph.json)").argument("[path]", "Project directory", void 0).option("-s, --symbols <list>", "Comma-separated symbol names to include").option("-g, --group <spec...>", 'Group spec: "Label:#sym1,#sym2" (repeatable)').option("-l, --link <spec...>", 'Link spec: "Source>Target:label" (repeatable)').action(async (name, path2, options) => {
+  const { graphGenerateCommand } = await import("./graph-5VSRBRKZ.js");
+  await graphGenerateCommand(name, path2, options);
+});
 var habitsCmd = program.command("habits").description("Behavioral habits - practice tracking and compliance");
 habitsCmd.command("list").alias("ls").description("List all configured habits").option("--trigger <trigger>", "Filter by trigger: preflight, postflight, on-stop, on-commit").option("--category <category>", "Filter by category: discovery, verification, testing, documentation, collaboration, security").option("--json", "Output as JSON").action(async (options) => {
   const { habitsListCommand } = await import("./habits-7BORPC2F.js");