open-agents-ai 0.187.161 → 0.187.162

package/dist/index.js

@@ -265041,9 +265041,200 @@ var init_temporalGraph = __esm({
   }
 });
 
+// packages/memory/dist/zettelkasten.js
+function cosineSimilarity2(a2, b) {
+  if (a2.length !== b.length || a2.length === 0)
+    return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i2 = 0; i2 < a2.length; i2++) {
+    dot += a2[i2] * b[i2];
+    normA += a2[i2] * a2[i2];
+    normB += b[i2] * b[i2];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom > 0 ? dot / denom : 0;
+}
+function findNeighbors(episode, candidates, topK, minSimilarity) {
+  if (!episode.embedding)
+    return [];
+  const scored = [];
+  for (const candidate of candidates) {
+    if (candidate.id === episode.id)
+      continue;
+    if (!candidate.embedding)
+      continue;
+    const sim = cosineSimilarity2(episode.embedding, candidate.embedding);
+    if (sim >= minSimilarity) {
+      scored.push({ episode: candidate, similarity: sim });
+    }
+  }
+  scored.sort((a2, b) => b.similarity - a2.similarity);
+  return scored.slice(0, topK);
+}
+function linkEpisode(episode, episodeStore, graph, config) {
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const result = { episodeId: episode.id, linkedTo: [], linksCreated: 0 };
+  if (!episode.embedding)
+    return result;
+  const candidates = episodeStore.recent(500).filter((e2) => e2.embedding != null);
+  const neighbors2 = findNeighbors(episode, candidates, cfg.topK, cfg.minSimilarity);
+  for (const { episode: neighbor, similarity } of neighbors2) {
+    if (result.linksCreated >= cfg.maxLinksPerEpisode)
+      break;
+    const srcNodeId = graph.upsertNode({
+      text: episode.content.slice(0, 100),
+      nodeType: "event"
+    });
+    const dstNodeId = graph.upsertNode({
+      text: neighbor.content.slice(0, 100),
+      nodeType: "event"
+    });
+    graph.addEdge({
+      srcId: srcNodeId,
+      dstId: dstNodeId,
+      relation: "related_to",
+      fact: `Associated: ${episode.content.slice(0, 50)} \u2194 ${neighbor.content.slice(0, 50)}`,
+      edgeType: "synonym",
+      confidence: similarity,
+      sourceEpisodeId: episode.id
+    });
+    result.linkedTo.push({ neighborId: neighbor.id, similarity, linked: true });
+    result.linksCreated++;
+    if (similarity >= cfg.evolutionThreshold && neighbor.gist !== episode.content.slice(0, 200)) {
+      const evolvedGist = neighbor.gist ? `${neighbor.gist} | Also related: ${episode.content.slice(0, 100)}` : `Related context: ${episode.content.slice(0, 150)}`;
+      episodeStore.setGist(neighbor.id, evolvedGist.slice(0, 500));
+    }
+  }
+  return result;
+}
+function batchLink(episodeStore, graph, config) {
+  const episodes = episodeStore.recent(200).filter((e2) => e2.embedding != null);
+  let totalLinks = 0;
+  let processed = 0;
+  for (const ep of episodes) {
+    const result = linkEpisode(ep, episodeStore, graph, config);
+    totalLinks += result.linksCreated;
+    if (result.linksCreated > 0)
+      processed++;
+  }
+  return { processed, linksCreated: totalLinks };
+}
+var DEFAULT_CONFIG4;
+var init_zettelkasten = __esm({
+  "packages/memory/dist/zettelkasten.js"() {
+    "use strict";
+    DEFAULT_CONFIG4 = {
+      topK: 3,
+      minSimilarity: 0.3,
+      evolutionThreshold: 0.6,
+      maxLinksPerEpisode: 10
+    };
+  }
+});
+
+// packages/memory/dist/gistCompressor.js
+function compressToGist(episodes, taskDescription) {
+  if (episodes.length === 0) {
+    return {
+      gist: "Empty task \u2014 no actions taken.",
+      sourceEpisodeIds: [],
+      episodeType: "mixed",
+      turnCount: 0,
+      toolsUsed: [],
+      filesModified: [],
+      errorsEncountered: [],
+      timestamp: Date.now()
+    };
+  }
+  const toolsUsed = [...new Set(episodes.map((e2) => e2.toolName).filter(Boolean))];
+  const filesModified = extractFilePaths(episodes, ["file_write", "file_edit", "file_patch", "batch_edit"]);
+  const filesRead = extractFilePaths(episodes, ["file_read"]);
+  const errorsEncountered = episodes.filter((e2) => e2.content.toLowerCase().includes("error") || e2.content.toLowerCase().includes("failed")).map((e2) => e2.content.slice(0, 80)).slice(0, 3);
+  const episodeType = classifyTrajectory(episodes, errorsEncountered);
+  const parts = [];
+  const taskSnippet = taskDescription.slice(0, 100).replace(/\n/g, " ");
+  parts.push(`Task: "${taskSnippet}"`);
+  if (filesModified.length > 0) {
+    parts.push(`Modified ${filesModified.length} file(s): ${filesModified.slice(0, 3).join(", ")}`);
+  }
+  if (errorsEncountered.length > 0 && episodeType === "error_recovery") {
+    parts.push(`Encountered ${errorsEncountered.length} error(s), recovered successfully`);
+  } else if (errorsEncountered.length > 0) {
+    parts.push(`${errorsEncountered.length} error(s) encountered`);
+  }
+  parts.push(`Used ${toolsUsed.length} tools across ${episodes.length} steps`);
+  const lastEp = episodes[episodes.length - 1];
+  if (lastEp.toolName === "task_complete") {
+    parts.push("Completed successfully");
+  } else if (lastEp.content.toLowerCase().includes("error")) {
+    parts.push("Ended with errors");
+  }
+  const gist = parts.join(". ") + ".";
+  return {
+    gist,
+    sourceEpisodeIds: episodes.map((e2) => e2.id),
+    episodeType,
+    turnCount: Math.max(...episodes.map((e2) => e2.turnNumber ?? 0)),
+    toolsUsed,
+    filesModified,
+    errorsEncountered,
+    timestamp: episodes[episodes.length - 1]?.timestamp ?? Date.now()
+  };
+}
+function compressAndStore(episodeStore, sessionId, taskDescription, minTurns = 10) {
+  const episodes = episodeStore.recent(500, sessionId);
+  const maxTurn = Math.max(0, ...episodes.map((e2) => e2.turnNumber ?? 0));
+  if (maxTurn < minTurns)
+    return null;
+  const gistRecord = compressToGist(episodes.reverse(), taskDescription);
+  episodeStore.insert({
+    sessionId,
+    modality: "gist",
+    content: gistRecord.gist,
+    importance: 8,
+    decayClass: "procedural",
+    sourceEpisodeId: gistRecord.sourceEpisodeIds[0]
+  });
+  return gistRecord;
+}
+function extractFilePaths(episodes, toolNames) {
+  const paths = [];
+  for (const ep of episodes) {
+    if (!ep.toolName || !toolNames.includes(ep.toolName))
+      continue;
+    if (ep.metadata) {
+      const fp = ep.metadata.args_fingerprint;
+      if (fp) {
+        const pathMatch = fp.match(/path=([^,]+)/);
+        if (pathMatch)
+          paths.push(pathMatch[1]);
+      }
+    }
+  }
+  return [...new Set(paths)];
+}
+function classifyTrajectory(episodes, errors) {
+  const hasErrors = errors.length > 0;
+  const lastSuccess = episodes.some((e2) => e2.toolName === "task_complete");
+  const hasFileEdits = episodes.some((e2) => ["file_write", "file_edit"].includes(e2.toolName ?? ""));
+  const hasSearch = episodes.some((e2) => ["grep_search", "find_files", "web_search"].includes(e2.toolName ?? ""));
+  if (hasErrors && lastSuccess)
+    return "error_recovery";
+  if (hasSearch && !hasFileEdits)
+    return "discovery";
+  if (!hasErrors && hasFileEdits)
+    return "tool_sequence";
+  return "mixed";
+}
+var init_gistCompressor = __esm({
+  "packages/memory/dist/gistCompressor.js"() {
+    "use strict";
+  }
+});
+
 // packages/memory/dist/embeddings.js
 async function generateEmbedding(text, config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const cfg = { ...DEFAULT_CONFIG5, ...config };
   try {
     const url = `${cfg.baseUrl}/api/embed`;
     const resp = await fetch(url, {
@@ -265078,7 +265269,7 @@ async function generateEmbedding(text, config) {
   }
 }
 async function checkEmbeddingAvailable(config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const cfg = { ...DEFAULT_CONFIG5, ...config };
   try {
     const resp = await fetch(`${cfg.baseUrl}/api/tags`, {
       signal: AbortSignal.timeout(5e3)
@@ -265105,11 +265296,11 @@ async function pullEmbeddingModel(baseUrl, model, timeoutMs) {
     return false;
   }
 }
-var DEFAULT_CONFIG4;
+var DEFAULT_CONFIG5;
 var init_embeddings = __esm({
   "packages/memory/dist/embeddings.js"() {
     "use strict";
-    DEFAULT_CONFIG4 = {
+    DEFAULT_CONFIG5 = {
       baseUrl: "http://localhost:11434",
       model: "nomic-embed-text",
       timeoutMs: 3e4
@@ -265139,6 +265330,8 @@ var init_dist7 = __esm({
     init_toolPatternStore();
     init_episodeStore();
     init_temporalGraph();
+    init_zettelkasten();
+    init_gistCompressor();
     init_embeddings();
     init_proceduralMemoryStore();
   }
@@ -265898,6 +266091,15 @@ var init_agenticRunner = __esm({
             const embResult = await generateEmbedding(content, { baseUrl });
             if (embResult?.vector) {
               this._episodeStore.setEmbedding(id, embResult.vector);
+              if (this._temporalGraph) {
+                const episode = this._episodeStore.get(id);
+                if (episode?.embedding) {
+                  try {
+                    linkEpisode(episode, this._episodeStore, this._temporalGraph);
+                  } catch {
+                  }
+                }
+              }
             }
           } catch {
           }
@@ -268138,6 +268340,19 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
               await this.processPendingEmbeddings();
             }
             this.stopEmbeddingPipeline();
+            const gist = compressAndStore(this._episodeStore, this._sessionId, task, 10);
+            if (gist) {
+              this.emit({ type: "status", content: `Gist compressed: "${gist.gist.slice(0, 100)}..."`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+            }
+            if (this._temporalGraph) {
+              try {
+                const linkResult = batchLink(this._episodeStore, this._temporalGraph);
+                if (linkResult.linksCreated > 0) {
+                  this.emit({ type: "status", content: `Zettelkasten: ${linkResult.linksCreated} associative links created`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                }
+              } catch {
+              }
+            }
             if (this._temporalGraph) {
               const nodes = this._temporalGraph.nodeCount();
               const edges = this._temporalGraph.activeEdgeCount();
@@ -303382,7 +303597,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
-      files: extractFilePaths(toolName, toolArgs),
+      files: extractFilePaths2(toolName, toolArgs),
       summary: buildSummary(toolName, toolArgs),
       success,
       session: sessionId,
@@ -303395,7 +303610,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
   }
   return { logToolCall, logPath: logPath2 };
 }
-function extractFilePaths(tool, args) {
+function extractFilePaths2(tool, args) {
   if (tool === "batch_edit") {
     const edits = args["edits"];
     if (Array.isArray(edits)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.161",
+  "version": "0.187.162",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",