dotdog 0.1.6 → 0.2.4

package/dist/cli.js

@@ -2534,9 +2534,9 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/cli.ts
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/parser.ts
 function parse(source) {
@@ -2894,13 +2894,173 @@ function parseInlineObject(value) {
   }
   return obj;
 }
-
-// src/cli.ts
+// src/serve.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import * as readline from "readline";
 function resolvePath(p) {
   if (p.startsWith("~"))
     p = join(homedir(), p.slice(1));
   return p.startsWith("/") ? p : join(process.cwd(), p);
 }
+function serve(dir = ".") {
+  const root = resolvePath(dir);
+  const dagCache = new Map;
+  function loadDags() {
+    const dirs = [join(root, "projects"), join(root, "specs"), root];
+    for (const dd of dirs) {
+      if (!existsSync(dd))
+        continue;
+      const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      for (const p of projects) {
+        const dagFile = join(dd, p, `${p}.dag`);
+        if (existsSync(dagFile)) {
+          dagCache.set(p, JSON.parse(readFileSync(dagFile, "utf-8")));
+        }
+      }
+    }
+    return [...dagCache.keys()];
+  }
+  function handleRequest(req) {
+    const { id, method, params } = req;
+    if (method === "initialize") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: "0.1.0",
+          serverInfo: { name: "spec-serve", version: "0.1.0" },
+          capabilities: { tools: {} }
+        }
+      };
+    }
+    if (method === "tools/list") {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          tools: [
+            { name: "getEntity", description: "Get entity with properties, states, lifecycle", inputSchema: { type: "object", properties: { project: { type: "string" }, name: { type: "string" } }, required: ["name"] } },
+            { name: "traverse", description: "Traverse graph: from node, follow edges, return subgraph", inputSchema: { type: "object", properties: { project: { type: "string" }, from: { type: "string" }, depth: { type: "number", default: 1 } }, required: ["from"] } },
+            { name: "search", description: "Find entities by name or type", inputSchema: { type: "object", properties: { project: { type: "string" }, q: { type: "string" }, type: { type: "string" } }, required: ["q"] } },
+            { name: "listProjects", description: "List all projects", inputSchema: { type: "object", properties: {} } },
+            { name: "summary", description: "Get project summary: node count, edge count, completeness", inputSchema: { type: "object", properties: { project: { type: "string" } } } },
+            { name: "schema", description: "Get full property schema for an entity", inputSchema: { type: "object", properties: { project: { type: "string" }, entity: { type: "string" } }, required: ["entity"] } }
+          ]
+        }
+      };
+    }
+    if (method === "tools/call") {
+      const { name, arguments: args } = params;
+      loadDags();
+      if (name === "listProjects") {
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify([...dagCache.keys()]) }] } };
+      }
+      if (name === "listNodes") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(dag.nodes || []) }] } };
+      }
+      if (name === "getEntity") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        const node = (dag.nodes || []).find((n) => n.id.toLowerCase() === (args.name || "").toLowerCase());
+        if (!node)
+          return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: "{}" }] } };
+        const edges = (dag.edges || []).filter((e) => e.source.toLowerCase() === node.id.toLowerCase() || e.target.toLowerCase() === node.id.toLowerCase());
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify({ ...node, edges }) }] } };
+      }
+      if (name === "traverse") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        const depth = args.depth || 1;
+        const visited = new Set;
+        const subgraph = { nodes: [], edges: [] };
+        const queue = [{ id: args.from, depth: 0 }];
+        while (queue.length > 0) {
+          const curr = queue.shift();
+          if (visited.has(curr.id) || curr.depth > depth)
+            continue;
+          visited.add(curr.id);
+          const node = (dag.nodes || []).find((n) => n.id.toLowerCase() === curr.id.toLowerCase());
+          if (node)
+            subgraph.nodes.push(node);
+          const edges = (dag.edges || []).filter((e) => e.source.toLowerCase() === curr.id.toLowerCase() || e.target.toLowerCase() === curr.id.toLowerCase());
+          for (const e of edges) {
+            subgraph.edges.push(e);
+            const next = e.source.toLowerCase() === curr.id.toLowerCase() ? e.target : e.source;
+            if (!visited.has(next))
+              queue.push({ id: next, depth: curr.depth + 1 });
+          }
+        }
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(subgraph) }] } };
+      }
+      if (name === "search") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        const q = (args.q || "").toLowerCase();
+        const type = (args.type || "").toLowerCase();
+        const results = (dag.nodes || []).filter((n) => n.id.toLowerCase().includes(q) && (!type || (n.type || "").toLowerCase().includes(type)));
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(results) }] } };
+      }
+      if (name === "summary") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        const s = {
+          project: dag.project,
+          nodes: (dag.nodes || []).length,
+          edges: (dag.edges || []).length,
+          files: dag.files || dag.count || 0,
+          compiled: dag.compiled_at
+        };
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(s) }] } };
+      }
+      if (name === "schema") {
+        const dag = dagCache.get(args.project || [...dagCache.keys()][0] || "");
+        if (!dag)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
+        const node = (dag.nodes || []).find((n) => n.id.toLowerCase() === (args.entity || "").toLowerCase());
+        if (!node)
+          return { jsonrpc: "2.0", id, error: { code: 404, message: "Entity not found" } };
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify({
+          entity: node.id,
+          properties: node.properties || {},
+          states: node.states || [],
+          lifecycle: node.lifecycle || []
+        }) }] } };
+      }
+      return { jsonrpc: "2.0", id, error: { code: 404, message: `Unknown tool: ${name}` } };
+    }
+    return { jsonrpc: "2.0", id, error: { code: 404, message: `Unknown method: ${method}` } };
+  }
+  const rl = readline.createInterface({ input: process.stdin });
+  loadDags();
+  console.error(`[spec-serve] Loaded ${dagCache.size} projects`);
+  rl.on("line", (line) => {
+    try {
+      const req = JSON.parse(line);
+      const res = handleRequest(req);
+      process.stdout.write(JSON.stringify(res) + `
+`);
+    } catch (e) {
+      process.stderr.write(`[spec-serve] Error: ${e}
+`);
+    }
+  });
+}
+
+// src/cli.ts
+function resolvePath2(p) {
+  if (p.startsWith("~"))
+    p = join2(homedir2(), p.slice(1));
+  return p.startsWith("/") ? p : join2(process.cwd(), p);
+}
 function parseSections2(markdown) {
   const lines = markdown.split(`
 `), sections = [];
@@ -2933,19 +3093,19 @@ function parseSections2(markdown) {
   return sections;
 }
 var program2 = new Command;
-var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
 program2.name("spec").alias("dotdog").description("The spec dog — validate, analyze, generate .dog files").version(pkg.version);
 program2.command("validate [dir]").action((d = ".") => {
-  const dirs = [join(d, "projects"), join(d, "specs")];
+  const dirs = [join2(d, "projects"), join2(d, "specs")];
   let found = false;
   for (const dd of dirs) {
-    if (!existsSync(dd))
+    if (!existsSync2(dd))
       continue;
-    const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
       found = true;
-      const pd = join(dd, p, "specs");
-      const files = existsSync(pd) ? readdirSync(pd).filter((f) => f.endsWith(".dog")) : [];
+      const pd = join2(dd, p, "specs");
+      const files = existsSync2(pd) ? readdirSync2(pd).filter((f) => f.endsWith(".dog")) : [];
       const missing = ["SPEC.dog", "constitution.dog", "data-model.dog"].filter((f) => !files.includes(f));
       const optional = ["COPY.dog", "plan.dog", "DESIGN-SYSTEM.dog", "INDEX.dog"].filter((f) => !files.includes(f));
       console.log(source_default.bold(`
@@ -2962,7 +3122,7 @@ program2.command("validate [dir]").action((d = ".") => {
     console.log(source_default.yellow("No projects found. Run: spec init <project>"));
 });
 program2.command("init <project>").action((p) => {
-  const d = join(process.cwd(), "specs", p);
+  const d = join2(process.cwd(), "specs", p);
   mkdirSync(d, { recursive: true });
   const tmpl = {
     "SPEC.dog": `# Project
@@ -2997,7 +3157,7 @@ program2.command("init <project>").action((p) => {
 `
   };
   for (const [f, c] of Object.entries(tmpl)) {
-    writeFileSync(join(d, f), c);
+    writeFileSync(join2(d, f), c);
     console.log(source_default.green(`  ✓ ${f}`));
   }
   console.log(source_default.bold(`
@@ -3005,23 +3165,23 @@ Project "${p}" initialized. Fill in SPEC.dog then run spec validate.`));
 });
 program2.command("list").action(() => {
   for (const d of ["projects", "specs"]) {
-    const dd = join(process.cwd(), d);
-    if (!existsSync(dd))
+    const dd = join2(process.cwd(), d);
+    if (!existsSync2(dd))
       continue;
-    const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     if (!projects.length)
       continue;
     console.log(source_default.bold(`
 ${d}/`));
     for (const p of projects) {
-      const sp = join(dd, p, "specs");
-      const n = existsSync(sp) ? readdirSync(sp).filter((f) => f.endsWith(".dog")).length : 0;
+      const sp = join2(dd, p, "specs");
+      const n = existsSync2(sp) ? readdirSync2(sp).filter((f) => f.endsWith(".dog")).length : 0;
       console.log(`  ${source_default.cyan(p)} — ${n} .dog files`);
     }
   }
 });
 program2.command("parse <file>").action((f) => {
-  const c = readFileSync(f, "utf-8");
+  const c = readFileSync2(f, "utf-8");
   const s = parseSections2(c);
   console.log(source_default.bold(`
 ${s.length} sections`));
@@ -3029,21 +3189,21 @@ ${s.length} sections`));
     console.log(`  ${sec.heading.padEnd(30)} ${sec.content.length} chars`);
 });
 program2.command("compile [dir]").option("-o, --output <file>").action((d = ".", opts) => {
-  const dir = resolvePath(d);
-  const dirs = [join(dir, "projects"), join(dir, "specs"), dir];
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
   let found = false;
   for (const dd of dirs) {
-    if (!existsSync(dd))
+    if (!existsSync2(dd))
       continue;
-    const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join(dd, p, "specs");
-      if (!existsSync(pd))
+      const pd = join2(dd, p, "specs");
+      if (!existsSync2(pd))
         continue;
-      const files = readdirSync(pd).filter((f) => f.endsWith(".dog"));
+      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
       const dag = { version: "1.0", project: p, compiled_at: new Date().toISOString(), nodes: [], edges: [], count: files.length };
       for (const f of files) {
-        const c = readFileSync(join(pd, f), "utf-8");
+        const c = readFileSync2(join2(pd, f), "utf-8");
         const secs = parseSections2(c);
         for (const s of secs) {
           if (s.heading.includes("Entity:") || s.heading.includes("Relationship:")) {
@@ -3058,7 +3218,7 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
         }
       }
       found = true;
-      const out = opts.output || join(pd, "..", `${p}.dag`);
+      const out = opts.output || join2(pd, "..", `${p}.dag`);
       writeFileSync(out, JSON.stringify(dag, null, 2));
       console.log(source_default.green(`  ✓ ${out}`));
       console.log(source_default.gray(`    ${dag.nodes.length} nodes, ${dag.edges.length} edges, ${dag.count} files`));
@@ -3067,33 +3227,70 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
   if (!found)
     console.log(source_default.yellow("No projects found."));
 });
+program2.command("visualize [dir]").option("-s, --save").action((d = ".", opts) => {
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  for (const dd of dirs) {
+    if (!existsSync2(dd))
+      continue;
+    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const p of projects) {
+      const dagFile = join2(dd, p, `${p}.dag`);
+      if (!existsSync2(dagFile))
+        continue;
+      const dag = JSON.parse(readFileSync2(dagFile, "utf-8"));
+      let out = "```mermaid\ngraph LR\n";
+      for (const n of dag.nodes || [])
+        out += `    ${n.id.replace(/\s+/g, "_")}[${n.id}]
+`;
+      for (const e of dag.edges || [])
+        out += `    ${e.source.replace(/\s+/g, "_")} -->|${e.verb || ""}| ${e.target.replace(/\s+/g, "_")}
+`;
+      out += "```\n";
+      if (opts.save) {
+        const outFile = join2(dd, p, "..", `${p}.md`);
+        writeFileSync(outFile, `# ${p} — Spec Graph
+
+${out}`);
+        console.log(source_default.green(`  ✓ ${outFile}`));
+      }
+      console.log(out);
+    }
+  }
+});
+program2.command("serve [dir]").description("MCP server — expose .dag graph to AI agents over stdio").action((d = ".") => serve(d));
 program2.command("staleness [dir]").action((d = ".") => {
-  const dir = resolvePath(d);
-  const dirs = [join(dir, "projects"), join(dir, "specs"), dir];
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
   console.log(source_default.bold(`Staleness Audit
 `));
   for (const dd of dirs) {
-    if (!existsSync(dd))
+    if (!existsSync2(dd))
       continue;
-    const projects = readdirSync(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join(dd, p, "specs");
-      if (!existsSync(pd))
+      const pd = join2(dd, p, "specs");
+      if (!existsSync2(pd))
         continue;
-      const planFile = join(pd, "plan.dog");
-      if (!existsSync(planFile)) {
+      const planFile = join2(pd, "plan.dog");
+      if (!existsSync2(planFile)) {
         console.log(source_default.yellow(`  ${p}: No plan.dog`));
         continue;
       }
-      const plan = readFileSync(planFile, "utf-8");
+      const plan = readFileSync2(planFile, "utf-8");
       const tasks = [...plan.matchAll(/^\s*- \[([ x])\]\s+(.+)/gm)];
       let issues = 0;
       for (const m of tasks) {
         const done = m[1] === "x";
         const text = m[2].toLowerCase();
+        const precedingText = plan.substring(Math.max(0, m.index - 200), m.index);
+        const phaseMatch = precedingText.match(/Phase\s+(\d+)/);
+        const phase = phaseMatch ? parseInt(phaseMatch[1]) : 99;
+        if (phase > 3)
+          continue;
         if (text.includes("npm publish") || text.includes("npm install")) {
           try {
-            const pkg2 = JSON.parse(readFileSync(join(resolvePath("."), "packages/dotdog/package.json"), "utf-8"));
+            const pkg2 = JSON.parse(readFileSync2(join2(resolvePath2("."), "packages/dotdog/package.json"), "utf-8"));
             if (pkg2.version && !done) {
               console.log(source_default.yellow(`  ⚠ Should be [x]: ${m[2].trim()}`));
               issues++;
@@ -3107,7 +3304,7 @@ program2.command("staleness [dir]").action((d = ".") => {
           }
         }
         if (text.includes("generate") && !done) {
-          if (existsSync(join(dir, "packages/dotdog/src/cli.ts")) || existsSync(join(dir, "packages/spec-cli/src/generate.ts"))) {
+          if (existsSync2(join2(dir, "packages/dotdog/src/cli.ts")) || existsSync2(join2(dir, "packages/spec-cli/src/generate.ts"))) {
             console.log(source_default.yellow(`  ⚠ Should be [x]: ${m[2].trim()}`));
             issues++;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotdog",
-  "version": "0.1.6",
+  "version": "0.2.4",
   "description": "The spec dog \u2014 validate, analyze, parse, and generate .dog spec genome files",
   "type": "module",
   "main": "dist/cli.js",
@@ -25,7 +25,7 @@
   ],
   "license": "MIT",
   "author": "specdog",
-  "repository": "github:specdog/spec",
+  "repository": "github:specdog/dotdog",
   "dependencies": {
     "commander": "^15.0.0",
     "chalk": "^5.6.0"