trellis 3.1.35 → 3.2.2

package/dist/{index-w5wccer3.js → chunk-S6GBJ2ZB.js}

@@ -1,11 +1,10 @@
-// @bun
 import {
   inferProjectContext,
   init_infer,
   init_profile,
   init_write,
   loadProfile
-} from "./index-rv1p47gp.js";
+} from "./chunk-L5N5PR2S.js";
 
 // src/scaffold/seed.ts
 init_profile();
@@ -15,7 +14,7 @@ import { join } from "path";
 async function seedContext(opts) {
   const { rootPath, ide = "none", force = false } = opts;
   const filesUpdated = [];
-  const timestamp = new Date().toISOString();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const profile = loadProfile();
   const context = await inferProjectContext(rootPath);
   const agentsDir = join(rootPath, ".trellis", "agents");
@@ -45,25 +44,40 @@ async function seedContext(opts) {
     case "cursor": {
       const cursorRulesPath = join(rootPath, ".cursor", "rules.md");
       if (existsSync(cursorRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "cursor", timestamp);
+        const content = renderSeedIdeRules(
+          profile,
+          context,
+          "cursor",
+          timestamp
+        );
         writeFileSync(cursorRulesPath, content, "utf-8");
         filesUpdated.push(".cursor/rules.md");
       }
       break;
     }
-    case "windsurf": {
-      const windsurfRulesPath = join(rootPath, ".windsurf", "rules.md");
-      if (existsSync(windsurfRulesPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "windsurf", timestamp);
-        writeFileSync(windsurfRulesPath, content, "utf-8");
-        filesUpdated.push(".windsurf/rules.md");
+    case "devin": {
+      const devinRulesPath = join(rootPath, ".devin", "rules.md");
+      if (existsSync(devinRulesPath) || force) {
+        const content = renderSeedIdeRules(
+          profile,
+          context,
+          "devin",
+          timestamp
+        );
+        writeFileSync(devinRulesPath, content, "utf-8");
+        filesUpdated.push(".devin/rules.md");
       }
       break;
     }
     case "claude": {
       const claudeSettingsPath = join(rootPath, ".claude", "settings.md");
       if (existsSync(claudeSettingsPath) || force) {
-        const content = renderSeedIdeRules(profile, context, "claude", timestamp);
+        const content = renderSeedIdeRules(
+          profile,
+          context,
+          "claude",
+          timestamp
+        );
         writeFileSync(claudeSettingsPath, content, "utf-8");
         filesUpdated.push(".claude/settings.md");
       }
@@ -163,4 +177,6 @@ init_infer();
 init_profile();
 init_write();
 
-export { seedContext };
+export {
+  seedContext
+};

package/dist/{index-7pjz3tsy.js → chunk-SGMDTWJJ.js}

@@ -1,22 +1,20 @@
-// @bun
 import {
-  TrellisKernel
-} from "./index-4wxa8xz4.js";
+  attachStandardMiddleware
+} from "./chunk-SPSPV5BC.js";
 import {
   SqliteKernelBackend
-} from "./index-h7zxhhhh.js";
+} from "./chunk-XMQ7G77X.js";
 import {
-  __require
-} from "./index-a76rekgs.js";
+  TrellisKernel
+} from "./chunk-KQ4A2D2P.js";
 
 // src/server/tenancy.ts
 import { existsSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
 var DEFAULT_TENANT = "default";
 var TENANTS_DIR = "tenants";
-
-class TenantPool {
-  pool = new Map;
+var TenantPool = class {
+  pool = /* @__PURE__ */ new Map();
   dbPath;
   agentId;
   backendOpts;
@@ -24,13 +22,24 @@ class TenantPool {
     this.dbPath = resolve(dbPath);
     if (typeof agentIdOrOpts === "string") {
       this.agentId = agentIdOrOpts;
-      this.backendOpts = undefined;
+      this.backendOpts = void 0;
     } else {
       this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
       this.backendOpts = agentIdOrOpts.backend;
     }
     this._ensureDirs();
   }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Get (or create) the kernel for a tenant.
+   * Pass `null` or `undefined` to get the default tenant.
+   *
+   * Uses the synchronous bun:sqlite backend. To use an async backend
+   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
+   * `get()` calls will return the preloaded kernel from the pool.
+   */
   get(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     if (!this.pool.has(id)) {
@@ -38,21 +47,37 @@ class TenantPool {
     }
     return this.pool.get(id);
   }
+  /**
+   * Pre-create a tenant's kernel using the runtime-selected backend.
+   * Required when running with an async-only backend (sql.js / WebContainer
+   * / browser). Idempotent — safe to call multiple times.
+   *
+   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
+   * synchronously from the pool.
+   */
   async preload(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     const cached = this.pool.get(id);
-    if (cached)
-      return cached;
+    if (cached) return cached;
     const kernel = await this._createKernelAsync(id);
     this.pool.set(id, kernel);
     return kernel;
   }
+  /**
+   * Check whether a tenant has been initialized (kernel created).
+   */
   has(tenantId) {
     return this.pool.has(tenantId);
   }
+  /**
+   * List all active tenant IDs (those with open kernels).
+   */
   activeTenants() {
     return Array.from(this.pool.keys());
   }
+  /**
+   * Close a specific tenant's kernel and remove it from the pool.
+   */
   close(tenantId) {
     const kernel = this.pool.get(tenantId);
     if (kernel) {
@@ -60,12 +85,22 @@ class TenantPool {
       this.pool.delete(tenantId);
     }
   }
+  /**
+   * Close all kernels and clear the pool.
+   */
   closeAll() {
     for (const kernel of this.pool.values()) {
       kernel.close();
     }
     this.pool.clear();
   }
+  /** Absolute path to the tenant data directory. */
+  dataPath() {
+    return this.dbPath;
+  }
+  /**
+   * Return the SQLite file path for a given tenant.
+   */
   dbFilePath(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     if (id === DEFAULT_TENANT) {
@@ -73,6 +108,9 @@ class TenantPool {
     }
     return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
   }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
   _createKernelSync(tenantId) {
     const sqlitePath = this.dbFilePath(tenantId);
     const backend = new SqliteKernelBackend(sqlitePath);
@@ -88,9 +126,10 @@ class TenantPool {
     const kernel = new TrellisKernel({
       backend,
       agentId: this.agentId,
-      snapshotThreshold: 1000
+      snapshotThreshold: 1e3
     });
     kernel.boot();
+    attachStandardMiddleware(kernel);
     return kernel;
   }
   _ensureDirs() {
@@ -102,6 +141,9 @@ class TenantPool {
       mkdirSync(tenantsPath, { recursive: true });
     }
   }
-}
+};
 
-export { DEFAULT_TENANT, TenantPool };
+export {
+  DEFAULT_TENANT,
+  TenantPool
+};

package/dist/chunk-SPSPV5BC.js

@@ -0,0 +1,390 @@
+// src/core/computation/expr-evaluator.ts
+var ExprEvaluator = class {
+  functions;
+  constructor() {
+    this.functions = /* @__PURE__ */ new Map([
+      ["$if", this.if.bind(this)],
+      ["$round", this.round.bind(this)],
+      ["$concat", this.concat.bind(this)],
+      ["$len", this.len.bind(this)],
+      ["$lower", this.lower.bind(this)],
+      ["$upper", this.upper.bind(this)],
+      ["$trim", this.trim.bind(this)],
+      ["$now", this.now.bind(this)],
+      ["$uuid", this.uuid.bind(this)],
+      ["$add", this.add.bind(this)],
+      ["$sub", this.sub.bind(this)],
+      ["$mul", this.mul.bind(this)],
+      ["$div", this.div.bind(this)],
+      ["$mod", this.mod.bind(this)],
+      ["$eq", this.eq.bind(this)],
+      ["$ne", this.ne.bind(this)],
+      ["$gt", this.gt.bind(this)],
+      ["$gte", this.gte.bind(this)],
+      ["$lt", this.lt.bind(this)],
+      ["$lte", this.lte.bind(this)],
+      ["$and", this.and.bind(this)],
+      ["$or", this.or.bind(this)],
+      ["$not", this.not.bind(this)],
+      ["$coalesce", this.coalesce.bind(this)],
+      ["$contains", this.contains.bind(this)],
+      ["$startsWith", this.startsWith.bind(this)],
+      ["$endsWith", this.endsWith.bind(this)]
+    ]);
+  }
+  /**
+   * Evaluate an expression string against a context.
+   */
+  eval(expr, context) {
+    const trimmed = expr.trim();
+    const fnMatch = trimmed.match(/^(\$\w+)\((.*)\)$/s);
+    if (fnMatch) {
+      const fnName = fnMatch[1];
+      const argsStr = fnMatch[2];
+      const fn = this.functions.get(fnName);
+      if (!fn) {
+        throw new Error(`Unknown function: ${fnName}`);
+      }
+      return this.evalFunction(fn, argsStr, context);
+    }
+    if (trimmed.startsWith("$")) {
+      const field = trimmed.slice(1);
+      return context[field];
+    }
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "null") return null;
+    const num = Number(trimmed);
+    if (!isNaN(num) && trimmed !== "") return num;
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    return trimmed;
+  }
+  evalFunction(fn, argsStr, context) {
+    const args = this.parseArgs(argsStr, context);
+    return fn(...args);
+  }
+  parseArgs(argsStr, context) {
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < argsStr.length; i++) {
+      const char = argsStr[i];
+      if (char === "(" || char === "[" || char === "{") depth++;
+      else if (char === ")" || char === "]" || char === "}") depth--;
+      else if (char === "," && depth === 0) {
+        args.push(this.eval(current.trim(), context));
+        current = "";
+        continue;
+      }
+      current += char;
+    }
+    if (current.trim()) {
+      args.push(this.eval(current.trim(), context));
+    }
+    return args;
+  }
+  // Built-in functions
+  if(cond, trueVal, falseVal) {
+    return cond ? trueVal : falseVal;
+  }
+  round(value, decimals = 0) {
+    const n = Number(value);
+    const factor = Math.pow(10, Number(decimals));
+    return Math.round(n * factor) / factor;
+  }
+  concat(...args) {
+    return args.map((a) => String(a ?? "")).join("");
+  }
+  len(value) {
+    if (typeof value === "string") return value.length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  lower(value) {
+    return String(value ?? "").toLowerCase();
+  }
+  upper(value) {
+    return String(value ?? "").toUpperCase();
+  }
+  trim(value) {
+    return String(value ?? "").trim();
+  }
+  now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  uuid() {
+    return crypto.randomUUID();
+  }
+  add(...args) {
+    return args.reduce((sum, a) => sum + Number(a), 0);
+  }
+  sub(a, b) {
+    return Number(a) - Number(b);
+  }
+  mul(...args) {
+    return args.reduce((prod, a) => prod * Number(a), 1);
+  }
+  div(a, b) {
+    return Number(a) / Number(b);
+  }
+  mod(a, b) {
+    return Number(a) % Number(b);
+  }
+  eq(a, b) {
+    return a === b;
+  }
+  ne(a, b) {
+    return a !== b;
+  }
+  gt(a, b) {
+    return Number(a) > Number(b);
+  }
+  gte(a, b) {
+    return Number(a) >= Number(b);
+  }
+  lt(a, b) {
+    return Number(a) < Number(b);
+  }
+  lte(a, b) {
+    return Number(a) <= Number(b);
+  }
+  and(...args) {
+    return args.every(Boolean);
+  }
+  or(...args) {
+    return args.some(Boolean);
+  }
+  not(value) {
+    return !value;
+  }
+  coalesce(...args) {
+    for (const arg of args) {
+      if (arg !== null && arg !== void 0) return arg;
+    }
+    return null;
+  }
+  contains(haystack, needle) {
+    return String(haystack ?? "").includes(String(needle ?? ""));
+  }
+  startsWith(str, prefix) {
+    return String(str ?? "").startsWith(String(prefix ?? ""));
+  }
+  endsWith(str, suffix) {
+    return String(str ?? "").endsWith(String(suffix ?? ""));
+  }
+};
+function evalExpr(expr, context) {
+  const result = new ExprEvaluator().eval(expr, context);
+  if (result === null || result === void 0) return "";
+  if (typeof result === "boolean") return result ? "true" : "false";
+  if (typeof result === "number") return result;
+  if (typeof result === "string") return result;
+  if (typeof result === "object") return JSON.stringify(result);
+  return String(result);
+}
+
+// src/core/computation/rollup.ts
+function collectRollupRelatedIds(rollup, ctx) {
+  if (rollup.joinEntity) {
+    const { type, foreignKey } = rollup.joinEntity;
+    const facts = ctx.store.getFactsByAttribute(foreignKey);
+    const ids = [];
+    for (const fact of facts) {
+      if (fact.v !== ctx.entityId) continue;
+      const typeFacts = ctx.store.getFactsByEntity(fact.e);
+      const entityType = typeFacts.find((f) => f.a === "type")?.v;
+      if (entityType === type) ids.push(fact.e);
+    }
+    return ids;
+  }
+  const linkAttr = resolveLinkAttribute(rollup.relationProperty, ctx.schema);
+  const links = ctx.store.getLinksByEntityAndAttribute(ctx.entityId, linkAttr);
+  if (links.length > 0) return links.map((l) => l.e2);
+  return [];
+}
+function resolveLinkAttribute(relationProperty, schema) {
+  const field = schema?.fields.find((f) => f.name === relationProperty);
+  if (field?.valueType === "relation") return relationProperty;
+  return relationProperty;
+}
+function readTargetValue(store, entityId, targetProperty) {
+  if (targetProperty === "id") return entityId;
+  const facts = store.getFactsByEntity(entityId);
+  return facts.find((f) => f.a === targetProperty)?.v;
+}
+function toNumbers(values) {
+  const nums = [];
+  for (const v of values) {
+    if (typeof v === "number" && Number.isFinite(v)) nums.push(v);
+  }
+  return nums;
+}
+function evaluateRollup(rollup, ctx) {
+  const related = collectRollupRelatedIds(rollup, ctx);
+  if (rollup.aggregation === "count") {
+    return related.length;
+  }
+  const values = related.map((id) => readTargetValue(ctx.store, id, rollup.targetProperty)).filter((v) => v !== void 0);
+  const nums = toNumbers(values);
+  if (nums.length === 0) return 0;
+  switch (rollup.aggregation) {
+    case "sum":
+      return nums.reduce((a, b) => a + b, 0);
+    case "avg":
+      return nums.reduce((a, b) => a + b, 0) / nums.length;
+    case "min":
+      return Math.min(...nums);
+    case "max":
+      return Math.max(...nums);
+    case "median": {
+      const sorted = [...nums].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    }
+    case "mode": {
+      const freq = /* @__PURE__ */ new Map();
+      for (const n of nums) freq.set(n, (freq.get(n) ?? 0) + 1);
+      let best = nums[0];
+      let bestCount = 0;
+      for (const [n, c] of freq) {
+        if (c > bestCount) {
+          best = n;
+          bestCount = c;
+        }
+      }
+      return best;
+    }
+    default:
+      return 0;
+  }
+}
+function projectRelationFields(binding, schema, store, entityId) {
+  for (const field of schema.fields) {
+    if (field.valueType !== "relation" || field.name in binding) continue;
+    const links = store.getLinksByEntityAndAttribute(entityId, field.name);
+    if (links.length === 0) continue;
+    const cardinality = field.relation?.cardinality ?? "many";
+    if (cardinality === "one") {
+      binding[field.name] = links[0].e2;
+    } else {
+      binding[field.name] = links.map((l) => l.e2).join(",");
+    }
+  }
+}
+
+// src/core/kernel/logic-middleware.ts
+function createLogicMiddleware(config) {
+  return {
+    name: "logic-computation",
+    handleQuery(query, ctx, next) {
+      const result = next(query);
+      if (result && Array.isArray(result.bindings)) {
+        const store = resolveStore(config, ctx);
+        for (const binding of result.bindings) {
+          enrichBinding(binding, config, store);
+        }
+      }
+      return result;
+    }
+  };
+}
+function resolveStore(config, ctx) {
+  if (config.getStore) return config.getStore();
+  return ctx.store;
+}
+function enrichBinding(binding, config, store) {
+  const row = binding;
+  const type = resolveEntityType(binding, config);
+  if (!type) return;
+  const schema = config.ontologies.get(type);
+  if (!schema) return;
+  const entityId = findEntityId(binding);
+  if (store && entityId) {
+    projectRelationFields(binding, schema, store, entityId);
+  }
+  for (const field of schema.fields) {
+    if (!(field.computed || field.formula || field.rollup || field.aiGenerated))
+      continue;
+    const fieldName = field.name;
+    if (fieldName in binding) continue;
+    if (field.formula) {
+      binding[fieldName] = evalExpr(field.formula, row);
+    }
+    if (field.rollup && store && entityId) {
+      binding[fieldName] = evaluateRollup(field.rollup, {
+        store,
+        entityId,
+        schema,
+        getEntityType: config.getEntityType
+      });
+    }
+    if (field.aiGenerated && config.generateAiField) {
+      const prompt = field.aiGenerated.prompt.replace(
+        /\{\{(\w+)\}\}/g,
+        (_, key) => String(row[key] ?? "")
+      );
+      config.generateAiField(prompt, row).then((value) => {
+        binding[fieldName] = value;
+      }).catch(() => {
+        binding[fieldName] = "";
+      });
+    }
+  }
+}
+function resolveEntityType(binding, config) {
+  const explicit = binding.type;
+  if (typeof explicit === "string" && explicit.length > 0) return explicit;
+  const entityId = findEntityId(binding);
+  if (entityId && config.getEntityType) {
+    return config.getEntityType(entityId);
+  }
+  return void 0;
+}
+function findEntityId(binding) {
+  for (const value of Object.values(binding)) {
+    if (typeof value === "string" && value.includes(":")) return value;
+  }
+  return void 0;
+}
+
+// src/core/kernel/boot-middleware.ts
+function buildOntologyIndex(schemas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    map.set(schema["@id"], schema);
+    const short = schema["@id"].includes(":") ? schema["@id"].split(":").pop() : schema["@id"];
+    if (short) {
+      map.set(short, schema);
+      map.set(short.toLowerCase(), schema);
+    }
+    if (schema.label) {
+      map.set(schema.label, schema);
+      map.set(schema.label.toLowerCase(), schema);
+    }
+  }
+  return map;
+}
+function attachStandardMiddleware(kernel) {
+  kernel.removeMiddleware("logic-computation");
+  const ontologies = buildOntologyIndex(kernel.listOntologies());
+  kernel.addMiddleware(
+    createLogicMiddleware({
+      ontologies,
+      getStore: () => kernel.getStore(),
+      getEntityType: (entityId) => kernel.getEntity(entityId)?.type
+    })
+  );
+}
+
+export {
+  ExprEvaluator,
+  evalExpr,
+  collectRollupRelatedIds,
+  evaluateRollup,
+  projectRelationFields,
+  createLogicMiddleware,
+  buildOntologyIndex,
+  attachStandardMiddleware
+};