open-agents-ai 0.33.0 → 0.34.0

package/dist/index.js

@@ -10083,6 +10083,55 @@ var init_lexicalSearch = __esm({
 });
 
 // packages/retrieval/dist/semanticSearch.js
+function parseTagFilter(query) {
+  const required = [];
+  const anyOf = [];
+  const excluded = [];
+  const cleanParts = [];
+  for (const token of query.split(/\s+/)) {
+    if (token.startsWith("+") && token.length > 1) {
+      required.push(token.slice(1).toLowerCase());
+    } else if (token.startsWith("~") && token.length > 1) {
+      anyOf.push(token.slice(1).toLowerCase());
+    } else if (token.startsWith("-") && token.length > 1 && !/^\d/.test(token.slice(1))) {
+      excluded.push(token.slice(1).toLowerCase());
+    } else {
+      cleanParts.push(token);
+    }
+  }
+  const hasFilter = required.length > 0 || anyOf.length > 0 || excluded.length > 0;
+  return {
+    cleanQuery: cleanParts.join(" "),
+    tagFilter: hasFilter ? { required, anyOf, excluded } : null
+  };
+}
+function matchesTagFilter(text, filter) {
+  const lowerText = text.toLowerCase();
+  const clusteringTags = /* @__PURE__ */ new Set();
+  for (const match of lowerText.matchAll(/clustering:(\S+)/g)) {
+    clusteringTags.add(match[1]);
+  }
+  const domainMatch = lowerText.match(/domain:\s*(\S+)/);
+  if (domainMatch)
+    clusteringTags.add(domainMatch[1]);
+  const riskMatch = lowerText.match(/risk:\s*(\S+)/);
+  if (riskMatch)
+    clusteringTags.add(riskMatch[1]);
+  for (const tag of filter.required) {
+    if (!clusteringTags.has(tag) && !lowerText.includes(tag))
+      return false;
+  }
+  if (filter.anyOf.length > 0) {
+    const hasAny = filter.anyOf.some((tag) => clusteringTags.has(tag) || lowerText.includes(tag));
+    if (!hasAny)
+      return false;
+  }
+  for (const tag of filter.excluded) {
+    if (clusteringTags.has(tag))
+      return false;
+  }
+  return true;
+}
 function cosineSimilarity(a, b) {
   if (a.length !== b.length || a.length === 0)
     return 0;
@@ -10108,7 +10157,7 @@ function makePlaceholderSummary(filePath) {
     lastIndexed: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var StubSemanticSearchEngine, IndexBackedSemanticSearchEngine;
+var StubSemanticSearchEngine, IndexBackedSemanticSearchEngine, LazySemanticSearchEngine;
 var init_semanticSearch = __esm({
   "packages/retrieval/dist/semanticSearch.js"() {
     "use strict";
@@ -10129,11 +10178,26 @@ var init_semanticSearch = __esm({
         if (!this.isAvailable)
           return [];
         const queryVector = await this.options.embedQuery(query);
+        const { cleanQuery, tagFilter } = parseTagFilter(query);
+        const searchVector = cleanQuery !== query ? await this.options.embedQuery(cleanQuery) : queryVector;
         const scored = this.options.index.map((item) => ({
           filePath: item.filePath,
-          score: cosineSimilarity(queryVector, item.vector)
+          score: cosineSimilarity(searchVector, item.vector),
+          text: item.text
         }));
-        return scored.sort((a, b) => b.score - a.score).slice(0, topK).map(({ filePath, score }) => {
+        let filtered = scored;
+        if (tagFilter) {
+          filtered = scored.filter((item) => matchesTagFilter(item.text, tagFilter));
+        }
+        const byFile = /* @__PURE__ */ new Map();
+        for (const item of filtered) {
+          const existing = byFile.get(item.filePath);
+          if (!existing || item.score > existing.score) {
+            byFile.set(item.filePath, item);
+          }
+        }
+        const deduped = Array.from(byFile.values());
+        return deduped.sort((a, b) => b.score - a.score).slice(0, topK).map(({ filePath, score }) => {
           const summary = this.options.summaryMap.get(filePath);
           return {
             filePath,
@@ -10143,6 +10207,74 @@ var init_semanticSearch = __esm({
           };
         });
       }
+      /**
+       * Pattern 7: Find semantically related items in the index.
+       * Returns pairs of items with >threshold similarity.
+       * Useful for auto-linking related memories/files.
+       */
+      findRelated(filePath, threshold = 0.7, maxResults = 5) {
+        const sourceItem = this.options.index.find((i) => i.filePath === filePath);
+        if (!sourceItem)
+          return [];
+        const scored = this.options.index.filter((i) => i.filePath !== filePath).map((item) => ({
+          filePath: item.filePath,
+          score: cosineSimilarity(sourceItem.vector, item.vector)
+        })).filter((r) => r.score >= threshold).sort((a, b) => b.score - a.score).slice(0, maxResults);
+        return scored;
+      }
+    };
+    LazySemanticSearchEngine = class {
+      inner = null;
+      buildPromise = null;
+      buildFailed = false;
+      opts;
+      constructor(opts) {
+        this.opts = opts;
+      }
+      get isAvailable() {
+        return this.inner?.isAvailable ?? false;
+      }
+      /**
+       * Trigger index building in the background.
+       * Call this during idle time to pre-warm the index.
+       */
+      warmUp() {
+        if (!this.buildPromise && !this.inner && !this.buildFailed) {
+          this.buildPromise = this.build();
+        }
+      }
+      async search(query, topK = 10) {
+        if (this.inner)
+          return this.inner.search(query, topK);
+        if (this.buildFailed)
+          return [];
+        if (!this.buildPromise) {
+          this.buildPromise = this.build();
+        }
+        const timeoutMs = this.opts.timeoutMs ?? 6e4;
+        try {
+          await Promise.race([
+            this.buildPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Index build timeout")), timeoutMs))
+          ]);
+        } catch {
+          return [];
+        }
+        return this.searchInner(query, topK);
+      }
+      searchInner(query, topK) {
+        if (this.inner)
+          return this.inner.search(query, topK);
+        return Promise.resolve([]);
+      }
+      async build() {
+        try {
+          const options = await this.opts.buildIndex();
+          this.inner = new IndexBackedSemanticSearchEngine(options);
+        } catch {
+          this.buildFailed = true;
+        }
+      }
     };
   }
 });
@@ -10299,24 +10431,41 @@ async function assembleContext(request, opts) {
     Promise.all(request.errorHint.slice(0, maxLogs).map((e) => searchByError(e, { rootDir: repoRoot, maxMatches: 5 }))).then((res) => res.flat()),
     semanticEngine?.isAvailable ? semanticEngine.search(request.query, maxFiles) : Promise.resolve([])
   ]);
-  const seenFiles = /* @__PURE__ */ new Set();
-  const candidateFiles = [];
-  function addCandidate(relativePath, priority) {
-    if (seenFiles.has(relativePath))
-      return;
-    seenFiles.add(relativePath);
-    candidateFiles.push({ relativePath, priority });
-  }
+  const queryType = classifyQuery(request.query);
+  const rrfK = adaptiveK(queryType, opts.rrfConfig?.k);
+  const wFts = opts.rrfConfig?.weightFts ?? 1;
+  const wSem = opts.rrfConfig?.weightSemantic ?? 1;
+  const lexicalCandidates = [];
   for (const m of pathMatches)
-    addCandidate(m.relativePath, 100);
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 100 });
   for (const m of symbolMatches)
-    addCandidate(m.relativePath, 80);
-  for (const r of semanticResults) {
-    addCandidate(r.filePath, Math.round(50 + r.score * 30));
-  }
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 80 });
   for (const m of errorMatches)
-    addCandidate(m.relativePath, 40);
-  const topFiles = candidateFiles.sort((a, b) => b.priority - a.priority).slice(0, maxFiles);
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 40 });
+  const lexDedup = /* @__PURE__ */ new Map();
+  for (const c3 of lexicalCandidates) {
+    const existing = lexDedup.get(c3.relativePath) ?? 0;
+    lexDedup.set(c3.relativePath, Math.max(existing, c3.basePriority));
+  }
+  const lexRanked = Array.from(lexDedup.entries()).sort((a, b) => b[1] - a[1]).map(([path], idx) => ({ path, rank: idx + 1 }));
+  const semRanked = semanticResults.sort((a, b) => b.score - a.score).map((r, idx) => ({ path: r.filePath, rank: idx + 1, score: r.score }));
+  const rrfScores = /* @__PURE__ */ new Map();
+  const lexRankMap = new Map(lexRanked.map((l) => [l.path, l.rank]));
+  const semRankMap = new Map(semRanked.map((s) => [s.path, s.rank]));
+  const allPaths = /* @__PURE__ */ new Set([...lexRankMap.keys(), ...semRankMap.keys()]);
+  for (const p of allPaths) {
+    const lexRank = lexRankMap.get(p);
+    const semRank = semRankMap.get(p);
+    let score = 0;
+    if (lexRank !== void 0)
+      score += wFts / (rrfK + lexRank);
+    if (semRank !== void 0)
+      score += wSem / (rrfK + semRank);
+    rrfScores.set(p, score);
+  }
+  const candidateFiles = Array.from(rrfScores.entries()).sort((a, b) => b[1] - a[1]).map(([relativePath, priority]) => ({ relativePath, priority: Math.round(priority * 1e3) }));
+  const seenFiles = new Set(candidateFiles.map((c3) => c3.relativePath));
+  const topFiles = candidateFiles.slice(0, maxFiles);
   const neighborFiles = [];
   if (expandNeighbors && graph) {
     const seedPaths = topFiles.map((f) => f.relativePath);
@@ -10361,6 +10510,39 @@ async function assembleContext(request, opts) {
     assembledAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function classifyQuery(query) {
+  const trimmed = query.trim();
+  if (/^["'].*["']$/.test(trimmed) || /"[^"]+"/.test(trimmed))
+    return "quoted";
+  if (/(?:error|exception|stack|traceback|ENOENT|EPERM|TypeError|SyntaxError)/i.test(trimmed))
+    return "error";
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(trimmed))
+    return "symbol";
+  const wordCount = trimmed.split(/\s+/).length;
+  if (wordCount <= 3)
+    return "short";
+  return "long";
+}
+function adaptiveK(queryType, overrideK) {
+  if (overrideK !== void 0)
+    return overrideK;
+  switch (queryType) {
+    case "short":
+      return 30;
+    // tight — top results matter more
+    case "quoted":
+      return 20;
+    // very tight — exact match should win
+    case "symbol":
+      return 25;
+    // tight — symbol search is precise
+    case "error":
+      return 40;
+    // moderate — errors need breadth
+    case "long":
+      return 60;
+  }
+}
 function buildSymbolSnippets(symbolMatches, maxSnippets) {
   const byFile = /* @__PURE__ */ new Map();
   for (const m of symbolMatches) {
@@ -10403,8 +10585,10 @@ __export(dist_exports, {
   CodeRetriever: () => CodeRetriever,
   GrepSearch: () => GrepSearch,
   IndexBackedSemanticSearchEngine: () => IndexBackedSemanticSearchEngine,
+  LazySemanticSearchEngine: () => LazySemanticSearchEngine,
   StubSemanticSearchEngine: () => StubSemanticSearchEngine,
   assembleContext: () => assembleContext,
+  classifyQuery: () => classifyQuery,
   estimatePacketTokens: () => estimatePacketTokens,
   estimateTokens: () => estimateTokens,
   expandGraph: () => expandGraph,
@@ -10412,6 +10596,7 @@ __export(dist_exports, {
   oneHopNeighbors: () => oneHopNeighbors,
   packFiles: () => packFiles,
   packSnippets: () => packSnippets,
+  parseTagFilter: () => parseTagFilter,
   searchByError: () => searchByError,
   searchByPath: () => searchByPath,
   searchByQuery: () => searchByQuery,

package/package.json

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