trellis 3.2.0 → 3.2.2

package/dist/chunk-VWKLKLYB.js

@@ -1,267 +0,0 @@
-import {
-  __require
-} from "./chunk-2ESYSVXG.js";
-
-// src/core/persist/sqljs-backend.ts
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS ops (
-  hash TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  timestamp TEXT NOT NULL,
-  agent_id TEXT NOT NULL,
-  previous_hash TEXT,
-  payload TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS snapshots (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  last_op_hash TEXT NOT NULL,
-  data TEXT NOT NULL,
-  created_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-CREATE TABLE IF NOT EXISTS blobs (
-  hash TEXT PRIMARY KEY,
-  content BLOB NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_ops_kind ON ops(kind);
-CREATE INDEX IF NOT EXISTS idx_ops_timestamp ON ops(timestamp);
-CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
-CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
-CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
-`;
-var SqlJsKernelBackend = class _SqlJsKernelBackend {
-  constructor(opts) {
-    this.opts = opts;
-    this.flushEvery = opts.autoFlushEvery ?? 50;
-  }
-  db;
-  stmts;
-  writes = 0;
-  flushEvery;
-  initialized = false;
-  /**
-   * Async factory — sql.js WASM init is async, but the resulting backend
-   * exposes the synchronous KernelBackend surface, so it slots into the
-   * existing kernel without interface changes.
-   */
-  static async create(opts) {
-    const backend = new _SqlJsKernelBackend(opts);
-    await backend.bootstrap();
-    return backend;
-  }
-  async bootstrap() {
-    let initSqlJs;
-    try {
-      const mod = await import("sql.js");
-      initSqlJs = mod.default ?? mod;
-    } catch (e) {
-      throw new Error(
-        'SqlJsKernelBackend requires the optional dependency "sql.js". Install it: npm install sql.js'
-      );
-    }
-    let sqljsDistDir = null;
-    if (typeof window === "undefined") {
-      try {
-        const moduleMod = await import("module");
-        const pathMod = await import("path");
-        const req = moduleMod.createRequire(import.meta.url);
-        const sqlJsEntry = req.resolve("sql.js");
-        sqljsDistDir = pathMod.dirname(sqlJsEntry);
-      } catch {
-        sqljsDistDir = null;
-      }
-    }
-    const SQL = await initSqlJs({
-      locateFile: (file) => {
-        if (typeof window !== "undefined") return `/sql-wasm/${file}`;
-        if (sqljsDistDir) return `${sqljsDistDir}/${file}`;
-        return file;
-      }
-    });
-    const existing = this.loadFromDisk();
-    this.db = existing ? new SQL.Database(existing) : new SQL.Database();
-  }
-  loadFromDisk() {
-    if (this.opts.dbPath === ":memory:") return null;
-    try {
-      const fs = __require("fs");
-      if (!fs.existsSync(this.opts.dbPath)) return null;
-      return new Uint8Array(fs.readFileSync(this.opts.dbPath));
-    } catch {
-      return null;
-    }
-  }
-  flushToDisk() {
-    if (this.opts.dbPath === ":memory:") return;
-    try {
-      const fs = __require("fs");
-      const path = __require("path");
-      const data = this.db.export();
-      fs.mkdirSync(path.dirname(this.opts.dbPath), { recursive: true });
-      const tmp = `${this.opts.dbPath}.tmp`;
-      fs.writeFileSync(tmp, Buffer.from(data));
-      fs.renameSync(tmp, this.opts.dbPath);
-    } catch {
-    }
-  }
-  init() {
-    if (this.initialized) return;
-    this.db.exec(SCHEMA_SQL);
-    this.prepareStatements();
-    this.initialized = true;
-  }
-  prepareStatements() {
-    this.stmts = {
-      insert: this.db.prepare(
-        `INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
-         VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)`
-      ),
-      readAll: this.db.prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops ORDER BY rowid ASC`
-      ),
-      readUntil: this.db.prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE rowid <= (SELECT rowid FROM ops WHERE hash = $hash)
-         ORDER BY rowid ASC`
-      ),
-      readAfter: this.db.prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE rowid > (SELECT rowid FROM ops WHERE hash = $hash)
-         ORDER BY rowid ASC`
-      ),
-      getByHash: this.db.prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE hash = $hash`
-      ),
-      getLast: this.db.prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops ORDER BY rowid DESC LIMIT 1`
-      ),
-      count: this.db.prepare(`SELECT COUNT(*) AS cnt FROM ops`),
-      saveSnapshot: this.db.prepare(
-        `INSERT INTO snapshots (last_op_hash, data) VALUES ($lastOpHash, $data)`
-      ),
-      loadSnapshot: this.db.prepare(
-        `SELECT last_op_hash, data FROM snapshots ORDER BY id DESC LIMIT 1`
-      )
-    };
-  }
-  append(op) {
-    const payload = JSON.stringify({
-      facts: op.facts,
-      links: op.links,
-      ...op.deleteFacts?.length ? { deleteFacts: op.deleteFacts } : {},
-      ...op.deleteLinks?.length ? { deleteLinks: op.deleteLinks } : {},
-      ...op.vcs ? { vcs: op.vcs } : {},
-      ...op.signature ? { signature: op.signature } : {}
-    });
-    this.stmts.insert.run({
-      $hash: op.hash,
-      $kind: op.kind,
-      $timestamp: op.timestamp,
-      $agentId: op.agentId,
-      $previousHash: op.previousHash ?? null,
-      $payload: payload
-    });
-    this.stmts.insert.reset();
-    this.tickFlush();
-  }
-  readAll() {
-    return this.runAll(this.stmts.readAll);
-  }
-  readUntil(hash) {
-    return this.runAll(this.stmts.readUntil, { $hash: hash });
-  }
-  readAfter(hash) {
-    return this.runAll(this.stmts.readAfter, { $hash: hash });
-  }
-  readUntilTimestamp(iso) {
-    const stmt = this.db.prepare(
-      `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-       FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`
-    );
-    const rows = this.runAll(stmt, { $ts: iso });
-    stmt.free();
-    return rows;
-  }
-  getByHash(hash) {
-    return this.runOne(this.stmts.getByHash, { $hash: hash });
-  }
-  getLastOp() {
-    return this.runOne(this.stmts.getLast);
-  }
-  getOpCount() {
-    this.stmts.count.bind({});
-    const has = this.stmts.count.step();
-    const row = has ? this.stmts.count.getAsObject() : { cnt: 0 };
-    this.stmts.count.reset();
-    return Number(row.cnt ?? 0);
-  }
-  saveSnapshot(lastOpHash, data) {
-    this.stmts.saveSnapshot.run({
-      $lastOpHash: lastOpHash,
-      $data: typeof data === "string" ? data : JSON.stringify(data)
-    });
-    this.stmts.saveSnapshot.reset();
-    this.tickFlush();
-  }
-  loadLatestSnapshot() {
-    this.stmts.loadSnapshot.bind({});
-    const has = this.stmts.loadSnapshot.step();
-    if (!has) {
-      this.stmts.loadSnapshot.reset();
-      return void 0;
-    }
-    const row = this.stmts.loadSnapshot.getAsObject();
-    this.stmts.loadSnapshot.reset();
-    return { lastOpHash: row.last_op_hash, data: row.data };
-  }
-  close() {
-    try {
-      this.flushToDisk();
-    } finally {
-      for (const s of Object.values(this.stmts ?? {})) s?.free?.();
-      this.db?.close?.();
-    }
-  }
-  /** Force a write of the in-memory DB image to disk. */
-  flush() {
-    this.flushToDisk();
-  }
-  runAll(stmt, params = {}) {
-    stmt.bind(params);
-    const rows = [];
-    while (stmt.step()) rows.push(rowToOp(stmt.getAsObject()));
-    stmt.reset();
-    return rows;
-  }
-  runOne(stmt, params = {}) {
-    stmt.bind(params);
-    const has = stmt.step();
-    const row = has ? stmt.getAsObject() : void 0;
-    stmt.reset();
-    return row ? rowToOp(row) : void 0;
-  }
-  tickFlush() {
-    if (this.flushEvery === 0) return;
-    if (++this.writes % this.flushEvery === 0) this.flushToDisk();
-  }
-};
-function rowToOp(row) {
-  const payload = JSON.parse(row.payload);
-  return {
-    hash: row.hash,
-    kind: row.kind,
-    timestamp: row.timestamp,
-    agentId: row.agent_id,
-    previousHash: row.previous_hash ?? void 0,
-    facts: payload.facts,
-    links: payload.links,
-    deleteFacts: payload.deleteFacts,
-    deleteLinks: payload.deleteLinks
-  };
-}
-
-export {
-  SqlJsKernelBackend
-};

package/dist/chunk-VYC3RZMK.js

@@ -1,277 +0,0 @@
-// 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/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)) {
-        for (const binding of result.bindings) {
-          enrichBinding(binding, config, ctx);
-        }
-      }
-      return result;
-    }
-  };
-}
-function enrichBinding(binding, config, ctx) {
-  const row = binding;
-  const type = resolveEntityType(binding, config);
-  if (!type) return;
-  const schema = config.ontologies.get(type);
-  if (!schema) return;
-  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) {
-      binding[fieldName] = "";
-    }
-    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);
-    if (schema.label) map.set(schema.label, schema);
-  }
-  return map;
-}
-function attachStandardMiddleware(kernel) {
-  kernel.removeMiddleware("logic-computation");
-  const ontologies = buildOntologyIndex(kernel.listOntologies());
-  kernel.addMiddleware(
-    createLogicMiddleware({
-      ontologies,
-      getEntityType: (entityId) => kernel.getEntity(entityId)?.type
-    })
-  );
-}
-
-export {
-  ExprEvaluator,
-  evalExpr,
-  createLogicMiddleware,
-  buildOntologyIndex,
-  attachStandardMiddleware
-};

package/dist/chunk-WMERMSWI.js

@@ -1,154 +0,0 @@
-import {
-  init_eav_store,
-  jsonEntityFacts
-} from "./chunk-G3XIHPSQ.js";
-
-// src/server/import.ts
-init_eav_store();
-import { readFileSync } from "fs";
-import { extname } from "path";
-async function importFile(kernel, filePath, opts) {
-  const ext = extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".json":
-      return importJson(kernel, filePath, opts);
-    case ".ndjson":
-    case ".jsonl":
-      return importNdjson(kernel, filePath, opts);
-    case ".csv":
-    case ".tsv":
-      return importCsv(kernel, filePath, opts);
-    case ".parquet":
-      return importParquet(kernel, filePath, opts);
-    default:
-      throw new Error(
-        `Unsupported file format: ${ext}. Supported: .json, .ndjson, .jsonl, .csv, .tsv, .parquet`
-      );
-  }
-}
-async function importRecords(kernel, records, opts) {
-  return _ingestRows(kernel, records, opts);
-}
-async function importJson(kernel, filePath, opts) {
-  const raw = readFileSync(filePath, "utf8");
-  const parsed = JSON.parse(raw);
-  const rows = Array.isArray(parsed) ? parsed : [parsed];
-  return _ingestRows(kernel, rows, opts);
-}
-async function importNdjson(kernel, filePath, opts) {
-  const raw = readFileSync(filePath, "utf8");
-  const rows = raw.split("\n").map((l) => l.trim()).filter(Boolean).map((line, i) => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
-  return _ingestRows(kernel, rows, opts);
-}
-async function importCsv(kernel, filePath, opts) {
-  const raw = readFileSync(filePath, "utf8");
-  const sep = filePath.endsWith(".tsv") ? "	" : ",";
-  const rows = parseCsv(raw, sep);
-  return _ingestRows(kernel, rows, opts);
-}
-function parseCsv(raw, sep = ",") {
-  const lines = raw.split(/\r?\n/);
-  if (lines.length < 2) return [];
-  const headers = splitCsvLine(lines[0], sep);
-  const result = [];
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line || line.trim() === "") continue;
-    const values = splitCsvLine(line, sep);
-    const row = {};
-    headers.forEach((h, idx) => {
-      row[h] = values[idx] ?? "";
-    });
-    result.push(row);
-  }
-  return result;
-}
-function splitCsvLine(line, sep) {
-  const result = [];
-  let current = "";
-  let inQuotes = false;
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if (ch === '"') {
-      if (inQuotes && line[i + 1] === '"') {
-        current += '"';
-        i++;
-      } else {
-        inQuotes = !inQuotes;
-      }
-    } else if (ch === sep && !inQuotes) {
-      result.push(current);
-      current = "";
-    } else {
-      current += ch;
-    }
-  }
-  result.push(current);
-  return result;
-}
-async function importParquet(kernel, filePath, opts) {
-  let parquet;
-  try {
-    parquet = await import("parquetjs");
-  } catch {
-    try {
-      parquet = await import("@dsnp/parquetjs");
-    } catch {
-      throw new Error(
-        "Parquet support requires `parquetjs` or `@dsnp/parquetjs`.\nRun: bun add parquetjs"
-      );
-    }
-  }
-  const reader = await parquet.ParquetReader.openFile(filePath);
-  const cursor = reader.getCursor();
-  const rows = [];
-  let row;
-  while ((row = await cursor.next()) !== null) {
-    rows.push(row);
-  }
-  await reader.close();
-  return _ingestRows(kernel, rows, opts);
-}
-async function _ingestRows(kernel, rows, opts) {
-  const result = {
-    imported: 0,
-    skipped: 0,
-    errors: [],
-    entityIds: []
-  };
-  const limit = opts.limit ?? Infinity;
-  let count = 0;
-  for (let i = 0; i < rows.length; i++) {
-    if (count >= limit) break;
-    const row = rows[i];
-    if (!row || opts.skipEmpty && Object.keys(row).length === 0) {
-      result.skipped++;
-      continue;
-    }
-    try {
-      const entityId = opts.idField ? `${opts.idPrefix ?? "import:"}${String(row[opts.idField] ?? "")}` : `${opts.idPrefix ?? "import:"}${crypto.randomUUID()}`;
-      const facts = jsonEntityFacts(entityId, row, opts.type);
-      await kernel.mutate("addFacts", { facts });
-      result.imported++;
-      result.entityIds.push(entityId);
-      count++;
-    } catch (err) {
-      result.errors.push({
-        row: i,
-        message: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return result;
-}
-
-export {
-  importFile,
-  importRecords
-};