open-agents-ai 0.187.162 → 0.187.163

package/dist/index.js

@@ -3680,7 +3680,7 @@ var init_memory_search = __esm({
     "use strict";
     MemorySearchTool = class {
       name = "memory_search";
-      description = "Search across all memory entries by relevance. Unlike memory_read (exact topic+key), this finds relevant memories using text matching. Use when you don't know the exact topic or key, or want to find all memories related to a concept.";
+      description = "Search across all memory entries by relevance. Unlike memory_read (exact topic+key), this finds relevant memories using text matching or associative graph traversal. Use when you don't know the exact topic or key, or want to find all memories related to a concept. Mode 'graph' uses knowledge graph traversal for multi-hop associative queries (e.g. 'what caused the auth error?').";
       parameters = {
         type: "object",
         properties: {
@@ -3691,6 +3691,11 @@ var init_memory_search = __esm({
           max_results: {
             type: "number",
             description: "Maximum number of results to return (default: 10)"
+          },
+          mode: {
+            type: "string",
+            enum: ["text", "graph", "episodes"],
+            description: "Search mode: 'text' (default \u2014 TF-IDF), 'graph' (PPR traversal), 'episodes' (recent episodes). Default: text."
           }
         },
         required: ["query"]
@@ -3702,7 +3707,87 @@ var init_memory_search = __esm({
       async execute(args) {
         const query = args["query"];
         const maxResults = args["max_results"] ?? 10;
+        const mode = args["mode"] ?? "text";
         const start2 = performance.now();
+        if (mode === "graph" || mode === "episodes") {
+          try {
+            const { join: pathJoin } = await import("node:path");
+            const { existsSync: pathExists } = await import("node:fs");
+            const { createRequire: createRequire7 } = await import("node:module");
+            const oaDir = pathJoin(this.workingDir, ".oa");
+            const epDbPath = pathJoin(oaDir, "episodes.db");
+            const kgDbPath = pathJoin(oaDir, "knowledge.db");
+            if (!pathExists(epDbPath)) {
+              return { success: true, output: `No episode store found. Run tasks to build the knowledge graph.`, durationMs: performance.now() - start2 };
+            }
+            const req2 = createRequire7(import.meta.url);
+            const Database2 = req2("better-sqlite3");
+            if (mode === "episodes") {
+              const db = new Database2(epDbPath, { readonly: true });
+              const queryLower = query.toLowerCase();
+              const rows = db.prepare(`
+            SELECT * FROM episodes
+            WHERE content LIKE ? OR tool_name LIKE ?
+            ORDER BY importance DESC, timestamp DESC
+            LIMIT ?
+          `).all(`%${queryLower}%`, `%${queryLower}%`, maxResults);
+              db.close();
+              if (rows.length === 0) {
+                return { success: true, output: `No episodes found for "${query}".`, durationMs: performance.now() - start2 };
+              }
+              const lines = rows.map((r2) => `[${r2.tool_name ?? r2.modality}] (importance: ${r2.importance}, decay: ${r2.decay_class})
+  ${r2.content.slice(0, 200)}`);
+              return {
+                success: true,
+                output: `Episode search for "${query}" (${rows.length} results):
+
+${lines.join("\n\n")}`,
+                durationMs: performance.now() - start2
+              };
+            }
+            if (mode === "graph" && pathExists(kgDbPath)) {
+              const db = new Database2(kgDbPath, { readonly: true });
+              const queryLower = query.toLowerCase();
+              const nodes = db.prepare(`
+            SELECT * FROM kg_nodes WHERE text LIKE ? ORDER BY mention_count DESC LIMIT 20
+          `).all(`%${queryLower}%`);
+              const episodeIds = /* @__PURE__ */ new Set();
+              const nodeInfo = [];
+              for (const node of nodes.slice(0, 5)) {
+                const edges = db.prepare(`
+              SELECT * FROM kg_edges WHERE (src_id = ? OR dst_id = ?) AND valid_until IS NULL
+            `).all(node.id, node.id);
+                nodeInfo.push(`${node.text} (${node.node_type}, ${node.mention_count} mentions, ${edges.length} edges)`);
+                for (const edge of edges) {
+                  if (edge.source_episode_id)
+                    episodeIds.add(edge.source_episode_id);
+                }
+              }
+              db.close();
+              const epLines = [];
+              if (episodeIds.size > 0 && pathExists(epDbPath)) {
+                const epDb = new Database2(epDbPath, { readonly: true });
+                for (const epId of [...episodeIds].slice(0, maxResults)) {
+                  const ep = epDb.prepare("SELECT * FROM episodes WHERE id = ?").get(epId);
+                  if (ep)
+                    epLines.push(`[${ep.tool_name ?? ep.modality}] ${ep.content.slice(0, 150)}`);
+                }
+                epDb.close();
+              }
+              const output = [
+                `Knowledge graph search for "${query}":`,
+                `
+Nodes found: ${nodes.length}`,
+                nodeInfo.length > 0 ? nodeInfo.map((n2) => `  - ${n2}`).join("\n") : "  (no matching nodes)",
+                epLines.length > 0 ? `
+Linked episodes (${epLines.length}):
+${epLines.map((l2) => `  ${l2}`).join("\n")}` : ""
+              ].filter(Boolean).join("\n");
+              return { success: true, output, durationMs: performance.now() - start2 };
+            }
+          } catch {
+          }
+        }
         try {
           const allEntries = await this.loadAllMemories();
           if (allEntries.length === 0) {
@@ -265232,9 +265317,214 @@ var init_gistCompressor = __esm({
   }
 });
 
+// packages/memory/dist/pprRetrieval.js
+function extractQueryEntities(query) {
+  const entities = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add2 = (text) => {
+    const normalized = text.trim().toLowerCase();
+    if (normalized.length < 2 || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    entities.push(text.trim());
+  };
+  const filePattern = /(?:[\w./-]+\/[\w./-]+|[\w-]+\.\w{1,5})\b/g;
+  for (const match of query.matchAll(filePattern)) {
+    if (match[0].includes(".") || match[0].includes("/"))
+      add2(match[0]);
+  }
+  const errorPattern = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b|\b\w+(?:Error|Exception|Failed|Failure)\b/g;
+  for (const match of query.matchAll(errorPattern))
+    add2(match[0]);
+  const toolPattern = /\b(?:file_read|file_write|file_edit|shell|grep_search|find_files|memory_\w+|web_\w+|camera_\w+|audio_\w+|wifi_\w+|bluetooth_\w+|sdr_\w+|flipper_\w+|meshtastic|gps_\w+|visual_\w+)\b/g;
+  for (const match of query.matchAll(toolPattern))
+    add2(match[0]);
+  const quotedPattern = /["']([^"']{2,50})["']/g;
+  for (const match of query.matchAll(quotedPattern))
+    add2(match[1]);
+  const STOP_WORDS2 = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "was",
+    "are",
+    "not",
+    "but",
+    "had",
+    "has",
+    "have",
+    "this",
+    "that",
+    "with",
+    "from",
+    "what",
+    "when",
+    "where",
+    "how",
+    "why",
+    "which",
+    "who",
+    "did",
+    "does",
+    "can",
+    "could",
+    "would",
+    "should",
+    "will",
+    "been",
+    "being",
+    "were",
+    "about",
+    "than",
+    "then",
+    "also",
+    "just",
+    "more",
+    "some",
+    "only",
+    "into",
+    "over"
+  ]);
+  const words = query.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS2.has(w.toLowerCase()));
+  for (const word2 of words) {
+    if (/^[A-Z]/.test(word2) || /[._-]/.test(word2) || /\d/.test(word2)) {
+      add2(word2.replace(/[.,;:!?]+$/, ""));
+    }
+  }
+  return entities;
+}
+function personalizedPageRank(graph, seedNodeIds, config) {
+  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const scores = /* @__PURE__ */ new Map();
+  if (seedNodeIds.length === 0)
+    return scores;
+  const nodeCount = graph.nodeCount();
+  if (nodeCount === 0)
+    return scores;
+  const teleportProb = 1 / seedNodeIds.length;
+  const seedSet = new Set(seedNodeIds);
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const seedId of seedNodeIds) {
+    allNodes.add(seedId);
+    const neighbors2 = graph.neighbors(seedId);
+    for (const { node } of neighbors2) {
+      allNodes.add(node.id);
+      const hop2 = graph.neighbors(node.id);
+      for (const { node: n2 } of hop2)
+        allNodes.add(n2.id);
+    }
+  }
+  for (const nodeId of allNodes) {
+    scores.set(nodeId, seedSet.has(nodeId) ? teleportProb : 0);
+  }
+  for (let iter = 0; iter < cfg.maxIterations; iter++) {
+    const newScores = /* @__PURE__ */ new Map();
+    let maxDelta = 0;
+    for (const nodeId of allNodes) {
+      const teleport = seedSet.has(nodeId) ? (1 - cfg.damping) * teleportProb : 0;
+      let walkSum = 0;
+      const inEdges = graph.currentEdges(nodeId);
+      for (const edge of inEdges) {
+        const neighborId = edge.srcId === nodeId ? edge.dstId : edge.srcId;
+        const neighborScore = scores.get(neighborId) ?? 0;
+        const neighborOutDegree = graph.currentEdges(neighborId).length || 1;
+        walkSum += neighborScore / neighborOutDegree;
+      }
+      const newScore = teleport + cfg.damping * walkSum;
+      newScores.set(nodeId, newScore);
+      const delta = Math.abs(newScore - (scores.get(nodeId) ?? 0));
+      if (delta > maxDelta)
+        maxDelta = delta;
+    }
+    for (const [id, score] of newScores)
+      scores.set(id, score);
+    if (maxDelta < cfg.convergenceThreshold) {
+      return scores;
+    }
+  }
+  return scores;
+}
+function retrieveByPPR(query, graph, episodeStore, config) {
+  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const queryEntities = extractQueryEntities(query);
+  if (queryEntities.length === 0) {
+    return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
+  }
+  const seedNodes = [];
+  for (const entity of queryEntities) {
+    const node = graph.findNode(entity);
+    if (node) {
+      seedNodes.push(node.id);
+      continue;
+    }
+    for (const nodeType of ["file", "error", "tool", "entity", "event", "concept", "person"]) {
+      const candidates = graph.nodesByType(nodeType, 50);
+      for (const candidate of candidates) {
+        if (candidate.text.toLowerCase().includes(entity.toLowerCase()) || entity.toLowerCase().includes(candidate.text.toLowerCase())) {
+          seedNodes.push(candidate.id);
+          break;
+        }
+      }
+      if (seedNodes.length > queryEntities.indexOf(entity))
+        break;
+    }
+  }
+  if (seedNodes.length === 0) {
+    return { episodes: [], queryEntities, seedNodes: [], iterations: 0 };
+  }
+  const pprScores = personalizedPageRank(graph, seedNodes, cfg);
+  const episodeScores = /* @__PURE__ */ new Map();
+  for (const [nodeId, score] of pprScores) {
+    if (score < 1e-3)
+      continue;
+    const node = graph.getNode(nodeId);
+    if (!node)
+      continue;
+    const edges = graph.currentEdges(nodeId);
+    for (const edge of edges) {
+      if (edge.sourceEpisodeId) {
+        const existing = episodeScores.get(edge.sourceEpisodeId);
+        if (existing) {
+          existing.score += score;
+          existing.matchedNodes.push(node.text);
+        } else {
+          episodeScores.set(edge.sourceEpisodeId, { score, matchedNodes: [node.text] });
+        }
+      }
+    }
+  }
+  const ranked = [...episodeScores.entries()].sort((a2, b) => b[1].score - a2[1].score).slice(0, cfg.topK);
+  const episodes = [];
+  for (const [epId, { score, matchedNodes }] of ranked) {
+    const episode = episodeStore.get(epId);
+    if (episode) {
+      episodes.push({ episode, pprScore: score, matchedNodes: [...new Set(matchedNodes)] });
+    }
+  }
+  return {
+    episodes,
+    queryEntities,
+    seedNodes,
+    iterations: cfg.maxIterations
+  };
+}
+var DEFAULT_CONFIG5;
+var init_pprRetrieval = __esm({
+  "packages/memory/dist/pprRetrieval.js"() {
+    "use strict";
+    init_zettelkasten();
+    DEFAULT_CONFIG5 = {
+      damping: 0.5,
+      maxIterations: 50,
+      convergenceThreshold: 1e-6,
+      topK: 10
+    };
+  }
+});
+
 // packages/memory/dist/embeddings.js
 async function generateEmbedding(text, config) {
-  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const cfg = { ...DEFAULT_CONFIG6, ...config };
   try {
     const url = `${cfg.baseUrl}/api/embed`;
     const resp = await fetch(url, {
@@ -265269,7 +265559,7 @@ async function generateEmbedding(text, config) {
   }
 }
 async function checkEmbeddingAvailable(config) {
-  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const cfg = { ...DEFAULT_CONFIG6, ...config };
   try {
     const resp = await fetch(`${cfg.baseUrl}/api/tags`, {
       signal: AbortSignal.timeout(5e3)
@@ -265296,11 +265586,11 @@ async function pullEmbeddingModel(baseUrl, model, timeoutMs) {
     return false;
   }
 }
-var DEFAULT_CONFIG5;
+var DEFAULT_CONFIG6;
 var init_embeddings = __esm({
   "packages/memory/dist/embeddings.js"() {
     "use strict";
-    DEFAULT_CONFIG5 = {
+    DEFAULT_CONFIG6 = {
       baseUrl: "http://localhost:11434",
       model: "nomic-embed-text",
       timeoutMs: 3e4
@@ -265332,6 +265622,7 @@ var init_dist7 = __esm({
     init_temporalGraph();
     init_zettelkasten();
     init_gistCompressor();
+    init_pprRetrieval();
     init_embeddings();
     init_proceduralMemoryStore();
   }
@@ -267000,6 +267291,21 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             if (compacted.length < prevLen)
               recentToolResults.clear();
           }
+          if (turn > 0 && turn % 3 === 0 && this._temporalGraph && this._episodeStore) {
+            try {
+              const taskGoal = this._taskState.goal || task.slice(0, 200);
+              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, { topK: 3 });
+              if (pprResult.episodes.length > 0) {
+                const memoryLines = pprResult.episodes.map(({ episode, pprScore, matchedNodes }) => `- [${episode.toolName ?? episode.modality}] ${episode.content.slice(0, 120)} (via: ${matchedNodes.slice(0, 2).join(", ")})`);
+                compacted.push({
+                  role: "system",
+                  content: `[Associative Memory \u2014 related prior experience]
+${memoryLines.join("\n")}`
+                });
+              }
+            } catch {
+            }
+          }
           if (this.options.environmentProvider) {
             try {
               const envStr = this.options.environmentProvider();

package/package.json

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