trellis 2.1.7 → 2.1.9

package/dist/index-4beszbgg.js

@@ -0,0 +1,292 @@
+// @bun
+import {
+  readConfig
+} from "./index-xzym9w0m.js";
+import {
+  TenantPool
+} from "./index-5p6zgspx.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/client/sdk.ts
+function isRemote(opts) {
+  return "url" in opts;
+}
+
+class TrellisDb {
+  opts;
+  _pool = null;
+  _ws = null;
+  _subCallbacks = new Map;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  static fromConfig(dir = ".") {
+    const config = readConfig(dir);
+    if (!config)
+      throw new Error("No .trellis-db.json found. Run `trellis db init` first.");
+    if (config.mode === "remote" && config.url) {
+      return new TrellisDb({ url: config.url, apiKey: config.apiKey });
+    }
+    if (config.dbPath) {
+      return new TrellisDb({ path: config.dbPath });
+    }
+    throw new Error("Invalid .trellis-db.json: missing url or dbPath.");
+  }
+  async create(type, attributes = {}, links) {
+    if (isRemote(this.opts)) {
+      const res = await this._fetch("POST", "/entities", {
+        type,
+        attributes,
+        links
+      });
+      return res.id;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entityId = `${type.toLowerCase()}:${crypto.randomUUID()}`;
+    await kernel.createEntity(entityId, type, attributes, links);
+    return entityId;
+  }
+  async read(id) {
+    if (isRemote(this.opts)) {
+      try {
+        return await this._fetch("GET", `/entities/${encodeURIComponent(id)}`);
+      } catch (err) {
+        if (err?.status === 404)
+          return null;
+        throw err;
+      }
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entity = kernel.getEntity(id);
+    if (!entity)
+      return null;
+    return entityToPlain(entity);
+  }
+  async update(id, attributes) {
+    if (isRemote(this.opts)) {
+      await this._fetch("PUT", `/entities/${encodeURIComponent(id)}`, attributes);
+      return;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.updateEntity(id, attributes);
+  }
+  async delete(id) {
+    if (isRemote(this.opts)) {
+      await this._fetch("DELETE", `/entities/${encodeURIComponent(id)}`);
+      return;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.deleteEntity(id);
+  }
+  async list(type, opts = {}) {
+    if (isRemote(this.opts)) {
+      const params = new URLSearchParams;
+      if (type)
+        params.set("type", type);
+      if (opts.limit)
+        params.set("limit", String(opts.limit));
+      if (opts.offset)
+        params.set("offset", String(opts.offset));
+      const qs = params.toString() ? `?${params}` : "";
+      return await this._fetch("GET", `/entities${qs}`);
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entities = kernel.listEntities(type, opts.filters);
+    const limit = opts.limit ?? 100;
+    const offset = opts.offset ?? 0;
+    const page = entities.slice(offset, offset + limit);
+    return {
+      data: page.map(entityToPlain),
+      total: entities.length,
+      limit,
+      offset
+    };
+  }
+  async query(eql) {
+    if (isRemote(this.opts)) {
+      return await this._fetch("POST", "/query", {
+        query: eql
+      });
+    }
+    const { parseSimple } = await import("./index-2r4jxwnb.js");
+    const { QueryEngine } = await import("./engine-y0724kjq.js");
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const parsed = parseSimple(eql);
+    const engine = new QueryEngine(kernel.getStore());
+    return engine.execute(parsed);
+  }
+  async upload(data, contentType = "application/octet-stream") {
+    const raw = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const cleanBuf = raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength);
+    const buffer = new Uint8Array(cleanBuf);
+    if (isRemote(this.opts)) {
+      const res = await fetch(`${this.opts.url}/upload`, {
+        method: "POST",
+        headers: {
+          "Content-Type": contentType,
+          ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        },
+        body: cleanBuf
+      });
+      if (!res.ok)
+        throw new FetchError(res.status, await res.text());
+      return await res.json();
+    }
+    const hashBuf = await crypto.subtle.digest("SHA-256", buffer);
+    const hash = `blob:${Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    if (!backend.hasBlob(hash))
+      backend.putBlob(hash, buffer);
+    return { hash, size: buffer.length, contentType };
+  }
+  async getFile(hash) {
+    if (isRemote(this.opts)) {
+      const res = await fetch(`${this.opts.url}/files/${encodeURIComponent(hash)}`, {
+        headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+      });
+      if (res.status === 404)
+        return null;
+      if (!res.ok)
+        throw new FetchError(res.status, await res.text());
+      return new Uint8Array(await res.arrayBuffer());
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    return backend.getBlob(hash) ?? null;
+  }
+  async register(email, password, name) {
+    if (!isRemote(this.opts))
+      throw new Error("register() requires remote mode");
+    return await this._fetch("POST", "/auth/register", {
+      email,
+      password,
+      name
+    });
+  }
+  async login(email, password) {
+    if (!isRemote(this.opts))
+      throw new Error("login() requires remote mode");
+    return await this._fetch("POST", "/auth/login", {
+      email,
+      password
+    });
+  }
+  setToken(token) {
+    if (!isRemote(this.opts))
+      return;
+    this.opts.apiKey = token;
+  }
+  subscribe(eql, callback) {
+    if (!isRemote(this.opts)) {
+      throw new Error("subscribe() requires remote mode (connect to a running server)");
+    }
+    const subId = `sub_${crypto.randomUUID()}`;
+    this._subCallbacks.set(subId, callback);
+    this._ensureWs().then((ws) => {
+      ws.send(JSON.stringify({ type: "subscribe", id: subId, query: eql }));
+    });
+    return {
+      unsubscribe: () => {
+        this._subCallbacks.delete(subId);
+        this._ws?.send(JSON.stringify({ type: "unsubscribe", id: subId }));
+      }
+    };
+  }
+  disconnect() {
+    this._ws?.close();
+    this._ws = null;
+  }
+  close() {
+    this._pool?.closeAll();
+    this._pool = null;
+    this.disconnect();
+  }
+  _getPool() {
+    if (!this._pool) {
+      const path = this.opts.path;
+      this._pool = new TenantPool(path);
+    }
+    return this._pool;
+  }
+  async _fetch(method, path, body) {
+    const opts = this.opts;
+    const url = `${opts.url}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+      },
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    const data = await res.json();
+    if (!res.ok)
+      throw new FetchError(res.status, data?.message ?? res.statusText, data);
+    return data;
+  }
+  async _ensureWs() {
+    if (this._ws && this._ws.readyState === WebSocket.OPEN)
+      return this._ws;
+    const opts = this.opts;
+    const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        this._ws = ws;
+        resolve(ws);
+      };
+      ws.onerror = (e) => reject(e);
+      ws.onmessage = (e) => {
+        try {
+          const msg = JSON.parse(e.data);
+          if (msg.type === "data" && this._subCallbacks.has(msg.id)) {
+            this._subCallbacks.get(msg.id)(msg.result, msg.diff);
+          }
+        } catch {}
+      };
+      ws.onclose = () => {
+        this._ws = null;
+      };
+    });
+  }
+}
+function entityToPlain(entity) {
+  const obj = { id: entity.id, type: entity.type };
+  for (const f of entity.facts) {
+    if (f.a !== "type")
+      obj[f.a] = f.v;
+  }
+  return obj;
+}
+
+class FetchError extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(`HTTP ${status}: ${message}`);
+    this.status = status;
+    this.body = body;
+    this.name = "FetchError";
+  }
+}
+
+export { TrellisDb, FetchError };

package/dist/index-5bhe57y9.js

@@ -0,0 +1,326 @@
+// @bun
+import {
+  __esm
+} from "./index-a76rekgs.js";
+
+// src/core/store/eav-store.ts
+function* flatten(obj, base = "") {
+  if (Array.isArray(obj)) {
+    for (const v of obj) {
+      yield* flatten(v, base);
+    }
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      yield* flatten(v, base ? `${base}.${k}` : k);
+    }
+  } else {
+    yield [base, obj];
+  }
+}
+function jsonEntityFacts(entityId, root, type) {
+  const facts = [{ e: entityId, a: "type", v: type }];
+  for (const [a, v] of flatten(root)) {
+    if (v === undefined || v === null)
+      continue;
+    if (Array.isArray(v)) {
+      for (const el of v) {
+        facts.push({ e: entityId, a, v: el });
+      }
+    } else if (typeof v === "object") {} else {
+      facts.push({ e: entityId, a, v });
+    }
+  }
+  return facts;
+}
+
+class EAVStore {
+  facts = [];
+  links = [];
+  catalog = new Map;
+  eavIndex = new Map;
+  aevIndex = new Map;
+  aveIndex = new Map;
+  linkIndex = new Map;
+  linkReverseIndex = new Map;
+  linkAttrIndex = new Map;
+  distinct = new Map;
+  addFacts(facts) {
+    for (let i = 0;i < facts.length; i++) {
+      const fact = facts[i];
+      if (fact) {
+        this.facts.push(fact);
+        this.updateIndexes(fact, this.facts.length - 1);
+        this.updateCatalog(fact);
+      }
+    }
+  }
+  addLinks(links) {
+    for (const link of links) {
+      this.links.push(link);
+      this.updateLinkIndexes(link);
+    }
+  }
+  deleteFacts(factsToDelete) {
+    for (const fact of factsToDelete) {
+      const valueKey = this.valueKey(fact.v);
+      const indices = this.aveIndex.get(fact.a)?.get(valueKey);
+      if (!indices)
+        continue;
+      let foundIdx = -1;
+      for (const idx of indices) {
+        const storedFact = this.facts[idx];
+        if (storedFact && storedFact.e === fact.e && storedFact.a === fact.a) {
+          foundIdx = idx;
+          break;
+        }
+      }
+      if (foundIdx !== -1) {
+        this.facts[foundIdx] = undefined;
+        this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
+        this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
+        this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
+        const entry = this.catalog.get(fact.a);
+        if (entry) {}
+      }
+    }
+  }
+  deleteLinks(linksToDelete) {
+    for (const link of linksToDelete) {
+      const initialLen = this.links.length;
+      this.links = this.links.filter((l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2));
+      if (this.links.length < initialLen) {
+        this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
+        this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
+        const attrPairs = this.linkAttrIndex.get(link.a);
+        if (attrPairs) {
+          for (const pair of attrPairs) {
+            if (pair[0] === link.e1 && pair[1] === link.e2) {
+              attrPairs.delete(pair);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  updateIndexes(fact, index) {
+    if (!this.eavIndex.has(fact.e)) {
+      this.eavIndex.set(fact.e, new Map);
+    }
+    if (!this.eavIndex.get(fact.e).has(fact.a)) {
+      this.eavIndex.get(fact.e).set(fact.a, new Set);
+    }
+    this.eavIndex.get(fact.e).get(fact.a).add(index);
+    if (!this.aevIndex.has(fact.a)) {
+      this.aevIndex.set(fact.a, new Map);
+    }
+    if (!this.aevIndex.get(fact.a).has(fact.e)) {
+      this.aevIndex.get(fact.a).set(fact.e, new Set);
+    }
+    this.aevIndex.get(fact.a).get(fact.e).add(index);
+    if (!this.aveIndex.has(fact.a)) {
+      this.aveIndex.set(fact.a, new Map);
+    }
+    const valueKey = this.valueKey(fact.v);
+    if (!this.aveIndex.get(fact.a).has(valueKey)) {
+      this.aveIndex.get(fact.a).set(valueKey, new Set);
+    }
+    this.aveIndex.get(fact.a).get(valueKey).add(index);
+  }
+  updateLinkIndexes(link) {
+    if (!this.linkIndex.has(link.e1)) {
+      this.linkIndex.set(link.e1, new Map);
+    }
+    const e1Attrs = this.linkIndex.get(link.e1);
+    if (!e1Attrs.has(link.a)) {
+      e1Attrs.set(link.a, new Set);
+    }
+    e1Attrs.get(link.a).add(link.e2);
+    if (!this.linkReverseIndex.has(link.e2)) {
+      this.linkReverseIndex.set(link.e2, new Map);
+    }
+    const e2Attrs = this.linkReverseIndex.get(link.e2);
+    if (!e2Attrs.has(link.a)) {
+      e2Attrs.set(link.a, new Set);
+    }
+    e2Attrs.get(link.a).add(link.e1);
+    if (!this.linkAttrIndex.has(link.a)) {
+      this.linkAttrIndex.set(link.a, new Set);
+    }
+    this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
+  }
+  valueKey(v) {
+    if (v instanceof Date)
+      return `date:${v.toISOString()}`;
+    return `${typeof v}:${v}`;
+  }
+  updateCatalog(fact) {
+    const entry = this.catalog.get(fact.a) || {
+      attribute: fact.a,
+      type: this.inferType(fact.v),
+      cardinality: "one",
+      distinctCount: 0,
+      examples: []
+    };
+    const factType = this.inferType(fact.v);
+    if (entry.type !== factType && entry.type !== "mixed") {
+      entry.type = "mixed";
+    }
+    const entityAttrs = this.eavIndex.get(fact.e)?.get(fact.a);
+    if (entityAttrs && entityAttrs.size > 1) {
+      entry.cardinality = "many";
+    }
+    const k = this.valueKey(fact.v);
+    const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, new Set), this.distinct.get(fact.a));
+    s.add(k);
+    entry.distinctCount = s.size;
+    if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
+      entry.examples.push(fact.v);
+    }
+    if (typeof fact.v === "number") {
+      entry.min = Math.min(entry.min ?? fact.v, fact.v);
+      entry.max = Math.max(entry.max ?? fact.v, fact.v);
+    }
+    this.catalog.set(fact.a, entry);
+  }
+  inferType(v) {
+    if (typeof v === "string")
+      return "string";
+    if (typeof v === "number")
+      return "number";
+    if (typeof v === "boolean")
+      return "boolean";
+    if (v instanceof Date)
+      return "date";
+    return "mixed";
+  }
+  getFactsByEntity(entity) {
+    const indices = this.eavIndex.get(entity);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const attrIndices of indices.values()) {
+      for (const idx of attrIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByAttribute(attribute) {
+    const indices = this.aevIndex.get(attribute);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const entityIndices of indices.values()) {
+      for (const idx of entityIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByValue(attribute, value) {
+    const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
+    if (!indices)
+      return [];
+    return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== undefined);
+  }
+  getCatalog() {
+    return Array.from(this.catalog.values());
+  }
+  getCatalogEntry(attribute) {
+    return this.catalog.get(attribute);
+  }
+  getAllFacts() {
+    return this.facts.filter((f) => f !== undefined);
+  }
+  getAllLinks() {
+    return [...this.links];
+  }
+  getLinksByEntity(entity) {
+    const results = [];
+    const forwardLinks = this.linkIndex.get(entity);
+    if (forwardLinks) {
+      for (const [attr, targets] of forwardLinks) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attr, e2: target });
+        }
+      }
+    }
+    const reverseLinks = this.linkReverseIndex.get(entity);
+    if (reverseLinks) {
+      for (const [attr, sources] of reverseLinks) {
+        for (const source of sources) {
+          results.push({ e1: source, a: attr, e2: entity });
+        }
+      }
+    }
+    return results;
+  }
+  getLinksByAttribute(attribute) {
+    const results = [];
+    const links = this.linkAttrIndex.get(attribute);
+    if (links) {
+      for (const [e1, e2] of links) {
+        results.push({ e1, a: attribute, e2 });
+      }
+    }
+    return results;
+  }
+  getLinksByEntityAndAttribute(entity, attribute) {
+    const results = [];
+    const attrs = this.linkIndex.get(entity);
+    if (attrs) {
+      const targets = attrs.get(attribute);
+      if (targets) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attribute, e2: target });
+        }
+      }
+    }
+    return results;
+  }
+  getStats() {
+    return {
+      totalFacts: this.facts.length,
+      totalLinks: this.links.length,
+      uniqueEntities: this.eavIndex.size,
+      uniqueAttributes: this.aevIndex.size,
+      catalogEntries: this.catalog.size
+    };
+  }
+  snapshot() {
+    return {
+      facts: this.facts.filter((f) => f !== undefined),
+      links: [...this.links],
+      catalog: this.getCatalog()
+    };
+  }
+  restore(snapshot) {
+    this.facts = [];
+    this.links = [];
+    this.catalog.clear();
+    this.eavIndex.clear();
+    this.aevIndex.clear();
+    this.aveIndex.clear();
+    this.linkIndex.clear();
+    this.linkReverseIndex.clear();
+    this.linkAttrIndex.clear();
+    this.distinct.clear();
+    this.addFacts(snapshot.facts);
+    this.addLinks(snapshot.links);
+    if (snapshot.catalog) {
+      for (const entry of snapshot.catalog) {
+        this.catalog.set(entry.attribute, entry);
+      }
+    }
+  }
+}
+var init_eav_store = () => {};
+
+export { flatten, jsonEntityFacts, EAVStore, init_eav_store };

package/dist/index-5p6zgspx.js

@@ -0,0 +1,77 @@
+// @bun
+import {
+  SqliteKernelBackend,
+  TrellisKernel
+} from "./index-7t92ej34.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;
+  dbPath;
+  agentId;
+  constructor(dbPath, agentId = "trellis-db") {
+    this.dbPath = resolve(dbPath);
+    this.agentId = agentId;
+    this._ensureDirs();
+  }
+  get(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (!this.pool.has(id)) {
+      this.pool.set(id, this._createKernel(id));
+    }
+    return this.pool.get(id);
+  }
+  has(tenantId) {
+    return this.pool.has(tenantId);
+  }
+  activeTenants() {
+    return Array.from(this.pool.keys());
+  }
+  close(tenantId) {
+    const kernel = this.pool.get(tenantId);
+    if (kernel) {
+      kernel.close();
+      this.pool.delete(tenantId);
+    }
+  }
+  closeAll() {
+    for (const kernel of this.pool.values()) {
+      kernel.close();
+    }
+    this.pool.clear();
+  }
+  dbFilePath(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (id === DEFAULT_TENANT) {
+      return join(this.dbPath, "default.sqlite");
+    }
+    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
+  }
+  _createKernel(tenantId) {
+    const sqlitePath = this.dbFilePath(tenantId);
+    const backend = new SqliteKernelBackend(sqlitePath);
+    const kernel = new TrellisKernel({
+      backend,
+      agentId: this.agentId,
+      snapshotThreshold: 1000
+    });
+    kernel.boot();
+    return kernel;
+  }
+  _ensureDirs() {
+    if (!existsSync(this.dbPath)) {
+      mkdirSync(this.dbPath, { recursive: true });
+    }
+    const tenantsPath = join(this.dbPath, TENANTS_DIR);
+    if (!existsSync(tenantsPath)) {
+      mkdirSync(tenantsPath, { recursive: true });
+    }
+  }
+}
+
+export { DEFAULT_TENANT, TenantPool };