trellis 2.0.8 → 2.0.13

package/dist/core/index.js

@@ -1,16 +1,485 @@
 // @bun
+import {
+  DatalogRuntime,
+  OntologyRegistry,
+  agentOntology,
+  builtinOntologies,
+  createValidationMiddleware,
+  parseQuery,
+  parseRule,
+  parseSimple,
+  projectOntology,
+  teamOntology,
+  validateEntity,
+  validateStore
+} from "../index-5m0g9r0y.js";
 import {
   EAVStore,
+  QueryEngine,
+  SqliteKernelBackend,
+  TrellisKernel,
   flatten,
   init_eav_store,
   jsonEntityFacts
-} from "../index-5bhe57y9.js";
+} from "../index-hybgxe40.js";
 import"../index-a76rekgs.js";
 
 // src/core/index.ts
 init_eav_store();
+
+// src/core/agents/harness.ts
+class AgentHarness {
+  kernel;
+  toolHandlers = new Map;
+  config;
+  runCounter = 0;
+  constructor(kernel, config) {
+    this.kernel = kernel;
+    this.config = {
+      recordDecisions: true,
+      maxDecisionsPerRun: 100,
+      ...config
+    };
+  }
+  async createAgent(def) {
+    const id = def.id ?? `agent:${def.name.toLowerCase().replace(/\s+/g, "-")}`;
+    await this.kernel.createEntity(id, "Agent", {
+      name: def.name,
+      ...def.description ? { description: def.description } : {},
+      ...def.model ? { model: def.model } : {},
+      ...def.provider ? { provider: def.provider } : {},
+      ...def.systemPrompt ? { systemPrompt: def.systemPrompt } : {},
+      status: def.status ?? "active"
+    });
+    if (def.capabilities) {
+      for (const cap of def.capabilities) {
+        await this.kernel.addLink(id, "hasCapability", cap);
+      }
+    }
+    if (def.tools) {
+      for (const tool of def.tools) {
+        await this.kernel.addLink(id, "hasTool", tool);
+      }
+    }
+    return this.getAgent(id);
+  }
+  getAgent(id) {
+    const entity = this.kernel.getEntity(id);
+    if (!entity || entity.type !== "Agent")
+      return null;
+    const store = this.kernel.getStore();
+    const capLinks = store.getLinksByEntityAndAttribute(id, "hasCapability");
+    const toolLinks = store.getLinksByEntityAndAttribute(id, "hasTool");
+    return {
+      id: entity.id,
+      name: String(entity.facts.find((f) => f.a === "name")?.v ?? ""),
+      description: entity.facts.find((f) => f.a === "description")?.v,
+      model: entity.facts.find((f) => f.a === "model")?.v,
+      provider: entity.facts.find((f) => f.a === "provider")?.v,
+      systemPrompt: entity.facts.find((f) => f.a === "systemPrompt")?.v,
+      status: entity.facts.find((f) => f.a === "status")?.v ?? "active",
+      capabilities: capLinks.map((l) => l.e2),
+      tools: toolLinks.map((l) => l.e2)
+    };
+  }
+  listAgents(status) {
+    const entities = this.kernel.listEntities("Agent", status ? { status } : undefined);
+    return entities.map((e) => this.getAgent(e.id)).filter((a) => a !== null);
+  }
+  async registerTool(def, handler) {
+    const id = def.id ?? `tool:${def.name.toLowerCase().replace(/\s+/g, "-")}`;
+    if (!this.kernel.getEntity(id)) {
+      await this.kernel.createEntity(id, "Tool", {
+        name: def.name,
+        ...def.description ? { description: def.description } : {},
+        ...def.schema ? { schema: def.schema } : {},
+        ...def.endpoint ? { endpoint: def.endpoint } : {}
+      });
+    }
+    this.toolHandlers.set(id, handler);
+    return id;
+  }
+  getToolHandler(toolId) {
+    return this.toolHandlers.get(toolId);
+  }
+  listTools() {
+    return this.kernel.listEntities("Tool").map((e) => ({
+      id: e.id,
+      name: String(e.facts.find((f) => f.a === "name")?.v ?? ""),
+      description: e.facts.find((f) => f.a === "description")?.v,
+      schema: e.facts.find((f) => f.a === "schema")?.v,
+      endpoint: e.facts.find((f) => f.a === "endpoint")?.v
+    }));
+  }
+  async startRun(agentId, input) {
+    const agent = this.getAgent(agentId);
+    if (!agent)
+      throw new Error(`Agent "${agentId}" not found.`);
+    const runId = `run:${agentId.replace("agent:", "")}:${Date.now()}:${++this.runCounter}`;
+    await this.kernel.createEntity(runId, "AgentRun", {
+      startedAt: new Date().toISOString(),
+      status: "running",
+      ...input ? { input } : {}
+    });
+    await this.kernel.addLink(runId, "executedBy", agentId);
+    return runId;
+  }
+  async completeRun(runId, output, tokenCount) {
+    const updates = {
+      status: "completed",
+      completedAt: new Date().toISOString()
+    };
+    if (output)
+      updates.output = output;
+    if (tokenCount !== undefined)
+      updates.tokenCount = tokenCount;
+    await this.kernel.updateEntity(runId, updates);
+  }
+  async failRun(runId, error) {
+    await this.kernel.updateEntity(runId, {
+      status: "failed",
+      completedAt: new Date().toISOString(),
+      output: `Error: ${error}`
+    });
+  }
+  getRun(runId) {
+    const entity = this.kernel.getEntity(runId);
+    if (!entity || entity.type !== "AgentRun")
+      return null;
+    const store = this.kernel.getStore();
+    const agentLink = store.getLinksByEntityAndAttribute(runId, "executedBy");
+    const agentId = agentLink[0]?.e2 ?? "";
+    const decisionLinks = store.getLinksByAttribute("belongsToRun");
+    const decisionIds = decisionLinks.filter((l) => l.e2 === runId).map((l) => l.e1);
+    const decisions = decisionIds.map((did) => this._buildDecisionTrace(did)).filter(Boolean);
+    const get = (a) => entity.facts.find((f) => f.a === a)?.v;
+    return {
+      id: runId,
+      agentId,
+      startedAt: String(get("startedAt") ?? ""),
+      completedAt: get("completedAt"),
+      status: get("status") ?? "running",
+      input: get("input"),
+      output: get("output"),
+      tokenCount: get("tokenCount"),
+      decisions
+    };
+  }
+  listRuns(agentId) {
+    const runs = this.kernel.listEntities("AgentRun");
+    return runs.map((e) => this.getRun(e.id)).filter((r) => r !== null).filter((r) => !agentId || r.agentId === agentId).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+  }
+  async recordDecision(runId, toolName, input, output, opts) {
+    const run = this.getRun(runId);
+    if (!run)
+      throw new Error(`Run "${runId}" not found.`);
+    const decId = `decision:${runId.replace("run:", "")}:${Date.now()}`;
+    await this.kernel.createEntity(decId, "DecisionTrace", {
+      toolName,
+      timestamp: new Date().toISOString(),
+      ...input ? { input: JSON.stringify(input) } : {},
+      ...output ? { output } : {},
+      ...opts?.rationale ? { rationale: opts.rationale } : {},
+      ...opts?.alternatives ? { alternatives: JSON.stringify(opts.alternatives) } : {}
+    });
+    await this.kernel.addLink(decId, "belongsToRun", runId);
+    await this.kernel.addLink(decId, "madeBy", run.agentId);
+    if (opts?.relatedEntities) {
+      for (const eid of opts.relatedEntities) {
+        await this.kernel.addLink(decId, "relatedTo", eid);
+      }
+    }
+    return decId;
+  }
+  async invokeTool(runId, toolId, input, opts) {
+    const handler = this.toolHandlers.get(toolId);
+    if (!handler)
+      throw new Error(`No handler registered for tool "${toolId}".`);
+    const result = await handler(input);
+    if (this.config.recordDecisions) {
+      const toolEntity = this.kernel.getEntity(toolId);
+      const toolName = toolEntity ? String(toolEntity.facts.find((f) => f.a === "name")?.v ?? toolId) : toolId;
+      await this.recordDecision(runId, toolName, input, result.success ? String(result.output ?? "") : `Error: ${result.error}`, opts);
+    }
+    return result;
+  }
+  getDecisionChain(entityId) {
+    const store = this.kernel.getStore();
+    const links = store.getLinksByAttribute("relatedTo");
+    const decisionIds = links.filter((l) => l.e2 === entityId).map((l) => l.e1);
+    return decisionIds.map((did) => this._buildDecisionTrace(did)).filter(Boolean);
+  }
+  _buildDecisionTrace(decId) {
+    const entity = this.kernel.getEntity(decId);
+    if (!entity)
+      return null;
+    const get = (a) => entity.facts.find((f) => f.a === a)?.v;
+    const store = this.kernel.getStore();
+    const runLink = store.getLinksByEntityAndAttribute(decId, "belongsToRun");
+    const agentLink = store.getLinksByEntityAndAttribute(decId, "madeBy");
+    const relatedLinks = store.getLinksByEntityAndAttribute(decId, "relatedTo");
+    let inputParsed;
+    const inputRaw = get("input");
+    if (inputRaw) {
+      try {
+        inputParsed = JSON.parse(inputRaw);
+      } catch {
+        inputParsed = { raw: inputRaw };
+      }
+    }
+    let alternatives;
+    const altRaw = get("alternatives");
+    if (altRaw) {
+      try {
+        alternatives = JSON.parse(altRaw);
+      } catch {
+        alternatives = [altRaw];
+      }
+    }
+    return {
+      id: decId,
+      runId: runLink[0]?.e2 ?? "",
+      agentId: agentLink[0]?.e2 ?? "",
+      toolName: String(get("toolName") ?? ""),
+      input: inputParsed,
+      output: get("output"),
+      rationale: get("rationale"),
+      alternatives,
+      timestamp: String(get("timestamp") ?? ""),
+      relatedEntities: relatedLinks.map((l) => l.e2)
+    };
+  }
+}
+// src/core/plugins/registry.ts
+class EventBus {
+  handlers = new Map;
+  on(event, handler) {
+    const set = this.handlers.get(event) ?? new Set;
+    set.add(handler);
+    this.handlers.set(event, set);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0)
+        this.handlers.delete(event);
+    }
+  }
+  async emit(event, data) {
+    const exact = this.handlers.get(event);
+    if (exact) {
+      for (const h of exact)
+        await h(data);
+    }
+    for (const [pattern, handlers] of this.handlers) {
+      if (pattern === event)
+        continue;
+      if (pattern.endsWith("*") && event.startsWith(pattern.slice(0, -1))) {
+        for (const h of handlers)
+          await h(data);
+      }
+    }
+  }
+  listEvents() {
+    return [...this.handlers.keys()];
+  }
+  clear() {
+    this.handlers.clear();
+  }
+}
+
+class PluginRegistry {
+  plugins = new Map;
+  eventBus = new EventBus;
+  workspaceConfig = {};
+  logs = [];
+  register(def) {
+    if (this.plugins.has(def.id)) {
+      throw new Error(`Plugin "${def.id}" is already registered.`);
+    }
+    this.plugins.set(def.id, { def, loaded: false });
+  }
+  async unregister(id) {
+    const entry = this.plugins.get(id);
+    if (!entry)
+      return;
+    if (entry.loaded)
+      await this.unload(id);
+    this.plugins.delete(id);
+  }
+  async load(id, kernel, ontologyRegistry, queryEngine) {
+    const entry = this.plugins.get(id);
+    if (!entry)
+      throw new Error(`Plugin "${id}" is not registered.`);
+    if (entry.loaded)
+      return;
+    if (entry.def.dependencies) {
+      for (const dep of entry.def.dependencies) {
+        const depEntry = this.plugins.get(dep);
+        if (!depEntry) {
+          throw new Error(`Plugin "${id}" depends on "${dep}" which is not registered.`);
+        }
+        if (!depEntry.loaded) {
+          await this.load(dep, kernel, ontologyRegistry, queryEngine);
+        }
+      }
+    }
+    if (entry.def.middleware && kernel) {
+      for (const mw of entry.def.middleware) {
+        kernel.addMiddleware(mw);
+      }
+    }
+    if (entry.def.ontologies && ontologyRegistry) {
+      for (const schema of entry.def.ontologies) {
+        try {
+          ontologyRegistry.register(schema);
+        } catch {}
+      }
+    }
+    if (entry.def.rules && queryEngine) {
+      for (const rule of entry.def.rules) {
+        queryEngine.addRule(rule);
+      }
+    }
+    if (entry.def.eventHandlers) {
+      for (const eh of entry.def.eventHandlers) {
+        this.eventBus.on(eh.event, eh.handler);
+      }
+    }
+    const ctx = this._buildContext(id);
+    if (entry.def.onLoad) {
+      await entry.def.onLoad(ctx);
+    }
+    entry.loaded = true;
+    await this.eventBus.emit("plugin:loaded", { pluginId: id });
+  }
+  async unload(id) {
+    const entry = this.plugins.get(id);
+    if (!entry || !entry.loaded)
+      return;
+    const ctx = this._buildContext(id);
+    if (entry.def.onUnload) {
+      await entry.def.onUnload(ctx);
+    }
+    if (entry.def.eventHandlers) {
+      for (const eh of entry.def.eventHandlers) {
+        this.eventBus.off(eh.event, eh.handler);
+      }
+    }
+    entry.loaded = false;
+    await this.eventBus.emit("plugin:unloaded", { pluginId: id });
+  }
+  async loadAll(kernel, ontologyRegistry, queryEngine) {
+    const order = this._resolveDependencyOrder();
+    for (const id of order) {
+      await this.load(id, kernel, ontologyRegistry, queryEngine);
+    }
+  }
+  async unloadAll() {
+    const order = this._resolveDependencyOrder().reverse();
+    for (const id of order) {
+      await this.unload(id);
+    }
+  }
+  get(id) {
+    return this.plugins.get(id)?.def;
+  }
+  isLoaded(id) {
+    return this.plugins.get(id)?.loaded ?? false;
+  }
+  list() {
+    return [...this.plugins.values()];
+  }
+  listLoaded() {
+    return [...this.plugins.values()].filter((e) => e.loaded).map((e) => e.def);
+  }
+  getEventBus() {
+    return this.eventBus;
+  }
+  async emit(event, data) {
+    await this.eventBus.emit(event, data);
+  }
+  on(event, handler) {
+    this.eventBus.on(event, handler);
+  }
+  getWorkspaceConfig() {
+    return this.workspaceConfig;
+  }
+  setWorkspaceConfig(config) {
+    this.workspaceConfig = config;
+  }
+  getConfigValue(key) {
+    return this.workspaceConfig.settings?.[key];
+  }
+  setConfigValue(key, value) {
+    if (!this.workspaceConfig.settings)
+      this.workspaceConfig.settings = {};
+    this.workspaceConfig.settings[key] = value;
+  }
+  getLogs(pluginId) {
+    if (pluginId)
+      return this.logs.filter((l) => l.pluginId === pluginId);
+    return [...this.logs];
+  }
+  _buildContext(pluginId) {
+    return {
+      pluginId,
+      on: (event, handler) => this.eventBus.on(event, handler),
+      emit: (event, data) => {
+        this.eventBus.emit(event, data);
+      },
+      getConfig: (key) => this.getConfigValue(key),
+      log: (message) => {
+        this.logs.push({ pluginId, message, timestamp: new Date().toISOString() });
+      }
+    };
+  }
+  _resolveDependencyOrder() {
+    const visited = new Set;
+    const order = [];
+    const visit = (id, stack) => {
+      if (visited.has(id))
+        return;
+      if (stack.has(id))
+        throw new Error(`Circular dependency detected: ${[...stack, id].join(" \u2192 ")}`);
+      stack.add(id);
+      const entry = this.plugins.get(id);
+      if (entry?.def.dependencies) {
+        for (const dep of entry.def.dependencies) {
+          visit(dep, stack);
+        }
+      }
+      stack.delete(id);
+      visited.add(id);
+      order.push(id);
+    };
+    for (const id of this.plugins.keys()) {
+      visit(id, new Set);
+    }
+    return order;
+  }
+}
 export {
+  validateStore,
+  validateEntity,
+  teamOntology,
+  projectOntology,
+  parseSimple,
+  parseRule,
+  parseQuery,
   jsonEntityFacts,
   flatten,
-  EAVStore
+  createValidationMiddleware,
+  builtinOntologies,
+  agentOntology,
+  TrellisKernel,
+  SqliteKernelBackend,
+  QueryEngine,
+  PluginRegistry,
+  OntologyRegistry,
+  EventBus,
+  EAVStore,
+  DatalogRuntime,
+  AgentHarness
 };

package/dist/embeddings/index.js

@@ -3,6 +3,7 @@ import {
   DEFAULT_MODEL_CONFIG,
   EmbeddingManager,
   VectorStore,
+  buildRAGContext,
   chunkCodeEntities,
   chunkDecision,
   chunkDocComments,
@@ -12,13 +13,14 @@ import {
   chunkMilestone,
   chunkSummary,
   cosineSimilarity,
+  createAutoEmbedMiddleware,
   embed,
   embedBatch,
   init_embeddings,
   loadModel,
   resetModel,
   slidingWindow
-} from "../index-zf6htvnm.js";
+} from "../index-7gvjxt27.js";
 import"../index-a76rekgs.js";
 init_embeddings();
 
@@ -28,6 +30,7 @@ export {
   loadModel,
   embedBatch,
   embed,
+  createAutoEmbedMiddleware,
   cosineSimilarity,
   chunkSummary,
   chunkMilestone,
@@ -37,6 +40,7 @@ export {
   chunkDocComments,
   chunkDecision,
   chunkCodeEntities,
+  buildRAGContext,
   VectorStore,
   EmbeddingManager,
   DEFAULT_MODEL_CONFIG

package/dist/{index-s603ev6w.js → index-5b01h414.js}

@@ -2,7 +2,7 @@
 import {
   EAVStore,
   init_eav_store
-} from "./index-5bhe57y9.js";
+} from "./index-hybgxe40.js";
 import {
   BlobStore,
   addCriterion,