trellis 3.1.35 → 3.2.0

package/dist/launch-explorer-AI6L2AWJ.js

@@ -0,0 +1,91 @@
+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 });
+  }
+  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/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/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
+};