dotdog 0.2.5 → 0.3.0

package/dist/cli.js

@@ -2537,6 +2537,7 @@ var source_default = chalk;
 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";
+import { createHash } from "crypto";
 
 // src/parser.ts
 function parse(source) {
@@ -3094,7 +3095,7 @@ function parseSections2(markdown) {
 }
 var program2 = new Command;
 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.name("spec").alias("dotdog").description("The spec dog — validate, analyze, generate, simulate .dog files").version(pkg.version);
 program2.command("validate [dir]").action((d = ".") => {
   const dirs = [join2(d, "projects"), join2(d, "specs")];
   let found = false;
@@ -3200,45 +3201,64 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
       const pd = join2(dd, p, "specs");
       if (!existsSync2(pd))
         continue;
-      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
-      const dag = { version: "1.1", project: p, compiled_at: new Date().toISOString(), nodes: [], edges: [], files: files.length };
+      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog")).sort();
+      if (!files.length)
+        continue;
+      found = true;
+      const sources = {};
+      let sourceBytes = 0;
+      const hash = createHash("sha256");
       for (const f of files) {
         const content = readFileSync2(join2(pd, f), "utf-8");
-        const ast = parse(content);
+        sources[f] = content;
+        sourceBytes += Buffer.byteLength(content, "utf-8");
+        hash.update(content);
+        hash.update(`
+`);
+      }
+      const integrity = { sha256: hash.digest("hex"), source_files: files.length, source_bytes: sourceBytes };
+      const sourceTokens = Math.round(sourceBytes / 4);
+      const nodes = [], edges = [];
+      for (const f of files) {
+        const ast = parse(sources[f]);
         for (const section of ast.sections) {
           for (const block of section.blocks) {
             if (block.kind === "entity") {
-              dag.nodes.push({
+              nodes.push({
                 id: block.name,
                 type: block.type,
                 description: block.description || "",
                 file: f,
-                properties: block.properties,
+                properties: Object.keys(block.properties).length,
                 states: block.states || [],
-                lifecycle: block.lifecycle || [],
                 chars: section.content?.length || 0
               });
             }
             if (block.kind === "relationship") {
-              dag.edges.push({
+              edges.push({
                 source: block.source,
                 target: block.target,
                 verb: block.verb,
                 cardinality: block.cardinality,
                 required: block.required,
-                cascade: block.cascade,
-                file: f,
-                section: section.heading
+                file: f
               });
             }
           }
         }
       }
-      found = true;
-      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.files} files`));
+      const dag = { version: "1.2", project: p, compiled_at: new Date().toISOString(), compiler: `dotdog@${pkg.version}`, integrity, nodes, edges };
+      const dagJson = JSON.stringify(dag);
+      const dagTokens = Math.round(Buffer.byteLength(dagJson, "utf-8") / 4);
+      const savingsPct = sourceTokens > 0 ? Math.round((1 - dagTokens / sourceTokens) * 1000) / 10 : 0;
+      const savingsTokens = sourceTokens - dagTokens;
+      const outPath = opts.output || join2(pd, "..", `${p}.dag`);
+      const report = { ...dag, tokens: { source_total: sourceTokens, dag_total: dagTokens, savings_pct: savingsPct, savings_tokens: savingsTokens } };
+      writeFileSync(outPath, JSON.stringify(report, null, 2));
+      console.log(source_default.green(`  ✓ ${outPath}`));
+      console.log(source_default.gray(`    ${nodes.length} nodes, ${edges.length} edges, ${files.length} files`));
+      console.log(source_default.gray(`    ${sourceTokens} → ${dagTokens} tokens (${savingsPct}% savings, ${savingsTokens} tokens saved)`));
+      console.log(source_default.gray(`    sha256: ${integrity.sha256.substring(0, 12)}...`));
     }
   }
   if (!found)
@@ -3276,6 +3296,208 @@ ${out}`);
   }
 });
 program2.command("serve [dir]").description("MCP server — expose .dag graph to AI agents over stdio").action((d = ".") => serve(d));
+program2.command("analyze [dir]").description("Analyze a spec project — score, gaps, suggestions").option("-p, --project <name>").action((d = ".", opts) => {
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  console.log(source_default.bold(`
+Spec Analysis
+`));
+  let found = false;
+  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) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join2(dd, p, "specs");
+      if (!existsSync2(pd))
+        continue;
+      const files = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
+      if (!files.length)
+        continue;
+      found = true;
+      console.log(source_default.bold(`
+  ${p}`));
+      console.log("  " + "─".repeat(50));
+      const allEntities = [];
+      const allRelationships = [];
+      const analyses = [];
+      for (const f of files) {
+        const content = readFileSync2(join2(pd, f), "utf-8");
+        const ast = parse(content);
+        const entities = ast.sections.flatMap((s) => s.blocks.filter((b) => b.kind === "entity"));
+        const rels = ast.sections.flatMap((s) => s.blocks.filter((b) => b.kind === "relationship"));
+        allEntities.push(...entities);
+        allRelationships.push(...rels);
+        analyses.push({ file: f, sections: ast.sections.length, size: content.length, entities: entities.length, rels: rels.length });
+      }
+      const missingReq = ["SPEC.dog", "constitution.dog", "data-model.dog"].filter((f) => !files.includes(f));
+      const missingOpt = ["COPY.dog", "plan.dog", "DESIGN-SYSTEM.dog", "INDEX.dog"].filter((f) => !files.includes(f));
+      let score = 100 - missingReq.length * 15 - missingOpt.length * 5;
+      const noDesc = allEntities.filter((e) => !e.description || e.description.length < 10).length;
+      score = Math.max(0, score - noDesc * 3);
+      const noProps = allEntities.filter((e) => Object.keys(e.properties).length === 0).length;
+      score = Math.max(0, score - noProps * 5);
+      const noStates = allEntities.filter((e) => e.states.length === 0).length;
+      score = Math.max(0, score - noStates * 3);
+      console.log(`  ${files.length} files | ${score}% complete`);
+      for (const a of analyses) {
+        const detail = a.entities > 0 ? ` (${a.entities} entities, ${a.rels} rels)` : "";
+        console.log(source_default.gray(`    ${a.file} — ${a.sections} sections, ${(a.size / 1024).toFixed(1)}KB${detail}`));
+      }
+      const gaps = [];
+      for (const f of missingReq)
+        gaps.push(`\uD83D\uDD34 ${f}: Missing required file`);
+      for (const f of missingOpt)
+        gaps.push(`\uD83D\uDFE1 ${f}: Missing optional file`);
+      const entityNames = new Set(allEntities.map((e) => e.name));
+      for (const e of allEntities) {
+        if (!e.description || e.description.length < 10)
+          gaps.push(`\uD83D\uDFE1 ${e.name}: No description`);
+        if (Object.keys(e.properties).length === 0)
+          gaps.push(`\uD83D\uDFE1 ${e.name}: No properties defined`);
+        if (e.states.length === 0)
+          gaps.push(`\uD83D\uDD35 ${e.name}: No states defined`);
+      }
+      for (const r of allRelationships) {
+        if (r.source && !entityNames.has(r.source))
+          gaps.push(`\uD83D\uDFE1 Relationship: unknown source "${r.source}"`);
+        if (r.target && !entityNames.has(r.target))
+          gaps.push(`\uD83D\uDFE1 Relationship: unknown target "${r.target}"`);
+      }
+      if (gaps.length > 0) {
+        console.log(source_default.bold(`
+  Gaps (${gaps.length})`));
+        for (const g of gaps)
+          console.log(`  ${g}`);
+      } else
+        console.log(source_default.green(`
+  No gaps found.`));
+    }
+  }
+  if (!found)
+    console.log(source_default.yellow("No spec projects found. Run: dotdog init <project>"));
+});
+program2.command("generate [dir]").description("Generate missing spec files from SPEC.dog").option("-p, --project <name>").action((d = ".", opts) => {
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  let specContent = "", specDir = "";
+  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) {
+      if (opts.project && p !== opts.project)
+        continue;
+      const pd = join2(dd, p, "specs");
+      const sp = join2(pd, "SPEC.dog");
+      if (existsSync2(sp)) {
+        specContent = readFileSync2(sp, "utf-8");
+        specDir = pd;
+        break;
+      }
+    }
+    if (specContent)
+      break;
+  }
+  if (!specContent) {
+    console.log(source_default.red("No SPEC.dog found. Create one first."));
+    return;
+  }
+  console.log(source_default.bold(`
+Spec Generator
+`));
+  console.log(source_default.gray(`  Source: ${specDir}/SPEC.dog
+`));
+  const ast = parse(specContent);
+  const entities = ast.sections.flatMap((s) => s.blocks.filter((b) => b.kind === "entity"));
+  const uiStrings = [];
+  for (const section of ast.sections) {
+    const h = section.heading.toLowerCase();
+    if (h.includes("what the user sees") || h.includes("screen")) {
+      const text = section.blocks.filter((b) => b.kind === "prose").map((b) => b.content).join(`
+`);
+      for (const m of text.match(/\[([^\]]+)\]/g) || [])
+        uiStrings.push({ screen: section.heading, element: "button", text: m });
+      for (const m of text.match(/"([^"]+)"/g) || [])
+        uiStrings.push({ screen: section.heading, element: "label", text: m });
+    }
+  }
+  if (!existsSync2(join2(specDir, "data-model.dog")) && entities.length > 0) {
+    let dm = `# Data Model
+
+## Core Entities
+
+`;
+    for (const e of entities) {
+      dm += `### Entity: ${e.name}
+
+${e.description || "No description."}
+
+`;
+      dm += "```yaml\n";
+      dm += `entity: ${e.name}
+`;
+      dm += `type: entity
+`;
+      dm += `properties:
+`;
+      for (const [k, v] of Object.entries(e.properties)) {
+        dm += `  ${k}:
+`;
+        dm += `    type: ${v.type}
+`;
+        if (v.required)
+          dm += `    required: true
+`;
+      }
+      if (e.states.length > 0)
+        dm += `states: [${e.states.join(", ")}]
+`;
+      dm += "```\n\n";
+    }
+    writeFileSync(join2(specDir, "data-model.dog"), dm);
+    console.log(source_default.green(`  ✓ data-model.dog (${entities.length} entities)`));
+  }
+  if (!existsSync2(join2(specDir, "COPY.dog")) && uiStrings.length > 0) {
+    let copy = `# App Copy
+
+| Screen | Element | Copy |
+|--------|---------|------|
+`;
+    for (const s of uiStrings)
+      copy += `| ${s.screen} | ${s.element} | ${s.text} |
+`;
+    writeFileSync(join2(specDir, "COPY.dog"), copy);
+    console.log(source_default.green(`  ✓ COPY.dog (${uiStrings.length} strings)`));
+  }
+  if (!existsSync2(join2(specDir, "INDEX.dog"))) {
+    let idx = `# INDEX
+
+| You are... | Start here | Then... |
+|------------|-----------|---------|
+`;
+    idx += `| Developer | SPEC.dog | data-model.dog → plan.dog |
+`;
+    idx += `| AI agent | data-model.dog | COPY.dog → SPEC.dog |
+`;
+    idx += `| Designer | SPEC.dog | COPY.dog |
+`;
+    writeFileSync(join2(specDir, "INDEX.dog"), idx);
+    console.log(source_default.green("  ✓ INDEX.dog"));
+  }
+  console.log(source_default.bold(`
+Run dotdog validate to verify.
+`));
+});
+program2.command("simulate <scenario>").description("Run a simulation scenario (phase 1 stub)").option("-p, --project <name>", "Project name", "default").action((scenario, opts) => {
+  console.log(source_default.bold(`
+Simulation: ${scenario} (project: ${opts.project})
+`));
+  console.log(source_default.gray("Simulation engine — reads SPEC.dog scenarios, walks through steps, checks pre/postconditions."));
+  console.log(source_default.gray("Full engine coming in a future release."));
+});
 program2.command("staleness [dir]").action((d = ".") => {
   const dir = resolvePath2(d);
   const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dotdog",
-  "version": "0.2.5",
-  "description": "The spec dog \u2014 validate, analyze, parse, and generate .dog spec genome files",
+  "version": "0.3.0",
+  "description": "The spec dog — structured, AI-queryable software specifications. Write .dog specs, compile to .dag graphs, query via MCP. Built for humans and AI agents.",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
@@ -16,16 +16,26 @@
   ],
   "keywords": [
     "spec",
-    "dogfood",
     "specification",
     "ai",
+    "agent",
+    "mcp",
     "documentation",
+    "cli",
+    "spec-driven-development",
+    "graph",
+    "markdown",
+    "yaml",
     "dotdog",
+    "dag",
     "dog"
   ],
   "license": "MIT",
   "author": "specdog",
-  "repository": "github:specdog/dotdog",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/specdog/dotdog.git"
+  },
   "dependencies": {
     "commander": "^15.0.0",
     "chalk": "^5.6.0"