trellis 3.1.35 → 3.2.0

package/dist/chunk-ELT7MLZB.js

@@ -0,0 +1,109 @@
+import {
+  RelayPersistence
+} from "./chunk-GFZCJ4EH.js";
+
+// src/realtime/relay-server.ts
+var REPLAY_GRACE_MS = 250;
+async function attachRealtimeRelay(server, opts = {}) {
+  const path = opts.path ?? "/rt";
+  const graceMs = opts.replayGraceMs ?? REPLAY_GRACE_MS;
+  const persistence = opts.persistence === false ? null : opts.persistence ?? new RelayPersistence();
+  const Wss = opts.WebSocketServerImpl ?? (await import("ws")).WebSocketServer;
+  const wss = new Wss({ noServer: true });
+  const clients = /* @__PURE__ */ new Set();
+  const sendReplay = (ws) => {
+    if (!persistence) return;
+    const messages = persistence.buildReplay();
+    if (messages.length === 0) return;
+    const frame = { v: 1, t: "replay", from: "relay", messages };
+    ws.send(JSON.stringify(frame));
+  };
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    const replaySent = { value: false };
+    const deliverReplay = () => {
+      if (replaySent.value) return;
+      replaySent.value = true;
+      sendReplay(ws);
+    };
+    const graceTimer = graceMs > 0 ? setTimeout(deliverReplay, graceMs) : null;
+    graceTimer?.unref?.();
+    ws.on("message", (data, isBinary) => {
+      const raw = isBinary ? data : String(data);
+      let message;
+      try {
+        message = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (message?.v === 1) {
+        if (message.t === "hello") deliverReplay();
+        persistence?.record(message);
+      }
+      for (const peer of clients) {
+        if (peer === ws || peer.readyState !== peer.OPEN) continue;
+        peer.send(String(raw));
+      }
+    });
+    ws.on("close", () => {
+      if (graceTimer) clearTimeout(graceTimer);
+      clients.delete(ws);
+    });
+  });
+  const onUpgrade = (req, socket, head) => {
+    const reqPath = (req.url ?? "").split("?")[0];
+    if (reqPath !== path && reqPath !== `${path}/`) return;
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  };
+  server.on("upgrade", onUpgrade);
+  return {
+    clientCount: () => clients.size,
+    persistence,
+    close: () => new Promise((resolve) => {
+      server.off("upgrade", onUpgrade);
+      for (const ws of clients) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+      clients.clear();
+      wss.close(() => resolve());
+    })
+  };
+}
+async function createRealtimeRelay(opts = {}) {
+  const { createServer } = await import("node:http");
+  const path = opts.path ?? "/rt";
+  const port = opts.port ?? 8231;
+  const hostname = opts.hostname ?? "0.0.0.0";
+  const server = createServer((req, res) => {
+    const reqPath = (req.url ?? "/").split("?")[0];
+    if (reqPath === "/" || reqPath === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true, relay: path }));
+      return;
+    }
+    res.writeHead(404).end("not found");
+  });
+  const relay = await attachRealtimeRelay(server, opts);
+  await new Promise((resolve) => server.listen(port, hostname, resolve));
+  const addr = server.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : port;
+  return {
+    ...relay,
+    port: boundPort,
+    server,
+    close: async () => {
+      await relay.close();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+export {
+  attachRealtimeRelay,
+  createRealtimeRelay
+};

package/dist/chunk-EWEIRF6G.js

@@ -0,0 +1,171 @@
+import {
+  inferProjectContext,
+  init_infer,
+  init_profile,
+  init_write,
+  loadProfile
+} from "./chunk-HGI74PXB.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 "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");
+      }
+      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-F5VDGQJC.js

@@ -0,0 +1,120 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/server/node-adapter.ts
+async function startNodeServer(opts) {
+  const http = await import("http");
+  let WebSocketServer;
+  try {
+    ({ WebSocketServer } = await import("ws"));
+  } catch {
+    throw new Error(
+      'Running the Trellis server outside Bun requires the optional dependency "ws". Install it: npm install ws'
+    );
+  }
+  const httpServer = http.createServer(
+    async (req, res) => {
+      try {
+        const fetchReq = await toFetchRequest(req);
+        const fetchRes = await opts.fetch(fetchReq);
+        await writeFetchResponse(res, fetchRes);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Internal Server Error", message: msg }));
+      }
+    }
+  );
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+  wss.on("connection", (ws) => {
+    Promise.resolve(opts.websocket.open(ws)).catch(() => {
+    });
+    ws.on("message", (raw) => {
+      const data = Array.isArray(raw) ? Buffer.concat(raw).toString() : raw instanceof ArrayBuffer ? Buffer.from(raw).toString() : raw.toString();
+      Promise.resolve(opts.websocket.message(ws, data)).catch(() => {
+      });
+    });
+    ws.on("close", () => opts.websocket.close(ws));
+  });
+  await new Promise(
+    (resolve) => httpServer.listen(opts.port, opts.hostname, resolve)
+  );
+  const addr = httpServer.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  const boundHost = typeof addr === "object" && addr ? addr.address : opts.hostname;
+  return wrapNodeServer(httpServer, wss, boundPort, boundHost);
+}
+async function toFetchRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const method = req.method ?? "GET";
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else if (value != null) {
+      headers.set(key, value);
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? new Uint8Array(await readBody(req)) : void 0;
+  return new Request(url, { method, headers, body });
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function writeFetchResponse(res, fetchRes) {
+  res.statusCode = fetchRes.status;
+  fetchRes.headers.forEach((value, key) => res.setHeader(key, value));
+  if (!fetchRes.body) {
+    res.end();
+    return;
+  }
+  const reader = fetchRes.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(value);
+  }
+  res.end();
+}
+function wrapNodeServer(httpServer, wss, port, hostname) {
+  return {
+    port,
+    hostname: hostname ?? "localhost",
+    stop(closeActiveConnections) {
+      return new Promise((resolve, reject) => {
+        if (closeActiveConnections) {
+          for (const client of wss.clients) client.terminate();
+        }
+        wss.close(() => {
+          httpServer.close(
+            (err) => err ? reject(err) : resolve()
+          );
+        });
+      });
+    }
+  };
+}
+var init_node_adapter = __esm({
+  "src/server/node-adapter.ts"() {
+  }
+});
+
+export {
+  startNodeServer,
+  init_node_adapter
+};

package/dist/chunk-FCPL3IEQ.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-XEN3OEYY.js";
+import {
+  init_types
+} from "./chunk-BXSTJVE3.js";
+import {
+  init_ops,
+  isVcsOp
+} from "./chunk-GLM4HGN4.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
+};

package/dist/{index-nq520y6k.js → chunk-FDPKYSV7.js}

@@ -1,4 +1,3 @@
-// @bun
 import {
   decompose,
   init_blob_store,
@@ -11,12 +10,12 @@ import {
   init_merge,
   init_milestone,
   init_op_log
-} from "./index-xhcp6xrn.js";
+} from "./chunk-NSDXU6QX.js";
 import {
   init_ops,
   init_types,
   isVcsOp
-} from "./index-nzb3am4f.js";
+} from "./chunk-V3G7Q3QQ.js";
 
 // src/vcs/index.ts
 init_types();
@@ -26,8 +25,7 @@ init_decompose();
 // src/vcs/vcs-middleware.ts
 init_decompose();
 init_ops();
-
-class VcsMiddleware {
+var VcsMiddleware = class {
   name = "vcs";
   async handleOp(op, ctx, next) {
     if (!isVcsOp(op)) {
@@ -36,39 +34,51 @@ class VcsMiddleware {
     const vcsOp = op;
     const decomposed = decompose(vcsOp);
     if (decomposed.deleteFacts.length > 0) {
-      await next({
-        ...op,
-        kind: "deleteFacts",
-        facts: decomposed.deleteFacts,
-        links: undefined
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "deleteFacts",
+          facts: decomposed.deleteFacts,
+          links: void 0
+        },
+        ctx
+      );
     }
     if (decomposed.deleteLinks.length > 0) {
-      await next({
-        ...op,
-        kind: "deleteLinks",
-        facts: undefined,
-        links: decomposed.deleteLinks
-      }, ctx);
+      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: undefined
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "addFacts",
+          facts: decomposed.addFacts,
+          links: void 0
+        },
+        ctx
+      );
     }
     if (decomposed.addLinks.length > 0) {
-      await next({
-        ...op,
-        kind: "addLinks",
-        facts: undefined,
-        links: decomposed.addLinks
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "addLinks",
+          facts: void 0,
+          links: decomposed.addLinks
+        },
+        ctx
+      );
     }
   }
-}
+};
 
 // src/vcs/index.ts
 init_blob_store();
@@ -81,4 +91,6 @@ init_issue();
 init_op_log();
 init_lane();
 
-export { VcsMiddleware };
+export {
+  VcsMiddleware
+};