trellis 3.2.3 → 3.2.4

package/dist/{chunk-GU374KWZ.js → chunk-NLFRRGX6.js}

@@ -1,14 +1,14 @@
 import {
   decisionEntityId,
   init_types
-} from "./chunk-N6MYZT4O.js";
+} from "./chunk-547FZFKO.js";
 import {
   createVcsOp,
   init_ops
-} from "./chunk-GLM4HGN4.js";
+} from "./chunk-GRWQPKYK.js";
 import {
   __esm
-} from "./chunk-KFQGP6VL.js";
+} from "./chunk-2ESYSVXG.js";
 
 // src/decisions/hooks.ts
 function matchesPattern(pattern, toolName) {

package/dist/{chunk-XMQ7G77X.js → chunk-OB4CMMX6.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./chunk-KFQGP6VL.js";
+} from "./chunk-2ESYSVXG.js";
 
 // src/core/persist/sqlite-backend.ts
 var _DatabaseCtor = null;

package/dist/chunk-OKNASCZY.js

@@ -0,0 +1,182 @@
+import {
+  inferProjectContext,
+  init_infer,
+  init_profile,
+  init_write,
+  loadProfile
+} from "./chunk-N3R74ZSR.js";
+
+// src/scaffold/seed.ts
+init_profile();
+init_infer();
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+async function seedContext(opts) {
+  const { rootPath, ide = "none", force = false } = opts;
+  const filesUpdated = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const profile = loadProfile();
+  const context = await inferProjectContext(rootPath);
+  const agentsDir = join(rootPath, ".trellis", "agents");
+  if (existsSync(agentsDir)) {
+    const agentsMdPath = join(agentsDir, "AGENTS.md");
+    if (existsSync(agentsMdPath) || force) {
+      const content = renderSeedAgentsMd(profile, context, timestamp);
+      writeFileSync(agentsMdPath, content, "utf-8");
+      filesUpdated.push(".trellis/agents/AGENTS.md");
+    }
+    const agentContextPath = join(agentsDir, "agent-context.json");
+    if (existsSync(agentContextPath) || force) {
+      const config = {
+        domain: context.domain,
+        ecosystem: context.ecosystem,
+        tools: [],
+        ontologies: [],
+        generatedAt: timestamp,
+        confidence: context.confidence,
+        lastSeed: timestamp
+      };
+      writeFileSync(agentContextPath, JSON.stringify(config, null, 2), "utf-8");
+      filesUpdated.push(".trellis/agents/agent-context.json");
+    }
+  }
+  switch (ide) {
+    case "cursor": {
+      const cursorRulesPath = join(rootPath, ".cursor", "rules.md");
+      if (existsSync(cursorRulesPath) || force) {
+        const content = renderSeedIdeRules(
+          profile,
+          context,
+          "cursor",
+          timestamp
+        );
+        writeFileSync(cursorRulesPath, content, "utf-8");
+        filesUpdated.push(".cursor/rules.md");
+      }
+      break;
+    }
+    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
+        );
+        writeFileSync(claudeSettingsPath, content, "utf-8");
+        filesUpdated.push(".claude/settings.md");
+      }
+      break;
+    }
+    case "none":
+      break;
+  }
+  return {
+    success: true,
+    filesUpdated,
+    timestamp
+  };
+}
+function renderSeedAgentsMd(profile, context, timestamp) {
+  const userName = profile?.name ?? "the user";
+  const userBio = profile?.bio ?? "(not provided)";
+  const userSkills = profile?.skills?.length ? profile.skills.join(", ") : "(not specified)";
+  return `# Trellis Agent Context
+
+> This file was seeded by \`trellis seed\` on ${timestamp}
+> Inference confidence: **${context.confidence}**
+
+---
+
+## About the User
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${userName} |
+| **Bio** | ${userBio} |
+| **Skills** | ${userSkills} |
+
+---
+
+## About This Project
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${context.name ?? "(unnamed)"} |
+| **Domain** | ${context.domain ?? "(not determined)"} |
+| **Description** | ${context.description ?? "(no description found)"} |
+| **Ecosystem** | ${context.ecosystem ?? "unknown"} |
+| **File count** | ~${context.fileCount} |
+
+---
+
+## Agent Instructions
+
+You are operating in a Trellis-tracked repository. Follow these guidelines:
+
+1. **Read \`agent-context.json\`** in this directory for registered tools, ontologies, and domain settings.
+2. **Check \`skills/\`** for domain-specific operating instructions relevant to this project.
+3. **Check \`workflows/\`** for repeatable task procedures.
+4. **Run \`trellis seed\`** to refresh this context file when the project evolves.
+
+---
+
+## Quick Reference
+
+\`\`\`bash
+trellis status          # Current repo state
+trellis log             # Causal operation history
+trellis seed            # Refresh this context
+trellis milestone       # Create narrative checkpoints
+\`\`\`
+`;
+}
+function renderSeedIdeRules(profile, context, ide, timestamp) {
+  const ideName = ide.charAt(0).toUpperCase() + ide.slice(1);
+  const projectName = context.name ?? "this project";
+  return `# ${ideName} Rules for ${projectName}
+
+> Generated by \`trellis seed\` on ${timestamp}
+
+## Project Context
+- **Domain**: ${context.domain ?? "(not determined)"}
+- **Ecosystem**: ${context.ecosystem ?? "unknown"}
+- **File count**: ~${context.fileCount}
+- **Confidence**: ${context.confidence}
+
+## Agent Instructions
+You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
+
+## Commands
+- \`trellis status\` \u2014 Check repo state
+- \`trellis seed\` \u2014 Refresh this context file
+- \`trellis log\` \u2014 View causal history
+
+---
+*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
+`;
+}
+
+// src/scaffold/index.ts
+init_infer();
+init_profile();
+init_write();
+
+export {
+  seedContext
+};

package/dist/chunk-ONOPPX5E.js

@@ -0,0 +1,394 @@
+import {
+  TrellisVcsEngine,
+  init_engine
+} from "./chunk-N3R74ZSR.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
+import {
+  JsonOpLog,
+  init_op_log
+} from "./chunk-IJNC25UD.js";
+import {
+  PartyKitRoomTransport,
+  TrellisVcsSyncPeer
+} from "./chunk-CPUYCCLT.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/vcs-client.ts
+init_engine();
+init_op_log();
+var DEFAULT_SYNC_STATUS = {
+  connected: false,
+  pending: 0,
+  synced: false,
+  lastSyncAt: null,
+  lastError: null
+};
+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;
+  _roomId = "room";
+  _pushDebounceMs = 200;
+  _snapshotMaxOps = 500;
+  _pushTimer;
+  _closed = false;
+  /** Raw causal log. Updated on every local or remote op. */
+  _ops = new Signal([]);
+  /** Sync connection state. */
+  _syncStatus = new Signal({ ...DEFAULT_SYNC_STATUS });
+  _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) {
+      client._roomId = opts.sync.roomId ?? "room";
+      client._pushDebounceMs = opts.sync.pushDebounceMs ?? 200;
+      client._snapshotMaxOps = opts.sync.snapshotMaxOps ?? 500;
+      const transport = client._createTransport(opts.sync, client);
+      client._syncPeer = new TrellisVcsSyncPeer({
+        peerId: client._peerId,
+        engine: client._engine,
+        transport,
+        onIntegrate: () => {
+          client._refreshState();
+          client._setSyncStatus({ synced: true, lastError: null });
+        }
+      });
+      if (opts.sync.connectOnOpen !== false) {
+        try {
+          await client._connectAndCatchUp();
+        } catch {
+        }
+      }
+    }
+    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();
+    this._schedulePush();
+    return op;
+  }
+  /** Force a push/pull sync with the room. */
+  async sync() {
+    if (!this._syncPeer) {
+      throw new Error(
+        "No sync configured. Pass sync.url to TrellisClient.open() to enable multiplayer sync."
+      );
+    }
+    await this._connectAndCatchUp();
+  }
+  /** Close (complete) an issue. */
+  async closeIssue(id, opts) {
+    const result = await this._engine.closeIssue(id, opts);
+    if (result.op) {
+      this._refreshState();
+      this._schedulePush();
+    }
+    return result.op ?? null;
+  }
+  /** Reopen a closed issue. */
+  async reopenIssue(id) {
+    const op = await this._engine.reopenIssue(id);
+    this._refreshState();
+    this._schedulePush();
+    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() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+      this._pushTimer = void 0;
+    }
+    this._syncPeer?.close();
+    if ("close" in this._opLog && typeof this._opLog.close === "function") {
+      void this._opLog.close();
+    }
+    this._engine.stop();
+    this._setSyncStatus({ connected: false });
+  }
+  // -------------------------------------------------------------------------
+  // 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
+  // -------------------------------------------------------------------------
+  _createTransport(sync, client) {
+    if (sync.transport) return sync.transport;
+    if (!sync.url) {
+      throw new Error(
+        "sync.transport or sync.url is required when sync is configured."
+      );
+    }
+    return new PartyKitRoomTransport({
+      peerId: this._peerId,
+      roomUrl: sync.url,
+      auth: sync.auth,
+      roomId: sync.roomId,
+      reconnect: sync.reconnect !== false,
+      onReconnect: () => client._onTransportReconnect(),
+      onDisconnect: () => client._setSyncStatus({ connected: false })
+    });
+  }
+  _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`);
+    }
+  }
+  async _connectTransport() {
+    const transport = this._syncPeer?.getTransport();
+    if (transport && "connect" in transport && typeof transport.connect === "function") {
+      await transport.connect();
+      this._setSyncStatus({ connected: true, lastError: null });
+    } else if (transport) {
+      this._setSyncStatus({ connected: true, lastError: null });
+    }
+  }
+  async _connectAndCatchUp() {
+    if (!this._syncPeer) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      await this._requestSnapshot();
+      const result = await this._syncPeer.syncWith(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.rejected === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.rejected > 0 ? `${result.rejected} op(s) rejected during sync` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+      throw err;
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  async _onTransportReconnect() {
+    if (this._closed || !this._syncPeer) return;
+    try {
+      await this._connectAndCatchUp();
+    } catch {
+    }
+  }
+  async _requestSnapshot() {
+    if (!this._syncPeer || this._snapshotMaxOps <= 0) return;
+    await this._syncPeer.requestSnapshot(this._roomId, this._snapshotMaxOps);
+    await new Promise((resolve) => {
+      queueMicrotask(() => resolve());
+    });
+  }
+  _schedulePush() {
+    if (!this._syncPeer || this._pushDebounceMs <= 0 || this._closed) return;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+    }
+    this._pushTimer = setTimeout(() => {
+      this._pushTimer = void 0;
+      void this._pushToRoom();
+    }, this._pushDebounceMs);
+  }
+  async _pushToRoom() {
+    if (!this._syncPeer || this._closed) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      const result = await this._syncPeer.pushTo(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.remoteRejected.length === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.remoteRejected.length > 0 ? `${result.remoteRejected.length} op(s) rejected by room` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  _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 {
+  TrellisClient
+};

package/dist/chunk-QMSU2RAH.js

@@ -0,0 +1,98 @@
+import {
+  decompose,
+  init_blob_store,
+  init_branch,
+  init_checkpoint,
+  init_decompose,
+  init_diff,
+  init_issue,
+  init_lane,
+  init_merge,
+  init_milestone,
+  init_op_log
+} from "./chunk-YKVB4LUQ.js";
+import {
+  init_types
+} from "./chunk-547FZFKO.js";
+import {
+  init_ops,
+  isVcsOp
+} from "./chunk-GRWQPKYK.js";
+
+// src/vcs/index.ts
+init_types();
+init_ops();
+init_decompose();
+
+// src/vcs/vcs-middleware.ts
+init_decompose();
+init_ops();
+var VcsMiddleware = class {
+  name = "vcs";
+  async handleOp(op, ctx, next) {
+    if (!isVcsOp(op)) {
+      return next(op, ctx);
+    }
+    const vcsOp = op;
+    const decomposed = decompose(vcsOp);
+    if (decomposed.deleteFacts.length > 0) {
+      await next(
+        {
+          ...op,
+          kind: "deleteFacts",
+          facts: decomposed.deleteFacts,
+          links: void 0
+        },
+        ctx
+      );
+    }
+    if (decomposed.deleteLinks.length > 0) {
+      await next(
+        {
+          ...op,
+          kind: "deleteLinks",
+          facts: void 0,
+          links: decomposed.deleteLinks
+        },
+        ctx
+      );
+    }
+    if (decomposed.addFacts.length > 0) {
+      await next(
+        {
+          ...op,
+          kind: "addFacts",
+          facts: decomposed.addFacts,
+          links: void 0
+        },
+        ctx
+      );
+    }
+    if (decomposed.addLinks.length > 0) {
+      await next(
+        {
+          ...op,
+          kind: "addLinks",
+          facts: void 0,
+          links: decomposed.addLinks
+        },
+        ctx
+      );
+    }
+  }
+};
+
+// src/vcs/index.ts
+init_blob_store();
+init_branch();
+init_milestone();
+init_checkpoint();
+init_diff();
+init_merge();
+init_issue();
+init_op_log();
+init_lane();
+
+export {
+  VcsMiddleware
+};