trellis 2.0.8 → 2.0.10

package/dist/cli/index.js

@@ -3,13 +3,30 @@
 import {
   TrellisVcsEngine,
   init_engine
-} from "../index-s603ev6w.js";
-import"../index-5bhe57y9.js";
+} 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,
@@ -3070,6 +3087,9 @@ var source_default = chalk;
 // src/cli/index.ts
 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";
@@ -5040,6 +5060,637 @@ Server stopped.`));
     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"),