trellis 1.0.8 → 2.0.6

package/dist/index-8pce39mh.js

@@ -0,0 +1,272 @@
+// @bun
+import {
+  createVcsOp,
+  decisionEntityId
+} from "./index-fd4e26s4.js";
+
+// src/decisions/hooks.ts
+class HookRegistry {
+  preHooks = [];
+  postHooks = [];
+  registerPreHook(hook) {
+    this.preHooks.push(hook);
+  }
+  registerPostHook(hook) {
+    this.postHooks.push(hook);
+  }
+  removePreHook(name) {
+    this.preHooks = this.preHooks.filter((h) => h.name !== name);
+  }
+  removePostHook(name) {
+    this.postHooks = this.postHooks.filter((h) => h.name !== name);
+  }
+  getPreHooks(toolName) {
+    return this.preHooks.filter((h) => matchesPattern(h.toolPattern, toolName));
+  }
+  getPostHooks(toolName) {
+    return this.postHooks.filter((h) => matchesPattern(h.toolPattern, toolName));
+  }
+  async runPreHooks(toolName, input) {
+    const hooks = this.getPreHooks(toolName);
+    const merged = {};
+    for (const hook of hooks) {
+      try {
+        const ctx = await hook.handler(toolName, input);
+        Object.assign(merged, ctx);
+        if (ctx.custom) {
+          merged.custom = { ...merged.custom, ...ctx.custom };
+        }
+      } catch {}
+    }
+    return merged;
+  }
+  async runPostHooks(toolName, input, output, preContext) {
+    const hooks = this.getPostHooks(toolName);
+    const merged = {};
+    for (const hook of hooks) {
+      try {
+        const enrichment = await hook.handler(toolName, input, output, preContext);
+        if (enrichment.rationale)
+          merged.rationale = enrichment.rationale;
+        if (enrichment.alternatives)
+          merged.alternatives = enrichment.alternatives;
+        if (enrichment.confidence !== undefined)
+          merged.confidence = enrichment.confidence;
+        if (enrichment.relatedEntities) {
+          merged.relatedEntities = [
+            ...merged.relatedEntities ?? [],
+            ...enrichment.relatedEntities
+          ];
+        }
+        if (enrichment.custom) {
+          merged.custom = { ...merged.custom, ...enrichment.custom };
+        }
+      } catch {}
+    }
+    return merged;
+  }
+  clear() {
+    this.preHooks = [];
+    this.postHooks = [];
+  }
+}
+function matchesPattern(pattern, toolName) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(toolName);
+  }
+  if (pattern === "*")
+    return true;
+  if (!pattern.includes("*"))
+    return pattern === toolName;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(toolName);
+}
+// src/decisions/auto-capture.ts
+function wrapToolHandler(toolName, handler, opts) {
+  return async (params) => {
+    if (opts.exclude?.has(toolName)) {
+      return handler(params);
+    }
+    const preContext = await opts.hooks.runPreHooks(toolName, params);
+    const result = await handler(params);
+    const enrichment = await opts.hooks.runPostHooks(toolName, params, result, preContext);
+    const decision = {
+      toolName,
+      input: sanitizeInput(params),
+      outputSummary: summarize(result),
+      context: preContext.prompt ?? preContext.conversationId,
+      rationale: enrichment.rationale,
+      alternatives: enrichment.alternatives,
+      confidence: enrichment.confidence,
+      relatedEntities: enrichment.relatedEntities,
+      custom: {
+        ...preContext.custom,
+        ...enrichment.custom,
+        agentModel: preContext.agentModel
+      }
+    };
+    opts.recorder(decision).catch(() => {});
+    return result;
+  };
+}
+function sanitizeInput(params) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "string" && value.length > 2000) {
+      sanitized[key] = value.slice(0, 2000) + "\u2026";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function summarize(result) {
+  if (result === null || result === undefined)
+    return "";
+  if (typeof result === "object" && result !== null && "content" in result) {
+    const content = result.content;
+    if (Array.isArray(content)) {
+      const texts = content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+      return texts.length > 500 ? texts.slice(0, 500) + "\u2026" : texts;
+    }
+  }
+  const str = typeof result === "string" ? result : JSON.stringify(result, null, 0);
+  return str.length > 500 ? str.slice(0, 500) + "\u2026" : str;
+}
+
+// src/decisions/index.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+function getDecisionCounterPath(rootPath) {
+  return join(rootPath, ".trellis", "decision-counter.json");
+}
+function nextDecisionId(rootPath) {
+  const counterPath = getDecisionCounterPath(rootPath);
+  let counter = 0;
+  if (existsSync(counterPath)) {
+    try {
+      counter = JSON.parse(readFileSync(counterPath, "utf-8")).counter ?? 0;
+    } catch {}
+  }
+  counter++;
+  const dir = dirname(counterPath);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  writeFileSync(counterPath, JSON.stringify({ counter }, null, 2));
+  return `DEC-${counter}`;
+}
+async function recordDecision(ctx, rootPath, input) {
+  const id = nextDecisionId(rootPath);
+  const op = await createVcsOp("vcs:decisionRecord", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      decisionId: id,
+      decisionToolName: input.toolName,
+      decisionToolInput: input.input ? JSON.stringify(input.input) : undefined,
+      decisionToolOutput: input.outputSummary,
+      decisionContext: input.context,
+      decisionRationale: input.rationale,
+      decisionAlternatives: input.alternatives ? JSON.stringify(input.alternatives) : undefined
+    }
+  });
+  ctx.applyOp(op);
+  if (input.relatedEntities) {
+    const eid = decisionEntityId(id);
+    const links = input.relatedEntities.map((target) => ({
+      e1: eid,
+      a: "relatedTo",
+      e2: target
+    }));
+    if (links.length > 0) {
+      ctx.store.addLinks(links);
+    }
+  }
+  return op;
+}
+function buildDecision(ctx, entityId) {
+  const facts = ctx.store.getFactsByEntity(entityId);
+  const get = (a) => {
+    const matches = facts.filter((f) => f.a === a);
+    return matches.length > 0 ? matches[matches.length - 1].v : undefined;
+  };
+  const links = ctx.store.getLinksByAttribute("relatedTo");
+  const related = links.filter((l) => l.e1 === entityId).map((l) => l.e2);
+  const bareId = entityId.replace(/^decision:/, "");
+  const alternativesRaw = get("alternatives");
+  let alternatives;
+  if (alternativesRaw) {
+    try {
+      alternatives = JSON.parse(alternativesRaw);
+    } catch {
+      alternatives = [alternativesRaw];
+    }
+  }
+  const confidenceRaw = get("confidence");
+  const confidence = confidenceRaw !== undefined ? parseFloat(confidenceRaw) : undefined;
+  return {
+    id: bareId,
+    toolName: get("toolName") ?? "",
+    outputSummary: get("outputSummary"),
+    context: get("context"),
+    rationale: get("rationale"),
+    alternatives,
+    confidence,
+    createdAt: get("createdAt"),
+    createdBy: get("createdBy"),
+    relatedEntities: related
+  };
+}
+function queryDecisions(ctx, filter) {
+  const decisionFacts = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Decision");
+  let decisions = decisionFacts.map((f) => buildDecision(ctx, f.e));
+  if (filter?.toolPattern) {
+    const pattern = filter.toolPattern;
+    const regex = pattern.includes("*") ? new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`) : null;
+    decisions = decisions.filter((d) => regex ? regex.test(d.toolName) : d.toolName === pattern);
+  }
+  if (filter?.agentId) {
+    decisions = decisions.filter((d) => d.createdBy === filter.agentId);
+  }
+  if (filter?.since) {
+    const since = new Date(filter.since).getTime();
+    decisions = decisions.filter((d) => d.createdAt && new Date(d.createdAt).getTime() >= since);
+  }
+  if (filter?.until) {
+    const until = new Date(filter.until).getTime();
+    decisions = decisions.filter((d) => d.createdAt && new Date(d.createdAt).getTime() <= until);
+  }
+  if (filter?.entityId) {
+    decisions = decisions.filter((d) => d.relatedEntities.includes(filter.entityId));
+  }
+  decisions.sort((a, b) => {
+    if (!a.createdAt || !b.createdAt)
+      return 0;
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  });
+  if (filter?.limit && filter.limit > 0) {
+    decisions = decisions.slice(0, filter.limit);
+  }
+  return decisions;
+}
+function getDecisionChain(ctx, entityId) {
+  const allLinks = ctx.store.getLinksByAttribute("relatedTo");
+  const decisionEids = new Set(allLinks.filter((l) => l.e2 === entityId).map((l) => l.e1).filter((e) => e.startsWith("decision:")));
+  const decisions = Array.from(decisionEids).map((eid) => buildDecision(ctx, eid));
+  decisions.sort((a, b) => {
+    if (!a.createdAt || !b.createdAt)
+      return 0;
+    return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+  });
+  return decisions;
+}
+function getDecision(ctx, id) {
+  const eid = decisionEntityId(id);
+  const typeFact = ctx.store.getFactsByEntity(eid).find((f) => f.a === "type" && f.v === "Decision");
+  if (!typeFact)
+    return null;
+  return buildDecision(ctx, eid);
+}
+
+export { HookRegistry, wrapToolHandler, recordDecision, queryDecisions, getDecisionChain, getDecision };

package/dist/index-a76rekgs.js

@@ -0,0 +1,67 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+export { __toESM, __toCommonJS, __commonJS, __export, __esm, __require };