trellis 3.1.35 → 3.2.0

package/dist/chunk-STLN6A6B.js

@@ -0,0 +1,355 @@
+import {
+  createVcsOp,
+  decisionEntityId,
+  init_ops,
+  init_types
+} from "./chunk-NO73OK2I.js";
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/decisions/hooks.ts
+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);
+}
+var HookRegistry;
+var init_hooks = __esm({
+  "src/decisions/hooks.ts"() {
+    "use strict";
+    HookRegistry = class {
+      preHooks = [];
+      postHooks = [];
+      /**
+       * Register a pre-hook that runs before a tool handler.
+       */
+      registerPreHook(hook) {
+        this.preHooks.push(hook);
+      }
+      /**
+       * Register a post-hook that runs after a tool handler.
+       */
+      registerPostHook(hook) {
+        this.postHooks.push(hook);
+      }
+      /**
+       * Remove a pre-hook by name.
+       */
+      removePreHook(name) {
+        this.preHooks = this.preHooks.filter((h) => h.name !== name);
+      }
+      /**
+       * Remove a post-hook by name.
+       */
+      removePostHook(name) {
+        this.postHooks = this.postHooks.filter((h) => h.name !== name);
+      }
+      /**
+       * Get all pre-hooks matching a tool name.
+       */
+      getPreHooks(toolName) {
+        return this.preHooks.filter((h) => matchesPattern(h.toolPattern, toolName));
+      }
+      /**
+       * Get all post-hooks matching a tool name.
+       */
+      getPostHooks(toolName) {
+        return this.postHooks.filter(
+          (h) => matchesPattern(h.toolPattern, toolName)
+        );
+      }
+      /**
+       * Run all matching pre-hooks and merge their contexts.
+       */
+      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;
+      }
+      /**
+       * Run all matching post-hooks and merge their enrichments.
+       */
+      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 !== void 0)
+              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 all hooks.
+       */
+      clear() {
+        this.preHooks = [];
+        this.postHooks = [];
+      }
+    };
+  }
+});
+
+// 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 > 2e3) {
+      sanitized[key] = value.slice(0, 2e3) + "\u2026";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function summarize(result) {
+  if (result === null || result === void 0) 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("\n");
+      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;
+}
+var init_auto_capture = __esm({
+  "src/decisions/auto-capture.ts"() {
+    "use strict";
+  }
+});
+
+// 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) : void 0,
+      decisionToolOutput: input.outputSummary,
+      decisionContext: input.context,
+      decisionRationale: input.rationale,
+      decisionAlternatives: input.alternatives ? JSON.stringify(input.alternatives) : void 0
+    }
+  });
+  await 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 : void 0;
+  };
+  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 !== void 0 ? parseFloat(confidenceRaw) : void 0;
+  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);
+}
+var init_decisions = __esm({
+  "src/decisions/index.ts"() {
+    init_hooks();
+    init_auto_capture();
+    init_ops();
+    init_types();
+  }
+});
+
+export {
+  HookRegistry,
+  wrapToolHandler,
+  recordDecision,
+  queryDecisions,
+  getDecisionChain,
+  getDecision,
+  init_decisions
+};

package/dist/chunk-TCKXSOBP.js

@@ -0,0 +1,123 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/server/node-adapter.ts
+async function startNodeServer(opts) {
+  const http = await import("http");
+  const httpServer = http.createServer(
+    async (req, res) => {
+      try {
+        const fetchReq = await toFetchRequest(req);
+        const fetchRes = await opts.fetch(fetchReq);
+        await writeFetchResponse(res, fetchRes);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Internal Server Error", message: msg }));
+      }
+    }
+  );
+  let wss = null;
+  try {
+    const { WebSocketServer } = await import("ws");
+    wss = new WebSocketServer({ noServer: true });
+    httpServer.on("upgrade", (req, socket, head) => {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    });
+    wss.on("connection", (ws) => {
+      Promise.resolve(opts.websocket.open(ws)).catch(() => {
+      });
+      ws.on("message", (raw) => {
+        const data = Array.isArray(raw) ? Buffer.concat(raw).toString() : raw instanceof ArrayBuffer ? Buffer.from(raw).toString() : raw.toString();
+        Promise.resolve(opts.websocket.message(ws, data)).catch(() => {
+        });
+      });
+      ws.on("close", () => opts.websocket.close(ws));
+    });
+  } catch {
+    httpServer.on("upgrade", (_req, socket) => {
+      socket.destroy();
+    });
+  }
+  await new Promise(
+    (resolve) => httpServer.listen(opts.port, opts.hostname, resolve)
+  );
+  const addr = httpServer.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  const boundHost = typeof addr === "object" && addr ? addr.address : opts.hostname;
+  return wrapNodeServer(httpServer, wss, boundPort, boundHost);
+}
+async function toFetchRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const method = req.method ?? "GET";
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else if (value != null) {
+      headers.set(key, value);
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? new Uint8Array(await readBody(req)) : void 0;
+  return new Request(url, { method, headers, body });
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function writeFetchResponse(res, fetchRes) {
+  res.statusCode = fetchRes.status;
+  fetchRes.headers.forEach((value, key) => res.setHeader(key, value));
+  if (!fetchRes.body) {
+    res.end();
+    return;
+  }
+  const reader = fetchRes.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(value);
+  }
+  res.end();
+}
+function wrapNodeServer(httpServer, wss, port, hostname) {
+  return {
+    port,
+    hostname: hostname ?? "localhost",
+    stop(closeActiveConnections) {
+      return new Promise((resolve, reject) => {
+        const closeHttp = () => {
+          httpServer.close((err) => err ? reject(err) : resolve());
+        };
+        if (!wss) {
+          closeHttp();
+          return;
+        }
+        if (closeActiveConnections) {
+          for (const client of wss.clients) client.terminate();
+        }
+        wss.close(() => closeHttp());
+      });
+    }
+  };
+}
+var init_node_adapter = __esm({
+  "src/server/node-adapter.ts"() {
+  }
+});
+
+export {
+  startNodeServer,
+  init_node_adapter
+};

package/dist/chunk-U7HV7GU2.js

@@ -0,0 +1,17 @@
+// src/schema/eql.ts
+function escapeValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function entitiesQuery(type, where) {
+  const conds = [`type = "${escapeValue(type)}"`];
+  for (const [k, v] of Object.entries(where ?? {})) {
+    if (v === void 0 || v === null) continue;
+    conds.push(`${k} = "${escapeValue(String(v))}"`);
+  }
+  return `find ?e where ${conds.join(" and ")}`;
+}
+
+export {
+  escapeValue,
+  entitiesQuery
+};

package/dist/chunk-UBGUDMUV.js

@@ -0,0 +1,59 @@
+// src/client/reactive.ts
+var Signal = class {
+  _value;
+  _subs = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (Object.is(this._value, v)) return;
+    this._value = v;
+    for (const fn of this._subs) {
+      try {
+        fn(v);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to changes. Immediately called with current value. */
+  subscribe(fn) {
+    this._subs.add(fn);
+    try {
+      fn(this._value);
+    } catch {
+    }
+    return () => {
+      this._subs.delete(fn);
+    };
+  }
+  /** Read without tracking. */
+  peek() {
+    return this._value;
+  }
+  /** Whether any subscriber is registered. */
+  hasSubscribers() {
+    return this._subs.size > 0;
+  }
+};
+var BatchSignal = class extends Signal {
+  _raf = null;
+  constructor(initial) {
+    super(initial);
+  }
+  set value(v) {
+    if (Object.is(this.peek(), v)) return;
+    if (this._raf !== null) cancelAnimationFrame(this._raf);
+    this._raf = requestAnimationFrame(() => {
+      this._raf = null;
+      super.value = v;
+    });
+  }
+};
+
+export {
+  Signal,
+  BatchSignal
+};

package/dist/chunk-UGZHOGRA.js

@@ -0,0 +1,39 @@
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/live.ts
+function liveQuery(client, eql) {
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(eql, (rows) => {
+          signal.value = { data: rows, loading: false, error: null };
+        });
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+
+export {
+  liveQuery
+};