trellis 3.2.0 → 3.2.3

package/dist/chunk-7C7LL6MB.js

@@ -1,315 +0,0 @@
-import {
-  TrellisVcsEngine,
-  init_engine
-} from "./chunk-ZMN5LUB7.js";
-import {
-  IdbOpLog
-} from "./chunk-MPXUVGT3.js";
-import {
-  JsonOpLog,
-  init_op_log
-} from "./chunk-XEN3OEYY.js";
-import {
-  PartyKitRoomTransport,
-  TrellisVcsSyncPeer
-} from "./chunk-BJ5EKCJ5.js";
-
-// src/client/vcs-client.ts
-init_engine();
-init_op_log();
-
-// 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;
-  }
-};
-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;
-    });
-  }
-};
-
-// src/client/vcs-client.ts
-var MemoryOpLog = class {
-  ops = [];
-  hashes = /* @__PURE__ */ new Set();
-  load() {
-  }
-  append(op) {
-    if (this.hashes.has(op.hash)) return;
-    this.ops.push(op);
-    this.hashes.add(op.hash);
-  }
-  readAll() {
-    return [...this.ops];
-  }
-  getLastOp() {
-    return this.ops[this.ops.length - 1];
-  }
-  count() {
-    return this.ops.length;
-  }
-};
-var TrellisClient = class _TrellisClient {
-  _engine;
-  _syncPeer;
-  _peerId = "";
-  _opLog;
-  /** Raw causal log. Updated on every local or remote op. */
-  _ops = new Signal([]);
-  /** Sync connection state. */
-  _syncStatus = new Signal({ pending: 0, synced: true });
-  _opHandlers = [];
-  _topicSubs = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  /** Factory — opens the repo, loads ops, and optionally connects to sync. */
-  static async open(opts) {
-    const client = new _TrellisClient();
-    client._peerId = opts.agentId ?? `client:${crypto.randomUUID()}`;
-    client._opLog = client._createOpLog(opts);
-    if ("load" in client._opLog && typeof client._opLog.load === "function") {
-      const maybePromise = client._opLog.load();
-      if (maybePromise instanceof Promise) await maybePromise;
-    }
-    client._engine = new TrellisVcsEngine({
-      rootPath: opts.repo,
-      agentId: client._peerId,
-      opLog: client._opLog
-    });
-    client._engine.open();
-    client._refreshState();
-    if (opts.sync) {
-      const transport = new PartyKitRoomTransport({
-        peerId: client._peerId,
-        roomUrl: opts.sync.url
-      });
-      client._syncPeer = new TrellisVcsSyncPeer({
-        peerId: client._peerId,
-        engine: client._engine,
-        transport,
-        onIntegrate: () => {
-          client._refreshState();
-          client._setSyncStatus({ synced: true });
-        }
-      });
-    }
-    return client;
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  /** Subscribe to reactive topics. Callback receives current value immediately. */
-  subscribe(topic, callback) {
-    if (!this._topicSubs.has(topic)) {
-      this._topicSubs.set(topic, /* @__PURE__ */ new Set());
-    }
-    const subs = this._topicSubs.get(topic);
-    subs.add(callback);
-    const current = this._getTopicValue(topic);
-    if (current !== void 0) {
-      try {
-        callback(current);
-      } catch {
-      }
-    }
-    return () => {
-      subs.delete(callback);
-    };
-  }
-  /** Listen for raw op events (local or remote). */
-  on(event, handler) {
-    this._opHandlers.push(handler);
-    return () => {
-      const idx = this._opHandlers.indexOf(handler);
-      if (idx >= 0) this._opHandlers.splice(idx, 1);
-    };
-  }
-  /** Create an issue and emit reactive updates. */
-  async createIssue(title, opts) {
-    const createOpts = { ...opts };
-    if (opts?.lane) {
-      createOpts.laneId = opts.lane;
-    }
-    const op = await this._engine.createIssue(title, createOpts);
-    this._refreshState();
-    return op;
-  }
-  /** Force a push/pull sync with the PartyKit room. */
-  async sync() {
-    if (!this._syncPeer) {
-      throw new Error(
-        "No sync configured. Pass sync.url to TrellisClient.open() to enable multiplayer sync."
-      );
-    }
-    this._setSyncStatus({
-      pending: this._syncStatus.value.pending + 1,
-      synced: false
-    });
-    try {
-      await this._syncPeer.syncWith("room");
-    } finally {
-      this._setSyncStatus({
-        pending: Math.max(0, this._syncStatus.value.pending - 1),
-        synced: true
-      });
-    }
-  }
-  /** Close (complete) an issue. */
-  async closeIssue(id, opts) {
-    const result = await this._engine.closeIssue(id, opts);
-    if (result.op) this._refreshState();
-    return result.op ?? null;
-  }
-  /** Reopen a closed issue. */
-  async reopenIssue(id) {
-    const op = await this._engine.reopenIssue(id);
-    this._refreshState();
-    return op;
-  }
-  /** Read current ops without subscribing. */
-  getOps() {
-    return this._engine.getOps();
-  }
-  /** Read current issues without subscribing. */
-  listIssues() {
-    return this._engine.listIssues();
-  }
-  /** Clean up resources. */
-  close() {
-    this._engine.stop();
-  }
-  // -------------------------------------------------------------------------
-  // Reactive accessors (for framework adapters)
-  // -------------------------------------------------------------------------
-  /** Signal exposing the full causal op log. */
-  get opsSignal() {
-    return this._ops;
-  }
-  /** Signal exposing sync connection status. */
-  get syncStatusSignal() {
-    return this._syncStatus;
-  }
-  /** Underlying VCS engine (for advanced sync wiring and queries). */
-  get engine() {
-    return this._engine;
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _createOpLog(opts) {
-    switch (opts.persist) {
-      case "indexeddb":
-        return new IdbOpLog({ dbName: opts.repo });
-      case "memory":
-        return new MemoryOpLog();
-      case "opfs":
-        throw new Error(
-          'OPFS persistence not yet implemented. Use "indexeddb" or "memory".'
-        );
-      default:
-        if (typeof globalThis !== "undefined" && "indexedDB" in globalThis) {
-          return new IdbOpLog({ dbName: opts.repo });
-        }
-        return new JsonOpLog(`${opts.repo}/.trellis/ops.json`);
-    }
-  }
-  _refreshState() {
-    const ops = this._engine.getOps();
-    const previousHashes = new Set(this._ops.value.map((o) => o.hash));
-    this._ops.value = ops;
-    for (const op of ops) {
-      if (!previousHashes.has(op.hash)) {
-        this._emitOp(op);
-      }
-    }
-    this._broadcastTopic("ops", ops);
-    this._broadcastTopic("issues", this._engine.listIssues());
-    this._broadcastTopic("milestones", this._engine.listMilestones());
-    this._broadcastTopic("branches", this._engine.listBranches());
-  }
-  _emitOp(op) {
-    for (const h of this._opHandlers) {
-      try {
-        h(op);
-      } catch {
-      }
-    }
-  }
-  _broadcastTopic(topic, data) {
-    const subs = this._topicSubs.get(topic);
-    if (!subs) return;
-    for (const fn of subs) {
-      try {
-        fn(data);
-      } catch {
-      }
-    }
-  }
-  _getTopicValue(topic) {
-    switch (topic) {
-      case "ops":
-        return this._ops.value;
-      case "syncStatus":
-        return this._syncStatus.value;
-      case "issues":
-        return this._engine.listIssues();
-      case "milestones":
-        return this._engine.listMilestones();
-      case "branches":
-        return this._engine.listBranches();
-      default:
-        return void 0;
-    }
-  }
-  _setSyncStatus(partial) {
-    this._syncStatus.value = { ...this._syncStatus.value, ...partial };
-    this._broadcastTopic("syncStatus", this._syncStatus.value);
-  }
-};
-
-export {
-  Signal,
-  BatchSignal,
-  TrellisClient
-};

package/dist/chunk-7F4HM3JG.js

@@ -1,394 +0,0 @@
-import {
-  TenantPool
-} from "./chunk-IUWVEEOX.js";
-import {
-  readConfig
-} from "./chunk-JA7AIHRK.js";
-
-// src/client/sdk.ts
-function isRemote(opts) {
-  return "url" in opts;
-}
-var TrellisDb = class _TrellisDb {
-  opts;
-  _pool = null;
-  _ws = null;
-  /** In-flight connect — concurrent subscribe() shares one socket open. */
-  _wsPromise = null;
-  _subCallbacks = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /**
-   * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
-   */
-  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.");
-  }
-  // -------------------------------------------------------------------------
-  // CRUD
-  // -------------------------------------------------------------------------
-  /**
-   * Create a new entity.
-   * Returns the generated entity ID.
-   */
-  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;
-  }
-  /**
-   * Read an entity by ID.
-   * Returns null if not found.
-   */
-  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);
-  }
-  /**
-   * Update an entity's attributes (partial update).
-   */
-  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);
-  }
-  /**
-   * Delete an entity by ID.
-   */
-  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);
-  }
-  /**
-   * List entities of a given type.
-   */
-  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
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Query
-  // -------------------------------------------------------------------------
-  /**
-   * Run an EQL-S query string.
-   */
-  async query(eql) {
-    if (isRemote(this.opts)) {
-      return await this._fetch("POST", "/query", {
-        query: eql
-      });
-    }
-    const { parseSimple } = await import("./query-XYLTJYSA.js");
-    const pool = this._getPool();
-    const tenantId = this.opts.tenantId ?? null;
-    const kernel = pool.get(tenantId);
-    const parsed = parseSimple(eql);
-    return kernel.query(parsed);
-  }
-  // -------------------------------------------------------------------------
-  // Schema registration
-  // -------------------------------------------------------------------------
-  /**
-   * Register a user/system-tier ontology schema with the kernel.
-   *
-   * Accepts a {@link SchemaDefinition} or anything carrying one (e.g. a
-   * `defineType` handle: `client.registerType(NavItem)`). Local mode calls
-   * `kernel.createOntology` directly; remote mode POSTs to `/ontologies`.
-   */
-  async registerType(schema) {
-    const def = "@id" in schema ? schema : schema.definition;
-    if (isRemote(this.opts)) {
-      await this._fetch("POST", "/ontologies", def);
-      return;
-    }
-    const pool = this._getPool();
-    const tenantId = this.opts.tenantId ?? null;
-    const kernel = pool.get(tenantId);
-    kernel.createOntology(def);
-  }
-  // -------------------------------------------------------------------------
-  // File upload
-  // -------------------------------------------------------------------------
-  /**
-   * Upload a file to the blob store.
-   * Returns a content-addressed hash.
-   */
-  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 };
-  }
-  /**
-   * Download a file by its blob hash.
-   */
-  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;
-  }
-  // -------------------------------------------------------------------------
-  // Auth helpers
-  // -------------------------------------------------------------------------
-  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
-    });
-  }
-  /**
-   * Set the active API key / JWT token for subsequent requests.
-   */
-  setToken(token) {
-    if (!isRemote(this.opts)) return;
-    this.opts.apiKey = token;
-  }
-  // -------------------------------------------------------------------------
-  // Realtime
-  // -------------------------------------------------------------------------
-  /**
-   * Subscribe to a live EQL-S query.
-   * Callback is fired immediately with the initial result, then on every update.
-   *
-   * Requires remote mode (WebSocket to server).
-   */
-  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 }));
-      }
-    };
-  }
-  /**
-   * Close the WebSocket connection.
-   */
-  disconnect() {
-    const ws = this._ws;
-    this._ws = null;
-    this._wsPromise = null;
-    ws?.close();
-  }
-  /**
-   * Close local kernel pool connections.
-   */
-  close() {
-    this._pool?.closeAll();
-    this._pool = null;
-    this.disconnect();
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _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 !== void 0 ? JSON.stringify(body) : void 0
-    });
-    const data = await res.json();
-    if (!res.ok)
-      throw new FetchError(
-        res.status,
-        data?.message ?? res.statusText,
-        data
-      );
-    return data;
-  }
-  _ensureWs() {
-    if (this._ws?.readyState === WebSocket.OPEN) {
-      return Promise.resolve(this._ws);
-    }
-    if (this._wsPromise) {
-      return this._wsPromise;
-    }
-    const opts = this.opts;
-    const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
-    this._wsPromise = new Promise((resolve, reject) => {
-      const ws = new WebSocket(wsUrl);
-      ws.onopen = () => {
-        this._ws = ws;
-        resolve(ws);
-      };
-      ws.onerror = (e) => {
-        reject(e instanceof Error ? e : new Error("WebSocket error"));
-      };
-      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 = () => {
-        if (this._ws === ws) {
-          this._ws = null;
-        }
-      };
-    }).finally(() => {
-      this._wsPromise = null;
-    });
-    return this._wsPromise;
-  }
-};
-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;
-}
-var FetchError = class extends Error {
-  constructor(status, message, body) {
-    super(`HTTP ${status}: ${message}`);
-    this.status = status;
-    this.body = body;
-    this.name = "FetchError";
-  }
-};
-
-export {
-  TrellisDb,
-  FetchError
-};