@a-company/paradigm 3.20.2 → 3.22.0

package/dist/graph-BFZXFAFL.js

@@ -0,0 +1,160 @@
+#!/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-BPKQYSQK.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 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(path, options) {
+  const projectDir = path || process.cwd();
+  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, options.name || "Generated Graph");
+    const json = JSON.stringify(state, null, 2);
+    if (options.output) {
+      fs.writeFileSync(options.output, json, "utf8");
+      console.log(chalk.green(`Graph written to ${options.output}`));
+      console.log(chalk.gray(`${state.nodes.length} nodes, ${state.edges.length} edges`));
+    } else {
+      process.stdout.write(json + "\n");
+    }
+  } catch (error) {
+    console.error(chalk.red("Failed to generate graph:"), error.message);
+    process.exit(1);
+  }
+}
+export {
+  graphCommand,
+  graphGenerateCommand
+};

package/dist/graph-server-BPKQYSQK.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/graph-server/index.ts
+import express from "express";
+import * as path2 from "path";
+import * as fs2 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/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.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.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  let uiDistPath = path2.join(__dirname, "..", "graph-ui", "dist");
+  if (!fs2.existsSync(uiDistPath)) {
+    uiDistPath = path2.join(__dirname, "..", "..", "graph-ui", "dist");
+  }
+  if (fs2.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path2.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/{habits-KD4RLIN2.js → habits-7BORPC2F.js}

@@ -263,22 +263,45 @@ function loadHabitsFresh(rootDir) {
   for (const seed of SEED_HABITS) {
     habitsById.set(seed.id, { ...seed });
   }
-  const globalHabitsPath = path.join(
-    process.env.HOME || process.env.USERPROFILE || "~",
-    ".paradigm",
-    "habits.yaml"
-  );
-  const globalConfig = loadHabitsYaml(globalHabitsPath);
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  const globalConfig = loadHabitsYaml(path.join(home, ".paradigm", "habits.yaml"));
   if (globalConfig) {
     mergeHabits(habitsById, globalConfig);
   }
-  const projectHabitsPath = path.join(rootDir, ".paradigm", "habits.yaml");
-  const projectConfig = loadHabitsYaml(projectHabitsPath);
+  const globalHabitFiles = loadHabitFiles(path.join(home, ".paradigm", "habits"));
+  for (const habit of globalHabitFiles) {
+    habitsById.set(habit.id, habit);
+  }
+  const projectConfig = loadHabitsYaml(path.join(rootDir, ".paradigm", "habits.yaml"));
   if (projectConfig) {
     mergeHabits(habitsById, projectConfig);
   }
+  const projectHabitFiles = loadHabitFiles(path.join(rootDir, ".paradigm", "habits"));
+  for (const habit of projectHabitFiles) {
+    habitsById.set(habit.id, habit);
+  }
   return Array.from(habitsById.values());
 }
+function loadHabitFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  try {
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".habit")).sort();
+    const habits = [];
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dir, file), "utf8");
+        const habit = yaml.load(content);
+        if (habit?.id && habit?.name) {
+          habits.push(habit);
+        }
+      } catch {
+      }
+    }
+    return habits;
+  } catch {
+    return [];
+  }
+}
 function loadHabitsYaml(filePath) {
   if (!fs.existsSync(filePath)) {
     return null;

package/dist/index.js

@@ -660,45 +660,53 @@ 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-BFZXFAFL.js");
+  await graphCommand(path2, options);
+});
+graphCmd.command("generate").description("Generate GraphState JSON from symbols (for agents / piping)").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)').option("-n, --name <name>", "Graph name", "Generated Graph").option("-o, --output <file>", "Write to file instead of stdout").action(async (path2, options) => {
+  const { graphGenerateCommand } = await import("./graph-BFZXFAFL.js");
+  await graphGenerateCommand(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-KD4RLIN2.js");
+  const { habitsListCommand } = await import("./habits-7BORPC2F.js");
   await habitsListCommand(options);
 });
 habitsCmd.command("status").description("Show practice profile with compliance rates").option("-p, --period <period>", "Time period: 7d, 30d, 90d, all", "30d").option("--json", "Output as JSON").action(async (options) => {
-  const { habitsStatusCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsStatusCommand } = await import("./habits-7BORPC2F.js");
   await habitsStatusCommand(options);
 });
 habitsCmd.command("init").description("Initialize habits.yaml with seed habits").option("-f, --force", "Overwrite existing file").action(async (options) => {
-  const { habitsInitCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsInitCommand } = await import("./habits-7BORPC2F.js");
   await habitsInitCommand(options);
 });
 habitsCmd.command("check").description("Evaluate habit compliance for a trigger point").requiredOption("-t, --trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--record", "Record practice events to Sentinel").option("--json", "Output as JSON").option("--files <files>", "Comma-separated files modified (default: git diff)").option("--symbols <symbols>", "Comma-separated symbols touched").action(async (options) => {
-  const { habitsCheckCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsCheckCommand } = await import("./habits-7BORPC2F.js");
   await habitsCheckCommand(options);
 });
 habitsCmd.command("add").description("Add a custom habit").requiredOption("--id <id>", "Habit ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").requiredOption("--description <desc>", "What this habit enforces").requiredOption("--category <category>", "Category: discovery, verification, testing, documentation, collaboration, security").requiredOption("--trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--severity <severity>", "Severity: advisory, warn, block", "advisory").option("--tools <tools>", "Comma-separated tools to check (for tool-called check type)").option("--check-type <type>", "Check type: tool-called, file-exists, file-modified, lore-recorded, symbols-registered, gates-declared, tests-exist, git-clean", "tool-called").option("--patterns <patterns>", "Comma-separated patterns (for file-exists, file-modified, tests-exist check types)").action(async (options) => {
-  const { habitsAddCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsAddCommand } = await import("./habits-7BORPC2F.js");
   await habitsAddCommand({ ...options, checkType: options.checkType });
 });
 habitsCmd.command("edit <id>").description("Edit a habit (seed habits: only severity/enabled; custom: all fields)").option("--name <name>", "New name").option("--description <desc>", "New description").option("--category <category>", "New category").option("--trigger <trigger>", "New trigger").option("--severity <severity>", "New severity: advisory, warn, block").option("--enabled <bool>", "Enable or disable: true, false").option("--check-type <type>", "New check type").option("--patterns <patterns>", "Comma-separated patterns").option("--tools <tools>", "Comma-separated tools").action(async (id, options) => {
-  const { habitsEditCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsEditCommand } = await import("./habits-7BORPC2F.js");
   await habitsEditCommand(id, { ...options, checkType: options.checkType });
 });
 habitsCmd.command("remove <id>").description("Remove a custom habit (seed habits cannot be removed, only disabled)").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
-  const { habitsRemoveCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsRemoveCommand } = await import("./habits-7BORPC2F.js");
   await habitsRemoveCommand(id, options);
 });
 habitsCmd.command("enable <id>").description("Enable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsToggleCommand } = await import("./habits-7BORPC2F.js");
   await habitsToggleCommand(id, "enable");
 });
 habitsCmd.command("disable <id>").description("Disable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsToggleCommand } = await import("./habits-7BORPC2F.js");
   await habitsToggleCommand(id, "disable");
 });
 habitsCmd.action(async () => {
-  const { habitsListCommand } = await import("./habits-KD4RLIN2.js");
+  const { habitsListCommand } = await import("./habits-7BORPC2F.js");
   await habitsListCommand({});
 });
 var sentinelCmd = program.command("sentinel").description("Sentinel \u2014 semantic error monitoring");