trellis 2.0.7 → 2.0.10

package/dist/cli/index.js

@@ -1,22 +1,43 @@
 #!/usr/bin/env bun
 // @bun
 import {
-  TrellisVcsEngine
-} from "../index-1j1anhmr.js";
-import"../index-gkvhzm9f.js";
-import"../index-3s0eak0p.js";
+  TrellisVcsEngine,
+  init_engine
+} from "../index-5b01h414.js";
 import {
+  OntologyRegistry,
+  builtinOntologies,
+  parseQuery,
+  parseSimple,
+  validateStore
+} from "../index-5m0g9r0y.js";
+import {
+  QueryEngine,
+  SqliteKernelBackend,
+  TrellisKernel
+} from "../index-hybgxe40.js";
+import"../index-3ejh8k6v.js";
+import {
+  VectorStore,
+  buildRAGContext,
+  embed,
   exports_embeddings,
-  init_embeddings
-} from "../index-zf6htvnm.js";
+  init_auto_embed,
+  init_embeddings,
+  init_model,
+  init_store
+} from "../index-7gvjxt27.js";
 import {
+  buildRefIndex,
+  createResolverContext,
   exports_links,
   init_links
 } from "../index-vkpkfwhq.js";
-import"../index-8pce39mh.js";
+import"../index-65z0xfjw.js";
 import {
-  createVcsOp
-} from "../index-fd4e26s4.js";
+  createVcsOp,
+  init_ops
+} from "../index-v9b4hqa7.js";
 import {
   __commonJS,
   __esm,
@@ -2261,6 +2282,303 @@ var init_reconciler = __esm(() => {
   ]);
 });
 
+// src/ui/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startUIServer: () => startUIServer
+});
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
+function buildGraph(engine) {
+  const nodes = [];
+  const edges = [];
+  const nodeIds = new Set;
+  const files = engine.trackedFiles();
+  for (const f of files) {
+    const id = `file:${f.path}`;
+    nodes.push({
+      id,
+      label: f.path,
+      type: "file",
+      meta: { contentHash: f.contentHash }
+    });
+    nodeIds.add(id);
+  }
+  const milestones = engine.listMilestones();
+  for (const m of milestones) {
+    const id = `milestone:${m.id}`;
+    nodes.push({
+      id,
+      label: m.message ?? m.id,
+      type: "milestone",
+      meta: {
+        createdAt: m.createdAt,
+        affectedFiles: m.affectedFiles,
+        fromOpHash: m.fromOpHash,
+        toOpHash: m.toOpHash
+      }
+    });
+    nodeIds.add(id);
+    for (const fp of m.affectedFiles ?? []) {
+      const fileId = `file:${fp}`;
+      if (nodeIds.has(fileId)) {
+        edges.push({
+          source: id,
+          target: fileId,
+          type: "milestone_file"
+        });
+      }
+    }
+  }
+  const issues = engine.listIssues();
+  for (const iss of issues) {
+    const id = `issue:${iss.id}`;
+    nodes.push({
+      id,
+      label: iss.title ?? iss.id,
+      type: "issue",
+      meta: {
+        status: iss.status,
+        priority: iss.priority,
+        labels: iss.labels,
+        assignee: iss.assignee,
+        createdAt: iss.createdAt,
+        description: iss.description,
+        criteria: iss.criteria
+      }
+    });
+    nodeIds.add(id);
+    if (iss.branchName) {
+      const branchId = `branch:${iss.branchName}`;
+      if (nodeIds.has(branchId)) {
+        edges.push({
+          source: id,
+          target: branchId,
+          type: "issue_branch"
+        });
+      }
+    }
+  }
+  const branches = engine.listBranches();
+  for (const b of branches) {
+    const id = `branch:${b.name}`;
+    if (!nodeIds.has(id)) {
+      nodes.push({
+        id,
+        label: b.name,
+        type: "branch",
+        meta: {
+          isCurrent: b.isCurrent,
+          createdAt: b.createdAt
+        }
+      });
+      nodeIds.add(id);
+    }
+    for (const iss of issues) {
+      if (iss.branchName === b.name) {
+        edges.push({
+          source: `issue:${iss.id}`,
+          target: id,
+          type: "issue_branch"
+        });
+      }
+    }
+  }
+  try {
+    const mdFiles = [];
+    for (const f of files) {
+      if (f.path.endsWith(".md")) {
+        const absPath = join5(engine.getRootPath(), f.path);
+        if (existsSync5(absPath)) {
+          mdFiles.push({
+            path: f.path,
+            content: readFileSync3(absPath, "utf-8")
+          });
+        }
+      }
+    }
+    if (mdFiles.length > 0) {
+      const ctx = createResolverContext({
+        trackedFiles: () => files,
+        listIssues: () => issues,
+        listMilestones: () => milestones
+      });
+      const refIndex = buildRefIndex(mdFiles, ctx);
+      for (const [filePath, refs] of refIndex.outgoing) {
+        const sourceId = `file:${filePath}`;
+        if (!nodeIds.has(sourceId))
+          continue;
+        for (const ref of refs) {
+          const targetId = `${ref.namespace}:${ref.target}`;
+          const candidateIds = [
+            targetId,
+            `file:${ref.target}`,
+            `issue:${ref.target}`,
+            `milestone:${ref.target}`
+          ];
+          for (const cid of candidateIds) {
+            if (nodeIds.has(cid) && cid !== sourceId) {
+              edges.push({
+                source: sourceId,
+                target: cid,
+                type: "wikilink",
+                label: ref.target
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+  } catch {}
+  return { nodes, edges };
+}
+function getNodeDetail(engine, nodeId) {
+  const [type, ...rest] = nodeId.split(":");
+  const id = rest.join(":");
+  switch (type) {
+    case "file": {
+      const files = engine.trackedFiles();
+      const file = files.find((f) => f.path === id);
+      if (!file)
+        return null;
+      const ops = engine.log({ filePath: id, limit: 10 });
+      return {
+        type: "file",
+        path: id,
+        contentHash: file.contentHash,
+        recentOps: ops.map((o) => ({
+          kind: o.kind,
+          timestamp: o.timestamp,
+          hash: o.hash.slice(0, 24)
+        }))
+      };
+    }
+    case "milestone": {
+      const milestones = engine.listMilestones();
+      const m = milestones.find((ms) => ms.id === id);
+      if (!m)
+        return null;
+      return { type: "milestone", ...m };
+    }
+    case "issue": {
+      const issue = engine.getIssue(id);
+      if (!issue)
+        return null;
+      return { type: "issue", ...issue };
+    }
+    case "branch": {
+      const branches = engine.listBranches();
+      const b = branches.find((br) => br.name === id);
+      if (!b)
+        return null;
+      return { type: "branch", ...b };
+    }
+    default:
+      return null;
+  }
+}
+async function startUIServer(opts) {
+  const engine = new TrellisVcsEngine({ rootPath: opts.rootPath });
+  engine.open();
+  const clientHtml = readFileSync3(join5(dirname4(new URL(import.meta.url).pathname), "client.html"), "utf-8");
+  let embeddingManager = null;
+  function getEmbeddingManager() {
+    if (!embeddingManager) {
+      try {
+        const { EmbeddingManager } = (init_embeddings(), __toCommonJS(exports_embeddings));
+        const dbPath = join5(opts.rootPath, ".trellis", "embeddings.db");
+        if (existsSync5(dbPath)) {
+          embeddingManager = new EmbeddingManager(dbPath);
+        }
+      } catch {}
+    }
+    return embeddingManager;
+  }
+  const requestedPort = opts.port ?? 3333;
+  const server = Bun.serve({
+    port: requestedPort,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      const headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      };
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers });
+      }
+      if (path === "/api/graph") {
+        const graph = buildGraph(engine);
+        return Response.json(graph, { headers });
+      }
+      if (path === "/api/search") {
+        const query = url.searchParams.get("q");
+        if (!query) {
+          return Response.json({ error: "Missing ?q= parameter" }, { status: 400, headers });
+        }
+        const limit = parseInt(url.searchParams.get("limit") ?? "10", 10);
+        const typeFilter = url.searchParams.get("type");
+        const mgr = getEmbeddingManager();
+        if (!mgr) {
+          return Response.json({
+            results: [],
+            message: "No embedding index. Run `trellis reindex` first."
+          }, { headers });
+        }
+        try {
+          const searchOpts = { limit };
+          if (typeFilter) {
+            searchOpts.types = typeFilter.split(",").map((t) => t.trim());
+          }
+          const results = await mgr.search(query, searchOpts);
+          return Response.json({
+            results: results.map((r) => ({
+              score: r.score,
+              chunkType: r.chunk.chunkType,
+              filePath: r.chunk.filePath,
+              entityId: r.chunk.entityId,
+              content: r.chunk.content
+            }))
+          }, { headers });
+        } catch (err) {
+          return Response.json({ error: err.message }, { status: 500, headers });
+        }
+      }
+      if (path.startsWith("/api/node/")) {
+        const nodeId = decodeURIComponent(path.slice("/api/node/".length));
+        const detail = getNodeDetail(engine, nodeId);
+        if (!detail) {
+          return Response.json({ error: "Node not found" }, { status: 404, headers });
+        }
+        return Response.json(detail, { headers });
+      }
+      if (path === "/" || path === "/index.html") {
+        return new Response(clientHtml, {
+          headers: { ...headers, "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+      return new Response("Not Found", { status: 404, headers });
+    }
+  });
+  return {
+    port: server.port,
+    stop: () => {
+      server.stop();
+      if (embeddingManager) {
+        try {
+          embeddingManager.close();
+        } catch {}
+      }
+    }
+  };
+}
+var init_server = __esm(() => {
+  init_engine();
+  init_links();
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -2767,7 +3085,11 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/cli/index.ts
-import { resolve, join as join5 } from "path";
+init_engine();
+import { resolve, join as join6 } from "path";
+init_auto_embed();
+init_store();
+init_model();
 
 // src/git/git-reader.ts
 import { execSync } from "child_process";
@@ -2867,6 +3189,8 @@ class GitReader {
 }
 
 // src/git/git-importer.ts
+init_engine();
+init_ops();
 import { existsSync as existsSync2, mkdirSync } from "fs";
 import { join as join2 } from "path";
 async function importFromGit(opts) {
@@ -3067,6 +3391,7 @@ class ImportEngine {
 }
 
 // src/git/git-exporter.ts
+init_engine();
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync, unlinkSync } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
@@ -3329,7 +3654,22 @@ program2.command("init").description("Initialize a new TrellisVCS repository in
     return;
   }
   const engine = new TrellisVcsEngine({ rootPath });
-  const result = await engine.initRepo();
+  let renderedProgress = false;
+  const result = await engine.initRepo({
+    onProgress: (progress) => {
+      renderedProgress = true;
+      if (progress.phase === "done") {
+        process.stdout.write("\r\x1B[2K");
+        return;
+      }
+      const label = progress.phase === "discovering" ? "Discovering\u2026" : progress.phase === "hashing" ? "Hashing\u2026" : "Recording\u2026";
+      process.stdout.write(`\r\x1B[2K  ${source_default.dim(label)} ${progress.message}`);
+    }
+  });
+  if (renderedProgress) {
+    process.stdout.write(`
+`);
+  }
   console.log(source_default.green("\u2713 Initialized TrellisVCS repository"));
   console.log(`  ${source_default.dim("Path:")}     ${rootPath}`);
   console.log(`  ${source_default.dim("Ops:")}      ${result.opsCreated} initial operations recorded`);
@@ -3754,9 +4094,9 @@ program2.command("parse").description("Parse a file into AST-level semantic enti
   const engine = new TrellisVcsEngine({ rootPath });
   if (TrellisVcsEngine.isRepo(rootPath))
     engine.open();
-  const { readFileSync: readFileSync3 } = __require("fs");
+  const { readFileSync: readFileSync4 } = __require("fs");
   const filePath = resolve(file);
-  const content = readFileSync3(filePath, "utf-8");
+  const content = readFileSync4(filePath, "utf-8");
   const result = engine.parseFile(content, file);
   if (!result) {
     console.log(source_default.dim(`No parser available for: ${file}`));
@@ -3792,9 +4132,9 @@ program2.command("sdiff").description("Show semantic diff between two versions o
   const engine = new TrellisVcsEngine({ rootPath });
   if (TrellisVcsEngine.isRepo(rootPath))
     engine.open();
-  const { readFileSync: readFileSync3 } = __require("fs");
-  const oldContent = readFileSync3(resolve(fileA), "utf-8");
-  const newContent = readFileSync3(resolve(fileB), "utf-8");
+  const { readFileSync: readFileSync4 } = __require("fs");
+  const oldContent = readFileSync4(resolve(fileA), "utf-8");
+  const newContent = readFileSync4(resolve(fileB), "utf-8");
   const patches = engine.semanticDiff(oldContent, newContent, fileA);
   if (patches.length === 0) {
     console.log(source_default.dim("No semantic differences."));
@@ -4456,7 +4796,7 @@ decisionCmd.command("chain").description("Trace all decisions that affected a gi
 });
 program2.command("identity").description("Manage local identity (Ed25519 key pair)").argument("[action]", '"init" or "show" (default: show)').option("-p, --path <path>", "Repository path", ".").option("--name <name>", "Display name for new identity").option("--email <email>", "Email for new identity").action((action, opts) => {
   const rootPath = resolve(opts.path);
-  const trellisDir = join5(rootPath, ".trellis");
+  const trellisDir = join6(rootPath, ".trellis");
   if (action === "init") {
     if (hasIdentity(trellisDir)) {
       console.error(source_default.yellow("Identity already exists. Use `trellis identity` to view it."));
@@ -4500,31 +4840,31 @@ program2.command("refs").description("List wiki-link references in files or find
   }
   const engine = new TrellisVcsEngine({ rootPath });
   engine.open();
-  const { readFileSync: readFileSync3 } = __require("fs");
+  const { readFileSync: readFileSync4 } = __require("fs");
   const {
     parseFileRefs,
-    buildRefIndex,
-    getOutgoingRefs,
-    getBacklinks,
+    buildRefIndex: buildRefIndex2,
+    getOutgoingRefs: getOutgoingRefs2,
+    getBacklinks: getBacklinks2,
     getIndexStats
   } = (init_links(), __toCommonJS(exports_links));
   const {
     resolveRef,
     resolveRefs,
-    createResolverContext
+    createResolverContext: createResolverContext2
   } = (init_links(), __toCommonJS(exports_links));
   const { StaleRefRegistry, getDiagnostics } = (init_links(), __toCommonJS(exports_links));
-  const resolverCtx = createResolverContext(engine);
+  const resolverCtx = createResolverContext2(engine);
   const trackedFiles = engine.trackedFiles();
   const fileContents = [];
   for (const f of trackedFiles) {
     try {
-      const absPath = join5(rootPath, f.path);
-      const content = readFileSync3(absPath, "utf-8");
+      const absPath = join6(rootPath, f.path);
+      const content = readFileSync4(absPath, "utf-8");
       fileContents.push({ path: f.path, content });
     } catch {}
   }
-  const index = buildRefIndex(fileContents, resolverCtx);
+  const index = buildRefIndex2(fileContents, resolverCtx);
   if (opts.stats) {
     const stats = getIndexStats(index);
     console.log(source_default.bold(`Reference Index Stats
@@ -4547,7 +4887,7 @@ program2.command("refs").description("List wiki-link references in files or find
     ];
     let found = false;
     for (const eid of candidates) {
-      const sources = getBacklinks(index, eid);
+      const sources = getBacklinks2(index, eid);
       if (sources.length > 0) {
         console.log(source_default.bold(`Backlinks for ${source_default.cyan(eid)} (${sources.length})
 `));
@@ -4599,7 +4939,7 @@ program2.command("refs").description("List wiki-link references in files or find
     return;
   }
   if (file) {
-    const refs = getOutgoingRefs(index, file);
+    const refs = getOutgoingRefs2(index, file);
     if (refs.length === 0) {
       console.log(source_default.dim(`No [[...]] references found in: ${file}`));
       return;
@@ -4640,7 +4980,7 @@ program2.command("search").description("Semantic search across all embedded cont
   const engine = new TrellisVcsEngine({ rootPath });
   engine.open();
   const { EmbeddingManager } = (init_embeddings(), __toCommonJS(exports_embeddings));
-  const dbPath = join5(rootPath, ".trellis", "embeddings.db");
+  const dbPath = join6(rootPath, ".trellis", "embeddings.db");
   const manager = new EmbeddingManager(dbPath);
   try {
     const searchOpts = {
@@ -4678,7 +5018,7 @@ program2.command("reindex").description("Rebuild the semantic embedding index").
   const engine = new TrellisVcsEngine({ rootPath });
   engine.open();
   const { EmbeddingManager } = (init_embeddings(), __toCommonJS(exports_embeddings));
-  const dbPath = join5(rootPath, ".trellis", "embeddings.db");
+  const dbPath = join6(rootPath, ".trellis", "embeddings.db");
   const manager = new EmbeddingManager(dbPath);
   try {
     console.log(source_default.dim("Loading embedding model\u2026"));
@@ -4690,6 +5030,667 @@ program2.command("reindex").description("Rebuild the semantic embedding index").
     manager.close();
   }
 });
+program2.command("ui").description("Launch the interactive graph explorer in your browser").option("-p, --path <path>", "Repository path", ".").option("--port <port>", "Server port", "3333").option("--no-open", "Do not auto-open browser").action(async (opts) => {
+  const rootPath = resolve(opts.path);
+  if (!TrellisVcsEngine.isRepo(rootPath)) {
+    console.error(source_default.red("Not a TrellisVCS repository. Run `trellis init` first."));
+    process.exit(1);
+  }
+  const { startUIServer: startUIServer2 } = (init_server(), __toCommonJS(exports_server));
+  const port = parseInt(opts.port, 10) || 3000;
+  try {
+    const server = await startUIServer2({ rootPath, port });
+    const url = `http://localhost:${server.port}`;
+    console.log(source_default.green(`\u2713 Trellis Graph Explorer running at ${source_default.bold(url)}`));
+    console.log(source_default.dim(`  Press Ctrl+C to stop
+`));
+    if (opts.open !== false) {
+      const { exec } = __require("child_process");
+      const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${cmd} ${url}`);
+    }
+    process.on("SIGINT", () => {
+      server.stop();
+      console.log(source_default.dim(`
+Server stopped.`));
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error(source_default.red(`Failed to start server: ${err.message}`));
+    process.exit(1);
+  }
+});
+function bootKernel(rootPath) {
+  const dbPath = join6(rootPath, ".trellis", "kernel.db");
+  const backend = new SqliteKernelBackend(dbPath);
+  const kernel = new TrellisKernel({
+    backend,
+    agentId: `agent:${process.env.USER ?? "unknown"}`
+  });
+  kernel.boot();
+  return kernel;
+}
+var entityCmd = program2.command("entity").description("Manage graph entities (generic CRUD)");
+entityCmd.command("create").description("Create a new entity in the graph").requiredOption("-i, --id <id>", 'Entity ID (e.g. "project:my-app")').requiredOption("-t, --type <type>", 'Entity type (e.g. "Project", "User")').option("-a, --attr <attrs...>", "Attributes as key=value pairs").option("-p, --path <path>", "Repository path", ".").action(async (opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const attrs = {};
+    if (opts.attr) {
+      for (const pair of opts.attr) {
+        const eq = pair.indexOf("=");
+        if (eq === -1)
+          continue;
+        const key = pair.slice(0, eq);
+        let val = pair.slice(eq + 1);
+        if (val === "true")
+          val = true;
+        else if (val === "false")
+          val = false;
+        else if (!isNaN(Number(val)) && val !== "")
+          val = Number(val);
+        attrs[key] = val;
+      }
+    }
+    const result = await kernel.createEntity(opts.id, opts.type, attrs);
+    console.log(source_default.green(`\u2713 Entity created: ${source_default.bold(opts.id)}`));
+    console.log(`  ${source_default.dim("Type:")}  ${opts.type}`);
+    console.log(`  ${source_default.dim("Facts:")} ${result.factsDelta.added}`);
+    console.log(`  ${source_default.dim("Op:")}    ${result.op.hash.slice(0, 32)}\u2026`);
+  } finally {
+    kernel.close();
+  }
+});
+entityCmd.command("get").description("Get an entity by ID").argument("<id>", "Entity ID").option("-p, --path <path>", "Repository path", ".").option("--json", "Output as JSON").action((id, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const entity = kernel.getEntity(id);
+    if (!entity) {
+      console.error(source_default.red(`Entity not found: ${id}`));
+      process.exit(1);
+    }
+    if (opts.json) {
+      const obj = { id: entity.id, type: entity.type };
+      for (const f of entity.facts) {
+        if (f.a !== "type")
+          obj[f.a] = f.v;
+      }
+      obj._links = entity.links.map((l) => ({
+        attribute: l.a,
+        target: l.e2,
+        source: l.e1
+      }));
+      console.log(JSON.stringify(obj, null, 2));
+      return;
+    }
+    console.log(source_default.bold(`${entity.type}: ${entity.id}
+`));
+    for (const f of entity.facts) {
+      console.log(`  ${source_default.dim(f.a.padEnd(20))} ${f.v}`);
+    }
+    if (entity.links.length > 0) {
+      console.log(`
+  ${source_default.bold("Links:")}`);
+      for (const l of entity.links) {
+        const dir = l.e1 === id ? "\u2192" : "\u2190";
+        const other = l.e1 === id ? l.e2 : l.e1;
+        console.log(`    ${dir} ${source_default.dim(l.a)} ${other}`);
+      }
+    }
+  } finally {
+    kernel.close();
+  }
+});
+entityCmd.command("update").description("Update attributes on an existing entity").argument("<id>", "Entity ID").requiredOption("-a, --attr <attrs...>", "Attributes as key=value pairs").option("-p, --path <path>", "Repository path", ".").action(async (id, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const updates = {};
+    for (const pair of opts.attr) {
+      const eq = pair.indexOf("=");
+      if (eq === -1)
+        continue;
+      const key = pair.slice(0, eq);
+      let val = pair.slice(eq + 1);
+      if (val === "true")
+        val = true;
+      else if (val === "false")
+        val = false;
+      else if (!isNaN(Number(val)) && val !== "")
+        val = Number(val);
+      updates[key] = val;
+    }
+    await kernel.updateEntity(id, updates);
+    console.log(source_default.green(`\u2713 Updated ${source_default.bold(id)}`));
+    for (const [k, v] of Object.entries(updates)) {
+      console.log(`  ${source_default.dim(k)} = ${v}`);
+    }
+  } finally {
+    kernel.close();
+  }
+});
+entityCmd.command("delete").description("Delete an entity and all its facts/links").argument("<id>", "Entity ID").option("-p, --path <path>", "Repository path", ".").action(async (id, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const entity = kernel.getEntity(id);
+    if (!entity) {
+      console.error(source_default.red(`Entity not found: ${id}`));
+      process.exit(1);
+    }
+    await kernel.deleteEntity(id);
+    console.log(source_default.green(`\u2713 Deleted entity ${source_default.bold(id)}`));
+  } finally {
+    kernel.close();
+  }
+});
+entityCmd.command("list").description("List entities, optionally filtered by type").option("-t, --type <type>", "Filter by entity type").option("-f, --filter <filters...>", "Attribute filters as key=value").option("--json", "Output as JSON").option("-p, --path <path>", "Repository path", ".").action((opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    let filters;
+    if (opts.filter) {
+      filters = {};
+      for (const pair of opts.filter) {
+        const eq = pair.indexOf("=");
+        if (eq === -1)
+          continue;
+        const key = pair.slice(0, eq);
+        let val = pair.slice(eq + 1);
+        if (val === "true")
+          val = true;
+        else if (val === "false")
+          val = false;
+        else if (!isNaN(Number(val)) && val !== "")
+          val = Number(val);
+        filters[key] = val;
+      }
+    }
+    const entities = kernel.listEntities(opts.type, filters);
+    if (opts.json) {
+      const out = entities.map((e) => {
+        const obj = { id: e.id, type: e.type };
+        for (const f of e.facts) {
+          if (f.a !== "type")
+            obj[f.a] = f.v;
+        }
+        return obj;
+      });
+      console.log(JSON.stringify(out, null, 2));
+      return;
+    }
+    if (entities.length === 0) {
+      console.log(source_default.dim("No entities found."));
+      return;
+    }
+    const typeLabel = opts.type ? ` (type: ${opts.type})` : "";
+    console.log(source_default.bold(`Entities (${entities.length})${typeLabel}
+`));
+    for (const e of entities) {
+      const nameFact = e.facts.find((f) => f.a === "name");
+      const name = nameFact ? ` ${source_default.white(String(nameFact.v))}` : "";
+      console.log(`  ${source_default.cyan(e.type.padEnd(16))} ${source_default.bold(e.id)}${name}`);
+    }
+  } finally {
+    kernel.close();
+  }
+});
+var factCmd = program2.command("fact").description("Add or remove individual facts on entities");
+factCmd.command("add").description("Add a fact to an entity").argument("<entity>", "Entity ID").argument("<attribute>", "Attribute name").argument("<value>", "Value").option("-p, --path <path>", "Repository path", ".").action(async (entity, attribute, value, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    let val = value;
+    if (val === "true")
+      val = true;
+    else if (val === "false")
+      val = false;
+    else if (!isNaN(Number(val)) && val !== "")
+      val = Number(val);
+    await kernel.addFact(entity, attribute, val);
+    console.log(source_default.green(`\u2713 Added fact: ${source_default.bold(entity)}.${attribute} = ${val}`));
+  } finally {
+    kernel.close();
+  }
+});
+factCmd.command("remove").description("Remove a fact from an entity").argument("<entity>", "Entity ID").argument("<attribute>", "Attribute name").argument("<value>", "Value to remove").option("-p, --path <path>", "Repository path", ".").action(async (entity, attribute, value, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    let val = value;
+    if (val === "true")
+      val = true;
+    else if (val === "false")
+      val = false;
+    else if (!isNaN(Number(val)) && val !== "")
+      val = Number(val);
+    await kernel.removeFact(entity, attribute, val);
+    console.log(source_default.green(`\u2713 Removed fact: ${source_default.bold(entity)}.${attribute} = ${val}`));
+  } finally {
+    kernel.close();
+  }
+});
+factCmd.command("query").description("Query facts by entity or attribute").option("-e, --entity <id>", "Filter by entity ID").option("-a, --attribute <attr>", "Filter by attribute").option("--json", "Output as JSON").option("-p, --path <path>", "Repository path", ".").action((opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const store = kernel.getStore();
+    let facts;
+    if (opts.entity) {
+      facts = store.getFactsByEntity(opts.entity);
+    } else if (opts.attribute) {
+      facts = store.getFactsByAttribute(opts.attribute);
+    } else {
+      facts = store.getAllFacts();
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(facts, null, 2));
+      return;
+    }
+    if (facts.length === 0) {
+      console.log(source_default.dim("No facts found."));
+      return;
+    }
+    console.log(source_default.bold(`Facts (${facts.length})
+`));
+    for (const f of facts.slice(0, 100)) {
+      console.log(`  ${source_default.cyan(f.e.padEnd(24))} ${source_default.dim(f.a.padEnd(20))} ${f.v}`);
+    }
+    if (facts.length > 100) {
+      console.log(source_default.dim(`  \u2026 +${facts.length - 100} more`));
+    }
+  } finally {
+    kernel.close();
+  }
+});
+var linkCmd = program2.command("link").description("Add or remove links between entities");
+linkCmd.command("add").description("Add a link between two entities").argument("<source>", "Source entity ID").argument("<attribute>", "Relationship attribute").argument("<target>", "Target entity ID").option("-p, --path <path>", "Repository path", ".").action(async (source, attribute, target, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    await kernel.addLink(source, attribute, target);
+    console.log(source_default.green(`\u2713 Link: ${source_default.bold(source)} \u2014[${attribute}]\u2192 ${source_default.bold(target)}`));
+  } finally {
+    kernel.close();
+  }
+});
+linkCmd.command("remove").description("Remove a link between two entities").argument("<source>", "Source entity ID").argument("<attribute>", "Relationship attribute").argument("<target>", "Target entity ID").option("-p, --path <path>", "Repository path", ".").action(async (source, attribute, target, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    await kernel.removeLink(source, attribute, target);
+    console.log(source_default.green(`\u2713 Removed: ${source_default.bold(source)} \u2014[${attribute}]\u2192 ${source_default.bold(target)}`));
+  } finally {
+    kernel.close();
+  }
+});
+linkCmd.command("query").description("Query links for an entity").option("-e, --entity <id>", "Entity ID").option("-a, --attribute <attr>", "Relationship attribute").option("--json", "Output as JSON").option("-p, --path <path>", "Repository path", ".").action((opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const store = kernel.getStore();
+    let links;
+    if (opts.entity && opts.attribute) {
+      links = store.getLinksByEntityAndAttribute(opts.entity, opts.attribute);
+    } else if (opts.entity) {
+      links = store.getLinksByEntity(opts.entity);
+    } else if (opts.attribute) {
+      links = store.getLinksByAttribute(opts.attribute);
+    } else {
+      links = store.getAllLinks();
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(links, null, 2));
+      return;
+    }
+    if (links.length === 0) {
+      console.log(source_default.dim("No links found."));
+      return;
+    }
+    console.log(source_default.bold(`Links (${links.length})
+`));
+    for (const l of links.slice(0, 100)) {
+      console.log(`  ${source_default.cyan(l.e1)} \u2014[${source_default.dim(l.a)}]\u2192 ${source_default.cyan(l.e2)}`);
+    }
+    if (links.length > 100) {
+      console.log(source_default.dim(`  \u2026 +${links.length - 100} more`));
+    }
+  } finally {
+    kernel.close();
+  }
+});
+program2.command("query").description("Execute an EQL-S query against the graph").argument("<query>", 'EQL-S query string (or "find ?e where attr = value" shorthand)').option("-p, --path <path>", "Repository path", ".").option("--json", "Output as JSON").action((queryStr, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const store = kernel.getStore();
+    const engine = new QueryEngine(store);
+    let q;
+    try {
+      q = parseSimple(queryStr);
+    } catch {
+      try {
+        q = parseQuery(queryStr);
+      } catch (e) {
+        console.error(source_default.red(`Parse error: ${e.message}`));
+        process.exit(1);
+        return;
+      }
+    }
+    const result = engine.execute(q);
+    if (opts.json) {
+      console.log(JSON.stringify(result.bindings, null, 2));
+    } else {
+      if (result.count === 0) {
+        console.log(source_default.dim("No results."));
+      } else {
+        const cols = result.bindings.length > 0 ? Object.keys(result.bindings[0]) : [];
+        console.log(source_default.bold(cols.map((c) => `?${c}`).join("\t")));
+        console.log(source_default.dim("\u2500".repeat(cols.length * 20)));
+        for (const row of result.bindings) {
+          console.log(cols.map((c) => String(row[c] ?? "")).join("\t"));
+        }
+        console.log(source_default.dim(`
+${result.count} result(s) in ${result.executionTime.toFixed(1)}ms`));
+      }
+    }
+  } finally {
+    kernel.close();
+  }
+});
+program2.command("repl").description("Interactive EQL-S query shell").option("-p, --path <path>", "Repository path", ".").action(async (opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  const store = kernel.getStore();
+  const engine = new QueryEngine(store);
+  console.log(source_default.cyan.bold("Trellis EQL-S REPL"));
+  console.log(source_default.dim('Type EQL-S queries or "find ?e where attr = value" shorthand.'));
+  console.log(source_default.dim(`Type .exit to quit, .help for help.
+`));
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: source_default.green("eql> ")
+  });
+  rl.prompt();
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === ".exit" || trimmed === ".quit") {
+      kernel.close();
+      rl.close();
+      return;
+    }
+    if (trimmed === ".help") {
+      console.log(`
+${source_default.bold("EQL-S Query Syntax:")}
+  ${source_default.cyan("SELECT")} ?var1 ?var2 ${source_default.cyan("WHERE")} { patterns } [${source_default.cyan("FILTER")} ...] [${source_default.cyan("ORDER BY")} ...] [${source_default.cyan("LIMIT")} n]
+
+${source_default.bold("Pattern types:")}
+  ${source_default.yellow('[?e "attr" "value"]')}     Fact pattern (entity, attribute, value)
+  ${source_default.yellow('(?src "rel" ?tgt)')}       Link pattern (source, relationship, target)
+  ${source_default.yellow('NOT [?e "attr" ?v]')}      Negation
+  ${source_default.yellow("OR { ... } { ... }")}      Disjunction
+
+${source_default.bold("Shorthand:")}
+  ${source_default.yellow('find ?e where type = "Project"')}
+
+${source_default.bold("Commands:")}
+  .exit / .quit   Exit the REPL
+  .stats          Show store statistics
+  .help           Show this help
+`);
+      rl.prompt();
+      return;
+    }
+    if (trimmed === ".stats") {
+      const facts = store.getAllFacts();
+      const links = store.getAllLinks();
+      const types = new Set(facts.filter((f) => f.a === "type").map((f) => f.v));
+      console.log(`  Facts: ${facts.length}`);
+      console.log(`  Links: ${links.length}`);
+      console.log(`  Entity types: ${[...types].join(", ") || "(none)"}`);
+      rl.prompt();
+      return;
+    }
+    try {
+      let q;
+      try {
+        q = parseSimple(trimmed);
+      } catch {
+        q = parseQuery(trimmed);
+      }
+      const result = engine.execute(q);
+      if (result.count === 0) {
+        console.log(source_default.dim("No results."));
+      } else {
+        const cols = Object.keys(result.bindings[0]);
+        console.log(source_default.bold(cols.map((c) => `?${c}`).join("\t")));
+        for (const row of result.bindings) {
+          console.log(cols.map((c) => String(row[c] ?? "")).join("\t"));
+        }
+        console.log(source_default.dim(`${result.count} result(s) in ${result.executionTime.toFixed(1)}ms`));
+      }
+    } catch (e) {
+      console.error(source_default.red(`Error: ${e.message}`));
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    kernel.close();
+    console.log(source_default.dim("Goodbye."));
+  });
+});
+var ontologyCmd = program2.command("ontology").description("Manage and inspect ontology schemas");
+ontologyCmd.command("list").description("List all registered ontologies (built-in + custom)").action(() => {
+  const registry = new OntologyRegistry;
+  for (const o of builtinOntologies)
+    registry.register(o);
+  const schemas = registry.list();
+  if (schemas.length === 0) {
+    console.log(source_default.dim("No ontologies registered."));
+    return;
+  }
+  console.log(source_default.bold(`Ontologies (${schemas.length})
+`));
+  for (const s of schemas) {
+    console.log(`  ${source_default.cyan(s.id)} ${source_default.dim(`v${s.version}`)}`);
+    console.log(`    ${s.name}${s.description ? ` \u2014 ${source_default.dim(s.description)}` : ""}`);
+    console.log(`    Entities: ${s.entities.map((e) => e.name).join(", ")}`);
+    console.log(`    Relations: ${s.relations.map((r) => r.name).join(", ")}`);
+    console.log();
+  }
+});
+ontologyCmd.command("inspect").description("Inspect a specific ontology or entity type").argument("<name>", 'Ontology ID (e.g. "trellis:project") or entity type name (e.g. "Project")').action((name) => {
+  const registry = new OntologyRegistry;
+  for (const o of builtinOntologies)
+    registry.register(o);
+  const schema = registry.get(name);
+  if (schema) {
+    console.log(source_default.bold(`${schema.name} ${source_default.dim(`(${schema.id} v${schema.version})`)}`));
+    if (schema.description)
+      console.log(source_default.dim(schema.description));
+    console.log();
+    console.log(source_default.bold("Entity Types:"));
+    for (const e of schema.entities) {
+      console.log(`
+  ${source_default.cyan.bold(e.name)}${e.abstract ? source_default.dim(" (abstract)") : ""}${e.extends ? source_default.dim(` extends ${e.extends}`) : ""}`);
+      if (e.description)
+        console.log(`  ${source_default.dim(e.description)}`);
+      for (const a of e.attributes) {
+        const flags = [
+          a.required ? source_default.red("required") : null,
+          a.enum ? `enum[${a.enum.join("|")}]` : null,
+          a.default !== undefined ? `default=${a.default}` : null
+        ].filter(Boolean).join(", ");
+        console.log(`    ${source_default.yellow(a.name)}: ${a.type}${flags ? ` (${flags})` : ""}`);
+      }
+    }
+    if (schema.relations.length > 0) {
+      console.log(source_default.bold(`
+Relations:`));
+      for (const r of schema.relations) {
+        console.log(`  ${source_default.yellow(r.name)}: ${r.sourceTypes.join("|")} \u2192 ${r.targetTypes.join("|")}${r.cardinality ? ` [${r.cardinality}]` : ""}`);
+      }
+    }
+    return;
+  }
+  const def = registry.getEntityDef(name);
+  if (def) {
+    const ontId = registry.getEntityOntology(name);
+    console.log(source_default.bold(`${def.name}`) + source_default.dim(` (from ${ontId})`));
+    if (def.description)
+      console.log(source_default.dim(def.description));
+    if (def.abstract)
+      console.log(source_default.dim("(abstract \u2014 cannot be instantiated)"));
+    if (def.extends)
+      console.log(source_default.dim(`extends ${def.extends}`));
+    console.log(source_default.bold(`
+Attributes:`));
+    for (const a of def.attributes) {
+      const flags = [
+        a.required ? source_default.red("required") : null,
+        a.enum ? `enum[${a.enum.join("|")}]` : null,
+        a.default !== undefined ? `default=${a.default}` : null
+      ].filter(Boolean).join(", ");
+      console.log(`  ${source_default.yellow(a.name)}: ${a.type}${flags ? ` (${flags})` : ""}`);
+      if (a.description)
+        console.log(`    ${source_default.dim(a.description)}`);
+    }
+    const rels = registry.getRelationsForType(name);
+    if (rels.length > 0) {
+      console.log(source_default.bold(`
+Relations:`));
+      for (const r of rels) {
+        const dir = r.sourceTypes.includes(name) ? "\u2192" : "\u2190";
+        console.log(`  ${source_default.yellow(r.name)} ${dir} ${r.sourceTypes.includes(name) ? r.targetTypes.join("|") : r.sourceTypes.join("|")}`);
+      }
+    }
+    return;
+  }
+  console.error(source_default.red(`Unknown ontology or entity type: "${name}"`));
+  console.log(source_default.dim("Available ontologies: " + registry.list().map((s) => s.id).join(", ")));
+  console.log(source_default.dim("Available types: " + registry.listEntityTypes().join(", ")));
+});
+ontologyCmd.command("validate").description("Validate all entities in the graph against registered ontologies").option("-p, --path <path>", "Repository path", ".").option("--strict", "Treat unknown types as errors").action((opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const kernel = bootKernel(rootPath);
+  try {
+    const registry = new OntologyRegistry;
+    for (const o of builtinOntologies)
+      registry.register(o);
+    const store = kernel.getStore();
+    const result = validateStore(store, registry);
+    if (result.errors.length > 0) {
+      console.log(source_default.red.bold(`\u2717 ${result.errors.length} error(s):
+`));
+      for (const err of result.errors) {
+        console.log(`  ${source_default.red("ERROR")} ${source_default.bold(err.entityId)} (${err.entityType}) \u2192 ${err.field}: ${err.message}`);
+      }
+    }
+    if (result.warnings.length > 0) {
+      console.log(source_default.yellow.bold(`
+\u26A0 ${result.warnings.length} warning(s):
+`));
+      for (const w of result.warnings) {
+        console.log(`  ${source_default.yellow("WARN")}  ${source_default.bold(w.entityId)} (${w.entityType}) \u2192 ${w.field}: ${w.message}`);
+      }
+    }
+    if (result.valid && result.warnings.length === 0) {
+      console.log(source_default.green("\u2713 All entities pass ontology validation."));
+    } else if (result.valid) {
+      console.log(source_default.green(`
+\u2713 Valid (with warnings).`));
+    } else {
+      console.log(source_default.red(`
+\u2717 Validation failed.`));
+    }
+  } finally {
+    kernel.close();
+  }
+});
+program2.command("ask").description("Natural language search over the graph (semantic search)").argument("<question>", "Natural language query").option("-p, --path <path>", "Repository path", ".").option("-n, --limit <n>", "Max results", "5").option("--json", "Output as JSON").option("--rag", "Output as RAG context (for LLM consumption)").action(async (question, opts) => {
+  const rootPath = resolve(opts.path);
+  requireRepo(rootPath);
+  const dbPath = join6(rootPath, ".trellis", "embeddings.db");
+  const vectorStore = new VectorStore(dbPath);
+  try {
+    const limit = parseInt(opts.limit, 10) || 5;
+    if (opts.rag) {
+      const ctx = await buildRAGContext(question, vectorStore, embed, {
+        maxChunks: limit
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(ctx, null, 2));
+      } else {
+        console.log(source_default.bold.cyan("RAG Context"));
+        console.log(source_default.dim(`Query: ${ctx.query}`));
+        console.log(source_default.dim(`Chunks: ${ctx.chunks.length} | ~${ctx.estimatedTokens} tokens
+`));
+        for (const c of ctx.chunks) {
+          console.log(source_default.yellow(`[${c.score.toFixed(3)}] ${c.entityId} (${c.chunkType})`));
+          console.log(c.content);
+          console.log();
+        }
+      }
+    } else {
+      const queryVector = await embed(question);
+      const results = vectorStore.search(queryVector, { limit });
+      if (opts.json) {
+        console.log(JSON.stringify(results.map((r) => ({
+          score: r.score,
+          entityId: r.chunk.entityId,
+          chunkType: r.chunk.chunkType,
+          content: r.chunk.content
+        })), null, 2));
+      } else {
+        if (results.length === 0) {
+          console.log(source_default.dim("No results. Run `trellis reindex` first to build the embedding index."));
+        } else {
+          console.log(source_default.bold(`Results for: "${question}"
+`));
+          for (const r of results) {
+            const score = source_default.dim(`[${r.score.toFixed(3)}]`);
+            const entity = source_default.cyan(r.chunk.entityId);
+            const type = source_default.dim(`(${r.chunk.chunkType})`);
+            console.log(`${score} ${entity} ${type}`);
+            const preview = r.chunk.content.length > 200 ? r.chunk.content.slice(0, 200) + "\u2026" : r.chunk.content;
+            console.log(`  ${preview}
+`);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (err.message?.includes("No transformers")) {
+      console.error(source_default.red("Embedding model not available."));
+      console.error(source_default.dim("Install: bun add @huggingface/transformers"));
+    } else {
+      console.error(source_default.red(`Error: ${err.message}`));
+    }
+  } finally {
+    vectorStore.close();
+  }
+});
 function formatOpKind(kind) {
   const kindMap = {
     "vcs:fileAdd": source_default.green("+add"),