dotdog 0.3.1 → 0.3.3

package/README.md

@@ -1,130 +1,76 @@
-# dotdog
+# spec-platform
 
-[![npm version](https://img.shields.io/npm/v/dotdog)](https://www.npmjs.com/package/dotdog)
-[![npm downloads](https://img.shields.io/npm/dm/dotdog)](https://www.npmjs.com/package/dotdog)
-[![License: MIT](https://img.shields.io/npm/l/dotdog)](https://github.com/specdog/dotdog/blob/main/LICENSE)
-[![CI](https://github.com/specdog/dotdog/actions/workflows/test.yml/badge.svg)](https://github.com/specdog/dotdog/actions)
+Monorepo for the Spec Platform — a knowledge graph system where specs ARE the database and LLMs ARE the query engine.
 
-> **Feed the dog. Ship with specs.** Write .dog specs. Dog checks them. AI agents fetch them.
+## The Flywheel
 
-## Install
-
-```bash
-npm install -g dotdog
-```
-
-Requires Node.js >= 20.
-
-## Quick Start
-
-```bash
-dotdog init my-project     # scaffold a spec genome
-dotdog validate            # score completeness (0-100%)
-dotdog analyze             # deep analysis : gaps, suggestions, entity audit
 ```
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `dotdog validate [dir]` | Score spec completeness. Checks file existence, entity descriptions, section counts. |
-| `dotdog analyze [dir]` | Deep analysis. Detects domain, stack, gaps with severity, entity quality audit. |
-| `dotdog parse <file>` | Parse a `.dog` file into sections. |
-| `dotdog compile [dir]` | Compile `.dog` files into a `.dag` graph (JSON). |
-| `dotdog visualize [dir]` | Output Mermaid graph from `.dag`. `--save` writes `.md` for GitHub rendering. |
-| `dotdog serve [dir]` | Start MCP server over stdio. AI agents query specs without hallucination. |
-| `dotdog staleness [dir]` | Detect drift between spec and reality. Compares plan.dog tasks against code. |
-| `dotdog generate [dir]` | Generate missing spec files from SPEC.dog (data-model, COPY, INDEX). |
-| `dotdog simulate <scenario>` | Run a simulation scenario. Reads SPEC.dog scenarios, checks pre/postconditions. |
-| `dotdog init <project>` | Scaffold a new spec genome project with templates. |
-| `dotdog list` | List all projects and their `.dog` file counts. |
-
-## File Formats
-
-### `.dog` : Human-Written Spec Genome
-
-Markdown prose + YAML structured blocks. Free and open source. Define entities, relationships, events, predictions, and copy in a single format that both humans and parsers understand.
-
-```markdown
-### Entity: User
-
-A person who uses the app.
-
-` ``yaml
-entity: User
-type: entity
-properties:
-  id:
-    type: string
-    required: true
-  email:
-    type: string
-    required: true
-states: [active, suspended]
-lifecycle: active → suspended
-` ``
+spec → validate → app → data → better spec → better app → ...
 ```
 
-### `.dag` : Machine-Compiled Graph
-
-JSON graph compiled from `.dog` files. Nodes, edges, properties, and states in a deterministic structure. 85% token savings vs raw `.dog` files for AI agents.
-
-## MCP Server : AI Agent Integration
-
-`dotdog serve` exposes specs to any MCP-compatible AI agent over stdio. Six tools:
+The spec describes the platform. The platform validates the spec. The validation report improves the spec. Each cycle adds granularity.
 
-| Tool | Description |
-|------|-------------|
-| `getEntity` | Exact entity with properties, states, lifecycle, and connected edges |
-| `traverse` | BFS subgraph from any starting node to any depth |
-| `search` | Find entities by name or type |
-| `schema` | Property definitions only : zero prose, agent-optimized |
-| `summary` | Node count, edge count, file count, compile time |
-| `listProjects` | Array of project names |
-
-Agent workflow: `listProjects` → `getEntity` → `traverse` graph.
-
-## Dogfood
-
-dotdog validates its own specs. Every PR:
+## Structure
 
 ```
-dotdog validate → find gaps → fix spec → PR → merge → tag → CI publish
+spec-platform/
+├── packages/
+│   ├── spec-engine/     # Core types and ontology (shared by everything)
+│   ├── spec-mcp/        # MCP Server — AI agents query specs via stdio
+│   └── spec-cli/        # CLI — spec validate, init, simulate, list
+├── projects/            # Spec genomes (dogfooding)
+│   └── spec-platform/
+│       └── specs/
+│           ├── SPEC.dog          # Product spec — screens, flows, stories
+│           ├── constitution.dog  # Immutable rules
+│           └── data-model.dog    # Graph ontology — nodes, edges, tasks, predictions, vectors
+├── templates/           # Spec genome templates for new projects
+└── package.json         # Bun workspace root
 ```
 
-Eat your own dogfood. The tool is the project.
+## Quick Start
 
-## VS Code Extension
+```bash
+bun install
+cd projects/spec-platform/specs
 
-Syntax highlighting for `.dog` files. Install:
+# Validate our own spec (dogfood)
+bun ../../../packages/spec-cli/src/index.ts validate ../..
 
-```bash
-cp -r extensions/vscode ~/.vscode/extensions/dotdog
+# List projects
+bun ../../../packages/spec-cli/src/index.ts list
 ```
 
-## Format Specifications
+## $0 Stack
 
-- [`.dog` format spec](spec/format-spec.dog) : language definition, EBNF grammar, validation rules
-- [`.dag` format spec](spec/format-spec-dag.dog) : graph definition, MCP API, token efficiency
+| Component | Technology | Cost |
+|-----------|-----------|------|
+| Runtime | Bun | $0 |
+| Database | bun:sqlite (embedded) | $0 |
+| Types | TypeScript (strict) | $0 |
+| CLI | Commander.js + chalk | $0 |
+| MCP Server | @modelcontextprotocol/sdk (stdio) | $0 |
+| Embeddings | all-MiniLM-L6-v2 (local) | $0 |
+| Hosting | None needed (local-first) | $0 |
 
-## Links
+## The Spec Graph
 
-- **GitHub:** [specdog/dotdog](https://github.com/specdog/dotdog)
-- **npm:** [dotdog](https://www.npmjs.com/package/dotdog)
-- **Docs:** [GitHub Pages](https://specdog.github.io/dotdog)
-- **llms.txt:** [llms.txt](llms.txt) : structured for AI agent discovery
-- **AGENTS.md:** [AGENTS.md](AGENTS.md) : instructions for AI coding agents
+The spec is not a document. It's a knowledge graph.
 
-## Spec-Driven Development
+- **Nodes**: entities, tasks, predictions, screens, constraints, user stories
+- **Edges**: contains, depends_on, implements, references, calls, precedes
+- **Vectors**: every section embedded for semantic search, contradiction detection, staleness checks
+- **Predictions**: forecasts with triggers, timeframes, confidence, and actual outcome tracking
 
-dotdog is built for SDD. Write your spec first. Validate it. Compile it. Let AI agents query it. The spec is the source of truth.
+LLMs traverse the graph at query time. They don't read prose and guess — they get exact typed values.
 
-```
-spec → validate → compile → serve → AI agent queries
-```
-
-No more specs that rot in a wiki. No more agents guessing from prose. One source. Zero ambiguity.
+## Score
 
-## License
+```
+spec validate → 43% complete
 
-MIT
+  ✓ SPEC.dog
+  ✓ constitution.dog
+  ✓ data-model.dog
+  ⚠ COPY.dog, DESIGN-SYSTEM.dog, plan.dog, INDEX.dog
+```

package/dist/cli.js

@@ -2537,7 +2537,6 @@ var source_default = chalk;
 import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, mkdirSync, writeFileSync } from "fs";
 import { join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash } from "crypto";
 
 // src/parser.ts
 function parse(source) {
@@ -2553,7 +2552,14 @@ function parseToJSON(source) {
 function parseSections(lines) {
   const sections = [];
   let i = 0;
-  const rootBlocks = parseBlocks(lines, 0, lines.length);
+  let firstHeading = lines.length;
+  for (let j = 0;j < lines.length; j++) {
+    if (/^##\s/.test(lines[j])) {
+      firstHeading = j;
+      break;
+    }
+  }
+  const rootBlocks = parseBlocks(lines, 0, firstHeading);
   if (rootBlocks.length > 0) {
     sections.push({
       kind: "section",
@@ -2574,7 +2580,7 @@ function parseSections(lines) {
       const sectionStart = i;
       i++;
       const end = findSectionEnd(lines, i, level);
-      const blocks = parseBlocks(lines, i, end);
+      const blocks = parseBlocks(lines, sectionStart, end);
       sections.push({
         kind: "section",
         level,
@@ -2593,9 +2599,7 @@ function parseSections(lines) {
 function findSectionEnd(lines, start, currentLevel) {
   for (let i = start;i < lines.length; i++) {
     const line = lines[i];
-    if (/^##\s/.test(line))
-      return i;
-    if (currentLevel === 2 && /^###\s/.test(line))
+    if (/^##\s/.test(line) || /^###\s/.test(line))
       return i;
   }
   return lines.length;
@@ -2632,6 +2636,15 @@ function parseBlocks(lines, start, end) {
         continue;
       }
     }
+    const predMatch = line.match(/^###\s+Prediction:\s*(.+)/);
+    if (predMatch) {
+      const result = parseStructuredBlock(lines, i, end, "prediction", predMatch[1]);
+      if (result) {
+        blocks.push(result.node);
+        i = result.nextLine;
+        continue;
+      }
+    }
     if (/^\|.+\|/.test(line) && i + 1 < end && /^\|[-| ]+\|/.test(lines[i + 1])) {
       const table = parseTable(lines, i, end);
       if (table) {
@@ -2711,6 +2724,12 @@ function parseStructuredBlock(lines, start, end, kind, headerRest) {
       nextLine: i
     };
   }
+  if (kind === "prediction") {
+    return {
+      node: buildPredictionNode(headerRest, description, yaml, start, i),
+      nextLine: i
+    };
+  }
   return null;
 }
 function buildEntityNode(name, description, yaml, lineStart, lineEnd) {
@@ -2731,7 +2750,11 @@ function buildEntityNode(name, description, yaml, lineStart, lineEnd) {
   }
   const states = Array.isArray(yaml.states) ? yaml.states : [];
   const lifecycleStr = yaml.lifecycle || "";
-  const lifecycle = lifecycleStr ? lifecycleStr.split(/\s*→\s*/) : [];
+  const lifecycleParts = lifecycleStr ? lifecycleStr.split(/\s*→\s*/).map((s) => s.trim()) : [];
+  const lifecycle = [];
+  for (let si = 0;si < lifecycleParts.length - 1; si++) {
+    lifecycle.push(`${lifecycleParts[si]} → ${lifecycleParts[si + 1]}`);
+  }
   return {
     kind: "entity",
     name,
@@ -2754,6 +2777,7 @@ function buildRelationshipNode(headerRest, description, yaml, lineStart, lineEnd
     source,
     target,
     verb: yaml.verb || "connects",
+    description: description || yaml.description || "",
     cardinality: yaml.cardinality || "N:M",
     required: yaml.required === true,
     cascade: yaml.cascade || "none",
@@ -2778,6 +2802,22 @@ function buildEventNode(name, description, yaml, lineStart, lineEnd) {
     lineEnd
   };
 }
+function buildPredictionNode(name, description, yaml, lineStart, lineEnd) {
+  return {
+    kind: "prediction",
+    statement: name,
+    description,
+    trigger: yaml.trigger || "",
+    timeframe: yaml.timeframe || "",
+    confidence: typeof yaml.confidence === "number" ? yaml.confidence : 0,
+    measurement: yaml.measurement || "",
+    preconditions: Array.isArray(yaml.preconditions) ? yaml.preconditions : [],
+    postconditions: Array.isArray(yaml.postconditions) ? yaml.postconditions : [],
+    yaml,
+    lineStart: lineStart + 1,
+    lineEnd
+  };
+}
 function parseTable(lines, start, end) {
   const headerLine = lines[start];
   const headers = headerLine.split("|").map((h) => h.trim()).filter(Boolean);
@@ -2850,15 +2890,25 @@ function parseSimpleYAML(lines) {
       } else if (value.startsWith("[") && value.endsWith("]")) {
         currentObj[nestedKey] = value.slice(1, -1).split(",").map((s) => s.trim());
       } else {
-        const inlineObj = parseInlineObject(value);
-        if (inlineObj) {
-          currentObj[nestedKey] = inlineObj;
-        } else {
-          currentObj[nestedKey] = value;
-        }
+        currentObj[nestedKey] = value;
       }
       continue;
     }
+    if (nestedMatch && !inNested) {
+      const key = nestedMatch[1];
+      const value = (nestedMatch[2] || "").trim();
+      if (value === "true")
+        result[key] = true;
+      else if (value === "false")
+        result[key] = false;
+      else if (/^-?\d+(\.\d+)?$/.test(value))
+        result[key] = parseFloat(value);
+      else if (value.startsWith("[") && value.endsWith("]"))
+        result[key] = value.slice(1, -1).split(",").map((s) => s.trim());
+      else
+        result[key] = value;
+      continue;
+    }
     const deepMatch = line.match(/^\s{4}(\w[\w_]*):\s*(.+)?$/);
     if (deepMatch && inNested && nestedKey && typeof currentObj[nestedKey] === "object") {
       const deepNested = currentObj[nestedKey];
@@ -2906,13 +2956,27 @@ function resolvePath(p) {
   const resolved = p.startsWith("/") ? p : join(process.cwd(), p);
   if (!p.startsWith("/") && !p.startsWith("~")) {
     const rel = resolve(process.cwd(), p);
-    if (!rel.startsWith(process.cwd() + "/") && rel !== process.cwd()) {
+    const cwd = process.cwd();
+    const isDescendant = rel.startsWith(cwd + "/");
+    const isSelf = rel === cwd;
+    const isAncestor = cwd.startsWith(rel + "/");
+    if (!isDescendant && !isSelf && !isAncestor) {
       throw new Error(`Path traversal blocked: ${p}`);
     }
     return rel;
   }
   return resolved;
 }
+var N = (dag) => dag.n || dag.nodes || [];
+var E = (dag) => dag.e || dag.edges || [];
+var P = (dag) => dag.p || dag.project || "";
+var ni = (n) => n.i || n.id || "";
+var nt = (n) => n.t || n.type || "";
+var np = (n) => n.p || n.properties || {};
+var ns = (n) => n.s || n.states || [];
+var nl = (n) => n.l || n.lifecycle || [];
+var es = (e) => e.s || e.source || "";
+var et = (e) => e.t || e.target || "";
 function serve(dir = ".") {
   const root = resolvePath(dir);
   const dagCache = new Map;
@@ -2954,7 +3018,7 @@ function serve(dir = ".") {
             { 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: "summary", description: "Get project summary: node count, edge count, token savings", 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"] } }
           ]
         }
@@ -2970,16 +3034,16 @@ function serve(dir = ".") {
         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 || []) }] } };
+        return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(N(dag)) }] } };
       }
       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());
+        const node = N(dag).find((n) => ni(n).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());
+        const edges = E(dag).filter((e) => es(e).toLowerCase() === ni(node).toLowerCase() || et(e).toLowerCase() === ni(node).toLowerCase());
         return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify({ ...node, edges }) }] } };
       }
       if (name === "traverse") {
@@ -2987,22 +3051,27 @@ function serve(dir = ".") {
         if (!dag)
           return { jsonrpc: "2.0", id, error: { code: 404, message: "Project not found" } };
         const depth = Math.min(Math.max(1, args.depth || 1), 20);
-        const visited = new Set;
+        const visitedNodes = new Set;
+        const visitedEdges = 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)
+          if (visitedNodes.has(curr.id) || curr.depth > depth)
             continue;
-          visited.add(curr.id);
-          const node = (dag.nodes || []).find((n) => n.id.toLowerCase() === curr.id.toLowerCase());
+          visitedNodes.add(curr.id);
+          const node = N(dag).find((n) => ni(n).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());
+          const edges = E(dag).filter((e) => es(e).toLowerCase() === curr.id.toLowerCase() || et(e).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))
+            const edgeKey = `${es(e)}→${et(e)}`;
+            if (!visitedEdges.has(edgeKey)) {
+              visitedEdges.add(edgeKey);
+              subgraph.edges.push(e);
+            }
+            const next = es(e).toLowerCase() === curr.id.toLowerCase() ? et(e) : es(e);
+            if (!visitedNodes.has(next))
               queue.push({ id: next, depth: curr.depth + 1 });
           }
         }
@@ -3014,19 +3083,21 @@ function serve(dir = ".") {
           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)));
+        const results = N(dag).filter((n) => ni(n).toLowerCase().includes(q) && (!type || nt(n).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 tk = dag.tk || dag.tokens || {};
         const s = {
-          project: dag.project,
-          nodes: (dag.nodes || []).length,
-          edges: (dag.edges || []).length,
-          files: dag.files || dag.count || 0,
-          compiled: dag.compiled_at
+          project: P(dag),
+          nodes: N(dag).length,
+          edges: E(dag).length,
+          version: dag.v || dag.version || "",
+          savings: tk.sv || tk.savings_pct || 0,
+          method: tk.m || tk.method || ""
         };
         return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(s) }] } };
       }
@@ -3034,14 +3105,14 @@ function serve(dir = ".") {
         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());
+        const node = N(dag).find((n) => ni(n).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 || []
+          entity: ni(node),
+          properties: np(node),
+          states: ns(node),
+          lifecycle: nl(node)
         }) }] } };
       }
       return { jsonrpc: "2.0", id, error: { code: 404, message: `Unknown tool: ${name}` } };
@@ -3071,7 +3142,11 @@ function resolvePath2(p) {
   const resolved = p.startsWith("/") ? p : join2(process.cwd(), p);
   if (!p.startsWith("/") && !p.startsWith("~")) {
     const rel = resolve2(process.cwd(), p);
-    if (!rel.startsWith(process.cwd() + "/") && rel !== process.cwd()) {
+    const cwd = process.cwd();
+    const isDescendant = rel.startsWith(cwd + "/");
+    const isSelf = rel === cwd;
+    const isAncestor = cwd.startsWith(rel + "/");
+    if (!isDescendant && !isSelf && !isAncestor) {
       throw new Error(`Path traversal blocked: ${p}`);
     }
     return rel;
@@ -3122,7 +3197,9 @@ program2.command("validate [dir]").action((d = ".") => {
     const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
       found = true;
-      const pd = join2(dd, p, "specs");
+      const pd = join2(dd, p);
+      if (!existsSync2(join2(pd, "SPEC.dog")))
+        continue;
       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));
@@ -3139,10 +3216,10 @@ program2.command("validate [dir]").action((d = ".") => {
   if (!found)
     console.log(source_default.yellow("No projects found. Run: spec init <project>"));
 });
-program2.command("init <project>").action((p) => {
+program2.command("init <project>").option("-m, --minimal", "Only SPEC.dog + data-model.dog").action((p, opts) => {
   const d = join2(process.cwd(), "specs", p);
   mkdirSync(d, { recursive: true });
-  const tmpl = {
+  const full = {
     "SPEC.dog": `# Project
 
 ## Product
@@ -3174,6 +3251,19 @@ program2.command("init <project>").action((p) => {
 |---|---|---|
 `
   };
+  const minimal = {
+    "SPEC.dog": `# Project
+
+## Product
+
+`,
+    "data-model.dog": `# Data Model
+
+## Entities
+
+`
+  };
+  const tmpl = opts.minimal ? minimal : full;
   for (const [f, c] of Object.entries(tmpl)) {
     writeFileSync(join2(d, f), c);
     console.log(source_default.green(`  ✓ ${f}`));
@@ -3192,7 +3282,7 @@ program2.command("list").action(() => {
     console.log(source_default.bold(`
 ${d}/`));
     for (const p of projects) {
-      const sp = join2(dd, p, "specs");
+      const sp = join2(dd, p);
       const n = existsSync2(sp) ? readdirSync2(sp).filter((f) => f.endsWith(".dog")).length : 0;
       console.log(`  ${source_default.cyan(p)} : ${n} .dog files`);
     }
@@ -3215,7 +3305,9 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
       continue;
     const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join2(dd, p, "specs");
+      const pd = join2(dd, p);
+      if (!existsSync2(join2(pd, "SPEC.dog")))
+        continue;
       if (!existsSync2(pd))
         continue;
       const files = readdirSync2(pd).filter((f) => f.endsWith(".dog")).sort();
@@ -3223,64 +3315,139 @@ program2.command("compile [dir]").option("-o, --output <file>").action((d = ".",
         continue;
       found = true;
       const sources = {};
-      let sourceBytes = 0;
-      const hash = createHash("sha256");
+      let sourceBytes = 0, contentBytes = 0;
       for (const f of files) {
         const content = readFileSync2(join2(pd, f), "utf-8");
         sources[f] = content;
-        sourceBytes += Buffer.byteLength(content, "utf-8");
-        hash.update(content);
-        hash.update(`
-`);
+        const bytes = Buffer.byteLength(content, "utf-8");
+        sourceBytes += bytes;
+        if (bytes >= 100)
+          contentBytes += bytes;
       }
-      const integrity = { sha256: hash.digest("hex"), source_files: files.length, source_bytes: sourceBytes };
       const sourceTokens = Math.round(sourceBytes / 4);
+      const contentTokens = Math.round(contentBytes / 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") {
+            if (block.kind === "entity" || block.kind === "event") {
+              const compactProps = {};
+              for (const [key, val] of Object.entries(block.properties || {})) {
+                let enc = "";
+                const t = val.type || "string";
+                if (t === "string")
+                  enc = "s";
+                else if (t === "number")
+                  enc = "n";
+                else if (t === "boolean")
+                  enc = "b";
+                else if (t === "enum")
+                  enc = "e";
+                else if (t === "json")
+                  enc = "j";
+                else
+                  enc = t[0];
+                if (val.required)
+                  enc += "!";
+                compactProps[key] = enc;
+              }
+              nodes.push({
+                i: block.name || "",
+                t: block.type || "",
+                g: block.kind,
+                d: block.description || "",
+                p: compactProps,
+                s: block.states || [],
+                l: block.lifecycle || []
+              });
+            }
+            if (block.kind === "prediction") {
               nodes.push({
-                id: block.name,
-                type: block.type,
-                description: block.description || "",
-                file: f,
-                properties: Object.keys(block.properties).length,
-                states: block.states || [],
-                chars: section.content?.length || 0
+                i: block.statement || block.name || "",
+                t: "prediction",
+                g: "prediction",
+                d: block.description || "",
+                p: {},
+                s: [],
+                l: [],
+                cf: block.confidence || 0,
+                tf: block.timeframe || "",
+                tg: block.trigger || "",
+                ms: block.measurement || ""
               });
             }
             if (block.kind === "relationship") {
               edges.push({
-                source: block.source,
-                target: block.target,
-                verb: block.verb,
-                cardinality: block.cardinality,
-                required: block.required,
-                file: f
+                s: block.source,
+                t: block.target,
+                v: block.verb,
+                d: block.description || "",
+                c: block.cardinality,
+                r: block.required
               });
             }
           }
         }
       }
-      const dag = { version: "1.2", project: p, compiled_at: new Date().toISOString(), compiler: `dotdog@${pkg.version}`, integrity, nodes, edges };
+      const dag = { v: "1.4", p, c: `dotdog@${pkg.version}`, n: nodes, e: 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 allSavingsPct = sourceTokens > 0 ? Math.round((1 - dagTokens / sourceTokens) * 1000) / 10 : 0;
+      const contentSavingsPct = contentTokens > 0 ? Math.round((1 - dagTokens / contentTokens) * 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 } };
+      const outPath = opts.output || join2(pd, `${p}.dag`);
+      const tokens = { m: "chars/4", st: sourceTokens, ct: contentTokens, dt: dagTokens, sv: allSavingsPct, cs: contentSavingsPct, saved: savingsTokens };
+      const report = { ...dag, tk: tokens };
       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)}...`));
+      console.log(source_default.gray(`    ${sourceTokens} → ${dagTokens} tokens (${allSavingsPct}% savings, ${contentSavingsPct}% content-only, ${savingsTokens} saved)`));
     }
   }
   if (!found)
     console.log(source_default.yellow("No projects found."));
 });
+program2.command("tokens [dir]").action((d = ".") => {
+  const dir = resolvePath2(d);
+  const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
+  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) {
+      const pd = join2(dd, p);
+      if (!existsSync2(join2(pd, "SPEC.dog")))
+        continue;
+      const dagFile = join2(pd, `${p}.dag`);
+      if (!existsSync2(dagFile))
+        continue;
+      found = true;
+      const dogFiles = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
+      let sourceBytes = 0, contentBytes = 0;
+      for (const f of dogFiles) {
+        const bytes = Buffer.byteLength(readFileSync2(join2(pd, f), "utf-8"), "utf-8");
+        sourceBytes += bytes;
+        if (bytes >= 100)
+          contentBytes += bytes;
+      }
+      const dagBytes = Buffer.byteLength(readFileSync2(dagFile, "utf-8"), "utf-8");
+      const savings = sourceBytes > 0 ? Math.round((1 - dagBytes / sourceBytes) * 1000) / 10 : 0;
+      console.log(source_default.bold(`
+  ${p}`));
+      console.log(source_default.gray(`    ${dogFiles.length} .dog files: ${sourceBytes} bytes`));
+      console.log(source_default.gray(`    .dag file: ${dagBytes} bytes`));
+      console.log(source_default.green(`    ${savings}% smaller (${sourceBytes - dagBytes} bytes saved)`));
+      if (contentBytes && contentBytes !== sourceBytes) {
+        const cs = Math.round((1 - dagBytes / contentBytes) * 1000) / 10;
+        console.log(source_default.gray(`    content-only: ${contentBytes} bytes → ${cs}% savings`));
+      }
+    }
+  }
+  if (!found)
+    console.log(source_default.yellow("No .dag files found. Run compile first."));
+});
 program2.command("visualize [dir]").option("-s, --save").action((d = ".", opts) => {
   const dir = resolvePath2(d);
   const dirs = [join2(dir, "projects"), join2(dir, "specs"), dir];
@@ -3327,7 +3494,9 @@ Spec Analysis
     for (const p of projects) {
       if (opts.project && p !== opts.project)
         continue;
-      const pd = join2(dd, p, "specs");
+      const pd = join2(dd, p);
+      if (!existsSync2(join2(pd, "SPEC.dog")))
+        continue;
       if (!existsSync2(pd))
         continue;
       const files = readdirSync2(pd).filter((f) => f.endsWith(".dog"));
@@ -3407,7 +3576,7 @@ program2.command("generate [dir]").description("Generate missing spec files from
     for (const p of projects) {
       if (opts.project && p !== opts.project)
         continue;
-      const pd = join2(dd, p, "specs");
+      const pd = join2(dd, p);
       const sp = join2(pd, "SPEC.dog");
       if (existsSync2(sp)) {
         specContent = readFileSync2(sp, "utf-8");
@@ -3525,7 +3694,9 @@ program2.command("staleness [dir]").action((d = ".") => {
       continue;
     const projects = readdirSync2(dd, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const p of projects) {
-      const pd = join2(dd, p, "specs");
+      const pd = join2(dd, p);
+      if (!existsSync2(join2(pd, "SPEC.dog")))
+        continue;
       if (!existsSync2(pd))
         continue;
       const planFile = join2(pd, "plan.dog");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotdog",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "CLI tool for structured software specifications. Validate .dog files, compile .dag graphs, query via MCP.",
   "type": "module",
   "main": "dist/cli.js",
@@ -15,29 +15,25 @@
     "LICENSE"
   ],
   "keywords": [
+    "spec",
     "specification",
-    "cli",
+    "ai",
+    "agent",
     "mcp",
+    "documentation",
+    "cli",
+    "dogfood",
+    "spec-driven-development",
     "graph",
-    "dag",
-    "yaml",
     "markdown",
-    "spec-driven-development"
+    "yaml",
+    "dotdog",
+    "dag",
+    "dog"
   ],
   "license": "MIT",
   "author": "specdog",
-  "homepage": "https://github.com/specdog/dotdog#readme",
-  "bugs": {
-    "url": "https://github.com/specdog/dotdog/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/specdog/dotdog.git",
-    "directory": "packages/dotdog"
-  },
-  "engines": {
-    "node": ">=20"
-  },
+  "repository": "github:specdog/dotdog",
   "dependencies": {
     "commander": "^15.0.0",
     "chalk": "^5.6.0"

package/CHANGELOG.md

@@ -1,35 +0,0 @@
-# Changelog
-
-## 0.3.1
-
-- Fix npm packaging: homepage, bugs, engines, repository fields
-- Trim keywords to 8 specific terms
-- Ship correct README, LICENSE, and CHANGELOG in package
-- CLI help text uses colons, no em dashes
-
-## 0.3.0
-
-- `dotdog analyze` — deep project analysis: score, gaps, entity audit
-- `dotdog generate` — generate missing spec files from SPEC.dog
-- `dotdog simulate` — run simulation scenarios
-- `.dag` v1.2: provable token savings, typed nodes and edges
-- VS Code extension: syntax highlighting for .dog files
-- GitHub Pages and llms.txt for AI agent discoverability
-- `dotdog serve` MCP server: getEntity, traverse, search, schema, summary
-- Path traversal guard, traverse depth cap, serve hardening
-
-## 0.2.0
-
-- `dotdog compile` — compile .dog files to .dag graph
-- `dotdog visualize` — Mermaid graph output with --save flag
-- MCP server: expose .dag graph to AI agents over stdio
-- `dotdog staleness` — detect drift between spec and reality
-- `dotdog init` — scaffold new spec genome projects
-- `dotdog list` — list all projects and .dog file counts
-
-## 0.1.0
-
-- `.dog` file format v1.0
-- `.dag` file format v1.0
-- `dotdog validate` — validate spec completeness
-- `dotdog parse` — parse .dog files

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 specdog
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.