trellis 3.1.35 → 3.2.2

package/dist/index.js

@@ -1,5 +1,4 @@
-// @bun
-import"./index-w5wccer3.js";
+import "./chunk-S6GBJ2ZB.js";
 import {
   FileWatcher,
   Ingestion,
@@ -12,10 +11,22 @@ import {
   loadProfile,
   saveProfile,
   writeAgentScaffold
-} from "./index-rv1p47gp.js";
+} from "./chunk-L5N5PR2S.js";
+import "./chunk-GU374KWZ.js";
+import {
+  SqliteKernelBackend
+} from "./chunk-XMQ7G77X.js";
+import {
+  TrellisKernel
+} from "./chunk-KQ4A2D2P.js";
+import "./chunk-6CTA6MCE.js";
+import "./chunk-4XIVMVHC.js";
 import {
   VcsMiddleware
-} from "./index-nq520y6k.js";
+} from "./chunk-FWRS4CSC.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
 import {
   BlobStore,
   JsonOpLog,
@@ -69,112 +80,110 @@ import {
   unblockIssue,
   updateIssue,
   updateLaneHead
-} from "./index-xhcp6xrn.js";
-import"./index-4cdr7x2x.js";
+} from "./chunk-VBYUTRXX.js";
 import {
   DEFAULT_CONFIG,
   branchEntityId,
   checkpointEntityId,
-  createVcsOp,
   criterionEntityId,
   decisionEntityId,
   dirEntityId,
   fileEntityId,
-  isVcsOp,
-  isVcsOpKind,
   issueEntityId,
   laneEntityId,
   milestoneEntityId
-} from "./index-nzb3am4f.js";
+} from "./chunk-N6MYZT4O.js";
 import {
-  TrellisKernel
-} from "./index-4wxa8xz4.js";
-import"./index-yp88he8n.js";
-import"./index-yhwjgfvj.js";
-import {
-  SqliteKernelBackend
-} from "./index-h7zxhhhh.js";
-import"./index-a76rekgs.js";
+  createVcsOp,
+  hashVcsOp,
+  isVcsOp,
+  isVcsOpKind,
+  verifyVcsOpHash
+} from "./chunk-GLM4HGN4.js";
+import "./chunk-KFQGP6VL.js";
 
 // src/index.ts
 init_engine();
 init_fs_watcher();
 init_ingestion();
 export {
-  writeAgentScaffold,
-  updateLaneHead,
-  updateIssue,
-  unblockIssue,
-  triageIssue,
-  threeWayTextMerge,
-  threeWayMerge,
-  switchBranch,
-  startIssue,
-  shouldAdvanceBranchHead,
-  setCriterionStatus,
-  saveProfile,
-  saveLaneMeta,
-  saveBranchState,
-  runCriteria,
-  resumeIssue,
-  resolveLaneHeadFromJournal,
-  reopenIssue,
-  pauseIssue,
-  newLaneId,
-  myersDiff,
-  milestoneEntityId,
-  loadProfile,
-  loadLaneMeta,
-  loadBranchState,
-  listMilestones,
-  listLaneMetas,
-  listLaneIds,
-  listIssues,
-  listCheckpoints,
-  listBranches,
-  lanesRoot,
-  laneMetaPath,
-  laneEntityId,
-  laneDir,
-  issueEntityId,
-  isVcsOpKind,
-  isVcsOp,
-  inferProjectContext,
-  hasProfile,
-  getIssue,
-  getBranchHeadOpHash,
-  getActiveIssues,
-  generateUnifiedDiff,
-  fileEntityId,
-  dirEntityId,
-  diffOpRange,
-  diffFileStates,
-  deleteBranch,
-  decompose,
-  decisionEntityId,
-  criterionEntityId,
-  createVcsOp,
-  createMilestone,
-  createLaneMeta,
-  createIssue,
-  createCheckpoint,
-  createBranch,
-  closeIssue,
-  checkpointEntityId,
-  checkCompletionReadiness,
-  buildFileStateAtOp,
-  branchEntityId,
-  blockIssue,
-  assignIssue,
-  addCriterion,
-  VcsMiddleware,
-  TrellisVcsEngine,
-  TrellisKernel,
-  SqliteKernelBackend,
-  LaneOpLog,
-  JsonOpLog,
-  Ingestion,
-  FileWatcher,
+  BlobStore,
   DEFAULT_CONFIG,
-  BlobStore
+  FileWatcher,
+  IdbOpLog,
+  Ingestion,
+  JsonOpLog,
+  LaneOpLog,
+  SqliteKernelBackend,
+  TrellisKernel,
+  TrellisVcsEngine,
+  VcsMiddleware,
+  addCriterion,
+  assignIssue,
+  blockIssue,
+  branchEntityId,
+  buildFileStateAtOp,
+  checkCompletionReadiness,
+  checkpointEntityId,
+  closeIssue,
+  createBranch,
+  createCheckpoint,
+  createIssue,
+  createLaneMeta,
+  createMilestone,
+  createVcsOp,
+  criterionEntityId,
+  decisionEntityId,
+  decompose,
+  deleteBranch,
+  diffFileStates,
+  diffOpRange,
+  dirEntityId,
+  fileEntityId,
+  generateUnifiedDiff,
+  getActiveIssues,
+  getBranchHeadOpHash,
+  getIssue,
+  hasProfile,
+  hashVcsOp,
+  inferProjectContext,
+  isVcsOp,
+  isVcsOpKind,
+  issueEntityId,
+  laneDir,
+  laneEntityId,
+  laneMetaPath,
+  lanesRoot,
+  listBranches,
+  listCheckpoints,
+  listIssues,
+  listLaneIds,
+  listLaneMetas,
+  listMilestones,
+  loadBranchState,
+  loadLaneMeta,
+  loadProfile,
+  milestoneEntityId,
+  myersDiff,
+  newLaneId,
+  pauseIssue,
+  reopenIssue,
+  resolveLaneHeadFromJournal,
+  resumeIssue,
+  runCriteria,
+  saveBranchState,
+  saveLaneMeta,
+  saveProfile,
+  setCriterionStatus,
+  shouldAdvanceBranchHead,
+  startIssue,
+  switchBranch,
+  threeWayMerge,
+  threeWayTextMerge,
+  triageIssue,
+  unblockIssue,
+  updateIssue,
+  updateLaneHead,
+  verifyVcsOpHash,
+  writeAgentScaffold
 };

package/dist/launch-explorer-HZ4ZJA4X.js

@@ -0,0 +1,95 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/ui/launch-explorer.ts
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+function resolveExplorerAppDir() {
+  const candidates = [
+    path.resolve(MODULE_DIR, "../../demo/realtime-app"),
+    path.resolve(process.cwd(), "demo/realtime-app")
+  ];
+  for (const dir of candidates) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+  }
+  throw new Error(
+    "Realtime explorer app not found at demo/realtime-app.\nRun: node scripts/sync-realtime-app.mjs"
+  );
+}
+function which(cmd) {
+  return process.platform === "win32" ? `${cmd}.cmd` : cmd;
+}
+async function launchRealtimeExplorer(opts) {
+  const appDir = resolveExplorerAppDir();
+  const appPort = opts.appPort ?? 4e3;
+  const trellisPort = opts.trellisPort ?? 3920;
+  if (!existsSync(path.join(appDir, "node_modules"))) {
+    console.log("Installing explorer dependencies (pnpm)\u2026");
+    await runCmd(which("pnpm"), ["install"], { cwd: appDir });
+  } else {
+    await runCmd(which("node"), ["scripts/ensure-trellis-build.mjs"], {
+      cwd: appDir
+    });
+  }
+  const env = {
+    ...process.env,
+    TRELLIS_PORT: String(trellisPort),
+    TRELLIS_REPO_ROOT: opts.rootPath
+  };
+  const child = spawn(which("pnpm"), ["run", "dev:all"], {
+    cwd: appDir,
+    env,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  const stop = () => {
+    if (!child.killed) child.kill("SIGTERM");
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    child.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+    child.on("exit", (code) => {
+      if (settled) return;
+      if (code != null && code !== 0) {
+        settled = true;
+        reject(new Error(`Explorer exited with code ${code}`));
+      }
+    });
+    setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve({
+        appPort,
+        trellisPort,
+        appUrl: `http://localhost:${appPort}`,
+        trellisUrl: `http://localhost:${trellisPort}`,
+        stop
+      });
+    }, 2e3);
+  });
+}
+function runCmd(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with ${code}`));
+    });
+  });
+}
+export {
+  launchRealtimeExplorer,
+  resolveExplorerAppDir
+};

package/dist/links/index.js

@@ -1,4 +1,3 @@
-// @bun
 import {
   StaleRefRegistry,
   applyRenameProposal,
@@ -24,32 +23,31 @@ import {
   resolveRef,
   resolveRefs,
   updateFileInIndex
-} from "../index-vkpkfwhq.js";
-import"../index-a76rekgs.js";
+} from "../chunk-VDAKEOML.js";
+import "../chunk-KFQGP6VL.js";
 init_links();
-
 export {
-  updateFileInIndex,
-  resolveRefs,
-  resolveRef,
-  removeFileFromIndex,
-  processSemanticPatches,
-  parseRefContent,
-  parseMarkdownRefs,
-  parseFileRefs,
-  parseDocCommentRefs,
-  inferNamespace,
-  handleSymbolDeletion,
-  handleFileDeletion,
-  getReferencedEntities,
-  getOutgoingRefs,
-  getIndexStats,
-  getFilesWithRefs,
-  getDiagnostics,
-  getBacklinks,
-  createResolverContext,
-  buildRenameProposal,
-  buildRefIndex,
+  StaleRefRegistry,
   applyRenameProposal,
-  StaleRefRegistry
+  buildRefIndex,
+  buildRenameProposal,
+  createResolverContext,
+  getBacklinks,
+  getDiagnostics,
+  getFilesWithRefs,
+  getIndexStats,
+  getOutgoingRefs,
+  getReferencedEntities,
+  handleFileDeletion,
+  handleSymbolDeletion,
+  inferNamespace,
+  parseDocCommentRefs,
+  parseFileRefs,
+  parseMarkdownRefs,
+  parseRefContent,
+  processSemanticPatches,
+  removeFileFromIndex,
+  resolveRef,
+  resolveRefs,
+  updateFileInIndex
 };

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAwBrE,wBAAgB,sBAAsB,IAAI,SAAS,CAisClD;AAMD;;;GAGG;AACH,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAKjE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAwBrE,wBAAgB,sBAAsB,IAAI,SAAS,CAqsClD;AAMD;;;GAGG;AACH,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAKjE"}

package/dist/plugins/agent-memory/index.js

@@ -0,0 +1,316 @@
+import "../../chunk-KFQGP6VL.js";
+
+// src/plugins/agent-memory/ontology.ts
+var agentMemoryOntology = {
+  id: "trellis:agent-memory",
+  name: "Agent Memory",
+  version: "1.0.0",
+  description: "Graph-persisted agent conversations and message history",
+  entities: [
+    {
+      name: "Conversation",
+      description: "A thread of messages between user and agent",
+      attributes: [
+        { name: "title", type: "string", required: true },
+        { name: "model", type: "string", description: "LLM model used for this conversation" },
+        {
+          name: "status",
+          type: "string",
+          enum: ["active", "archived"],
+          default: "active"
+        },
+        { name: "createdAt", type: "string", required: true, description: "ISO 8601 timestamp" },
+        { name: "createdBy", type: "string", description: "Agent or user ID that initiated" },
+        { name: "agentId", type: "ref", description: "Agent entity this conversation belongs to", refTypes: ["Agent"] },
+        { name: "runId", type: "ref", description: "AgentRun this conversation is associated with", refTypes: ["AgentRun"] }
+      ]
+    },
+    {
+      name: "Message",
+      description: "A single message within a conversation",
+      attributes: [
+        {
+          name: "role",
+          type: "string",
+          required: true,
+          enum: ["system", "user", "assistant", "tool"]
+        },
+        { name: "content", type: "string", description: "Message content (may be null for tool-call-only messages)" },
+        { name: "timestamp", type: "string", required: true, description: "ISO 8601 timestamp" },
+        { name: "tokenCount", type: "number", description: "Estimated token count" },
+        { name: "name", type: "string", description: "Tool name for tool messages" },
+        { name: "toolCallId", type: "string", description: "Tool call ID for tool response messages" },
+        {
+          name: "status",
+          type: "string",
+          enum: ["active", "archived"],
+          default: "active",
+          description: "Archived messages are preserved for Idea Garden but excluded from active context"
+        }
+      ]
+    }
+  ],
+  relations: [
+    {
+      name: "hasMessage",
+      sourceTypes: ["Conversation"],
+      targetTypes: ["Message"],
+      cardinality: "many"
+    }
+  ]
+};
+
+// src/plugins/agent-memory/plugin.ts
+function createAgentMemoryPlugin() {
+  const isMemoryEntity = (data) => {
+    if (!data || typeof data !== "object") return false;
+    const d = data;
+    return d.type === "Conversation" || d.type === "Message";
+  };
+  return {
+    id: "trellis:agent-memory",
+    name: "Agent Memory",
+    version: "1.0.0",
+    description: "Graph-persisted agent conversations and message history",
+    ontologies: [agentMemoryOntology],
+    eventHandlers: [
+      {
+        event: "entity:created",
+        handler: (data) => {
+          if (!isMemoryEntity(data)) return;
+        }
+      },
+      {
+        event: "entity:updated",
+        handler: (data) => {
+          if (!isMemoryEntity(data)) return;
+        }
+      },
+      {
+        event: "entity:deleted",
+        handler: (data) => {
+          if (!isMemoryEntity(data)) return;
+        }
+      }
+    ],
+    onLoad: async (ctx) => {
+      ctx.log("Agent memory system loaded");
+    },
+    onUnload: async (ctx) => {
+      ctx.log("Agent memory system unloaded");
+    }
+  };
+}
+
+// src/plugins/agent-memory/graph-context-manager.ts
+var globalIdCounter = 0;
+var GraphContextManager = class {
+  kernel;
+  conversationId = null;
+  messageCounter = 0;
+  /**
+   * In-memory cache of active messages for fast getHistory() reads.
+   * Always kept in sync with the graph via addMessage/prune/resume.
+   */
+  cache = [];
+  /** In-flight graph writes from fire-and-forget addMessage/prune calls. */
+  pendingWrites = /* @__PURE__ */ new Set();
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  // -------------------------------------------------------------------------
+  // Conversation lifecycle
+  // -------------------------------------------------------------------------
+  /**
+   * Create a new conversation entity and set it as the active context.
+   * Returns the conversation entity ID.
+   */
+  async createConversation(opts) {
+    const id = `conversation:${Date.now()}:${++globalIdCounter}`;
+    const attrs = {
+      title: opts.title,
+      status: "active"
+    };
+    if (opts.agentId) attrs.agentId = opts.agentId;
+    if (opts.model) attrs.model = opts.model;
+    if (opts.createdBy) attrs.createdBy = opts.createdBy;
+    await this.kernel.createEntity(id, "Conversation", attrs);
+    this.conversationId = id;
+    this.cache = [];
+    this.messageCounter = 0;
+    return id;
+  }
+  /**
+   * Resume an existing conversation by loading its messages from the graph.
+   */
+  async resumeConversation(conversationId) {
+    const entity = this.kernel.getEntity(conversationId);
+    if (!entity || entity.type !== "Conversation") {
+      throw new Error(`Conversation "${conversationId}" not found.`);
+    }
+    this.conversationId = conversationId;
+    this.cache = this._loadMessagesFromGraph(conversationId);
+    this.messageCounter = this.cache.length;
+  }
+  /**
+   * Get the active conversation ID, or null if none is set.
+   */
+  getConversationId() {
+    return this.conversationId;
+  }
+  /**
+   * Archive the active conversation and clear local state.
+   */
+  async archiveConversation() {
+    if (!this.conversationId) return;
+    await this.kernel.updateEntity(this.conversationId, { status: "archived" });
+    this.conversationId = null;
+    this.cache = [];
+  }
+  // -------------------------------------------------------------------------
+  // ContextManager implementation
+  // -------------------------------------------------------------------------
+  addMessage(message) {
+    if (!this.conversationId) {
+      throw new Error("GraphContextManager: No active conversation. Call createConversation() first.");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entityId = `message:${this.conversationId.replace("conversation:", "")}:${++globalIdCounter}`;
+    const attrs = {
+      role: message.role,
+      timestamp,
+      status: "active"
+    };
+    if (message.content != null) attrs.content = message.content;
+    if (message.name) attrs.name = message.name;
+    if (message.tool_call_id) attrs.toolCallId = message.tool_call_id;
+    const tokenCount = this.calculateTokenCount(message);
+    attrs.tokenCount = tokenCount;
+    const write = this.kernel.createEntity(entityId, "Message", attrs, [
+      { attribute: "hasMessage", targetEntityId: entityId }
+    ]).then(() => {
+      return this.kernel.addLink(this.conversationId, "hasMessage", entityId);
+    }).catch((err) => {
+      console.error(`GraphContextManager: Failed to persist message ${entityId}:`, err);
+    }).then(() => void 0);
+    this.trackWrite(write);
+    this.cache.push({
+      entityId,
+      message,
+      timestamp,
+      status: "active"
+    });
+  }
+  getHistory() {
+    return this.cache.filter((r) => r.status === "active").map((r) => r.message);
+  }
+  async prune(targetTokenCount) {
+    let totalTokens = 0;
+    const active = this.cache.filter((r) => r.status === "active");
+    for (const record of active) {
+      totalTokens += this.calculateTokenCount(record.message);
+    }
+    if (totalTokens <= targetTokenCount) return;
+    for (const record of active) {
+      if (totalTokens <= targetTokenCount) break;
+      if (record.message.role === "system") continue;
+      record.status = "archived";
+      totalTokens -= this.calculateTokenCount(record.message);
+      const write = this.kernel.updateEntity(record.entityId, { status: "archived" }).catch((err) => {
+        console.error(`GraphContextManager: Failed to archive message ${record.entityId}:`, err);
+      }).then(() => void 0);
+      this.trackWrite(write);
+    }
+  }
+  async summarize() {
+    const archived = this.cache.filter((r) => r.status === "archived");
+    if (archived.length === 0) return "";
+    return `[${archived.length} earlier messages archived]`;
+  }
+  async injectRagContext(query, limit) {
+  }
+  calculateTokenCount(message) {
+    return (message.content?.length ?? 0) / 4;
+  }
+  // -------------------------------------------------------------------------
+  // Graph queries
+  // -------------------------------------------------------------------------
+  /**
+   * List all conversations, optionally filtered by status.
+   */
+  listConversations(status) {
+    const entities = this.kernel.listEntities("Conversation", status ? { status } : void 0);
+    return entities.map((e) => {
+      const get = (a) => e.facts.find((f) => f.a === a)?.v;
+      const messageLinks = this.kernel.getStore().getLinksByEntityAndAttribute(e.id, "hasMessage");
+      return {
+        id: e.id,
+        title: String(get("title") ?? "Untitled"),
+        status: String(get("status") ?? "active"),
+        createdAt: String(get("createdAt") ?? ""),
+        messageCount: messageLinks.length
+      };
+    });
+  }
+  /**
+   * Get the total message count for the active conversation.
+   */
+  getMessageCount() {
+    return this.cache.filter((r) => r.status === "active").length;
+  }
+  /**
+   * Get the total estimated token count for the active conversation.
+   */
+  getTotalTokenCount() {
+    return this.cache.filter((r) => r.status === "active").reduce((sum, r) => sum + this.calculateTokenCount(r.message), 0);
+  }
+  /** Wait for in-flight graph writes (tests and graceful shutdown). */
+  async awaitPersistence() {
+    while (this.pendingWrites.size > 0) {
+      await Promise.all([...this.pendingWrites]);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  trackWrite(write) {
+    this.pendingWrites.add(write);
+    write.finally(() => {
+      this.pendingWrites.delete(write);
+    });
+  }
+  /**
+   * Load messages from the graph for a given conversation, sorted by timestamp.
+   */
+  _loadMessagesFromGraph(conversationId) {
+    const store = this.kernel.getStore();
+    const messageLinks = store.getLinksByEntityAndAttribute(conversationId, "hasMessage");
+    const records = [];
+    for (const link of messageLinks) {
+      const entity = this.kernel.getEntity(link.e2);
+      if (!entity || entity.type !== "Message") continue;
+      const get = (a) => entity.facts.find((f) => f.a === a)?.v;
+      const message = {
+        role: get("role"),
+        content: get("content") ?? null
+      };
+      const name = get("name");
+      if (name) message.name = name;
+      const toolCallId = get("toolCallId");
+      if (toolCallId) message.tool_call_id = toolCallId;
+      records.push({
+        entityId: entity.id,
+        message,
+        timestamp: String(get("timestamp") ?? ""),
+        status: get("status") ?? "active"
+      });
+    }
+    records.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return records;
+  }
+};
+export {
+  GraphContextManager,
+  agentMemoryOntology,
+  createAgentMemoryPlugin
+};