@optave/codegraph 3.1.5 → 3.3.0

package/src/domain/parser.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Language, Parser, Query } from 'web-tree-sitter';
-import { warn } from '../infrastructure/logger.js';
+import { debug, warn } from '../infrastructure/logger.js';
 import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
 
 // Re-export all extractors for backward compatibility
@@ -116,29 +116,35 @@ export async function createParsers() {
  */
 export function disposeParsers() {
   if (_cachedParsers) {
-    for (const [, parser] of _cachedParsers) {
+    for (const [id, parser] of _cachedParsers) {
       if (parser && typeof parser.delete === 'function') {
         try {
           parser.delete();
-        } catch {}
+        } catch (e) {
+          debug(`Failed to dispose parser ${id}: ${e.message}`);
+        }
       }
     }
     _cachedParsers = null;
   }
-  for (const [, query] of _queryCache) {
+  for (const [id, query] of _queryCache) {
     if (query && typeof query.delete === 'function') {
       try {
         query.delete();
-      } catch {}
+      } catch (e) {
+        debug(`Failed to dispose query ${id}: ${e.message}`);
+      }
     }
   }
   _queryCache.clear();
   if (_cachedLanguages) {
-    for (const [, lang] of _cachedLanguages) {
+    for (const [id, lang] of _cachedLanguages) {
       if (lang && typeof lang.delete === 'function') {
         try {
           lang.delete();
-        } catch {}
+        } catch (e) {
+          debug(`Failed to dispose language ${id}: ${e.message}`);
+        }
       }
     }
     _cachedLanguages = null;
@@ -189,14 +195,15 @@ export async function ensureWasmTrees(fileSymbols, rootDir) {
     let code;
     try {
       code = fs.readFileSync(absPath, 'utf-8');
-    } catch {
+    } catch (e) {
+      debug(`ensureWasmTrees: cannot read ${relPath}: ${e.message}`);
       continue;
     }
     try {
       symbols._tree = parser.parse(code);
       symbols._langId = entry.id;
-    } catch {
-      // skip files that fail to parse
+    } catch (e) {
+      debug(`ensureWasmTrees: parse failed for ${relPath}: ${e.message}`);
     }
   }
 }
@@ -313,7 +320,7 @@ export const LANGUAGE_REGISTRY = [
   },
   {
     id: 'python',
-    extensions: ['.py'],
+    extensions: ['.py', '.pyi'],
     grammarFile: 'tree-sitter-python.wasm',
     extractor: extractPythonSymbols,
     required: false,
@@ -348,14 +355,14 @@ export const LANGUAGE_REGISTRY = [
   },
   {
     id: 'ruby',
-    extensions: ['.rb'],
+    extensions: ['.rb', '.rake', '.gemspec'],
     grammarFile: 'tree-sitter-ruby.wasm',
     extractor: extractRubySymbols,
     required: false,
   },
   {
     id: 'php',
-    extensions: ['.php'],
+    extensions: ['.php', '.phtml'],
     grammarFile: 'tree-sitter-php.wasm',
     extractor: extractPHPSymbols,
     required: false,
@@ -371,6 +378,31 @@ for (const entry of LANGUAGE_REGISTRY) {
 
 export const SUPPORTED_EXTENSIONS = new Set(_extToLang.keys());
 
+/**
+ * WASM-based typeMap backfill for older native binaries that don't emit typeMap.
+ * Uses tree-sitter AST extraction instead of regex to avoid false positives from
+ * matches inside comments and string literals.
+ * TODO: Remove once all published native binaries include typeMap extraction (>= 3.2.0)
+ */
+async function backfillTypeMap(filePath, source) {
+  let code = source;
+  if (!code) {
+    try {
+      code = fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      return { typeMap: [], backfilled: false };
+    }
+  }
+  const parsers = await createParsers();
+  const extracted = wasmExtractSymbols(parsers, filePath, code);
+  if (!extracted?.symbols?.typeMap) return { typeMap: [], backfilled: false };
+  const tm = extracted.symbols.typeMap;
+  return {
+    typeMap: tm instanceof Map ? tm : new Map(tm.map((e) => [e.name, e.typeName])),
+    backfilled: true,
+  };
+}
+
 /**
  * WASM extraction helper: picks the right extractor based on file extension.
  */
@@ -407,7 +439,14 @@ export async function parseFileAuto(filePath, source, opts = {}) {
 
   if (native) {
     const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
-    return result ? patchNativeResult(result) : null;
+    if (!result) return null;
+    const patched = patchNativeResult(result);
+    if (!patched.typeMap || patched.typeMap.length === 0) {
+      const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
+      patched.typeMap = typeMap;
+      if (backfilled) patched._typeMapBackfilled = true;
+    }
+    return patched;
   }
 
   // WASM path
@@ -435,10 +474,35 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
       !!opts.dataflow,
       opts.ast !== false,
     );
+    const needsTypeMap = [];
     for (const r of nativeResults) {
       if (!r) continue;
+      const patched = patchNativeResult(r);
       const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
-      result.set(relPath, patchNativeResult(r));
+      result.set(relPath, patched);
+      if (!patched.typeMap || patched.typeMap.length === 0) {
+        needsTypeMap.push({ filePath: r.file, relPath });
+      }
+    }
+    // Backfill typeMap via WASM for native binaries that predate the type-map feature
+    if (needsTypeMap.length > 0) {
+      const parsers = await createParsers();
+      for (const { filePath, relPath } of needsTypeMap) {
+        try {
+          const code = fs.readFileSync(filePath, 'utf-8');
+          const extracted = wasmExtractSymbols(parsers, filePath, code);
+          if (extracted?.symbols?.typeMap) {
+            const symbols = result.get(relPath);
+            symbols.typeMap =
+              extracted.symbols.typeMap instanceof Map
+                ? extracted.symbols.typeMap
+                : new Map(extracted.symbols.typeMap.map((e) => [e.name, e.typeName]));
+            symbols._typeMapBackfilled = true;
+          }
+        } catch {
+          /* skip — typeMap is a best-effort backfill */
+        }
+      }
     }
     return result;
   }
@@ -483,7 +547,9 @@ export function getActiveEngine(opts = {}) {
   if (native) {
     try {
       version = getNativePackageVersion() ?? version;
-    } catch {}
+    } catch (e) {
+      debug(`getNativePackageVersion failed: ${e.message}`);
+    }
   }
   return { name, version };
 }
@@ -510,7 +576,14 @@ export function createParseTreeCache() {
 export async function parseFileIncremental(cache, filePath, source, opts = {}) {
   if (cache) {
     const result = cache.parseFile(filePath, source);
-    return result ? patchNativeResult(result) : null;
+    if (!result) return null;
+    const patched = patchNativeResult(result);
+    if (!patched.typeMap || patched.typeMap.length === 0) {
+      const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
+      patched.typeMap = typeMap;
+      if (backfilled) patched._typeMapBackfilled = true;
+    }
+    return patched;
   }
   return parseFileAuto(filePath, source, opts);
 }

package/src/domain/queries.js

@@ -22,6 +22,7 @@ export {
 } from '../shared/kinds.js';
 // ── Shared utilities ─────────────────────────────────────────────────────
 export { kindIcon, normalizeSymbol } from '../shared/normalize.js';
+export { briefData } from './analysis/brief.js';
 export { contextData, explainData } from './analysis/context.js';
 export { fileDepsData, fnDepsData, pathData } from './analysis/dependencies.js';
 export { exportsData } from './analysis/exports.js';
@@ -31,6 +32,7 @@ export {
   fnImpactData,
   impactAnalysisData,
 } from './analysis/impact.js';
+export { implementationsData, interfacesData } from './analysis/implementations.js';
 export {
   FALSE_POSITIVE_CALLER_THRESHOLD,
   FALSE_POSITIVE_NAMES,

package/src/domain/search/search/filters.js

@@ -29,15 +29,19 @@ const TEST_PATTERN = /\.(test|spec)\.|__test__|__tests__|\.stories\./;
  * @param {object} opts
  * @param {string} [opts.filePattern] - Glob pattern (only applied if it contains glob chars)
  * @param {boolean} [opts.noTests] - Exclude test/spec files
- * @param {boolean} [opts.isGlob] - Pre-computed: does filePattern contain glob chars?
  * @returns {Array}
  */
 export function applyFilters(rows, opts = {}) {
   let filtered = rows;
-  const isGlob =
-    opts.isGlob !== undefined ? opts.isGlob : opts.filePattern && /[*?[\]]/.test(opts.filePattern);
-  if (isGlob) {
-    filtered = filtered.filter((row) => globMatch(row.file, opts.filePattern));
+  const fp = opts.filePattern;
+  const fpArr = Array.isArray(fp) ? fp : fp ? [fp] : [];
+  if (fpArr.length > 0) {
+    filtered = filtered.filter((row) =>
+      fpArr.some((p) => {
+        const patternIsGlob = /[*?[\]]/.test(p);
+        return patternIsGlob ? globMatch(row.file, p) : row.file.includes(p);
+      }),
+    );
   }
   if (opts.noTests) {
     filtered = filtered.filter((row) => !TEST_PATTERN.test(row.file));

package/src/domain/search/search/hybrid.js

@@ -1,4 +1,5 @@
 import { openReadonlyOrFail } from '../../../db/index.js';
+import { loadConfig } from '../../../infrastructure/config.js';
 import { hasFtsIndex } from '../stores/fts5.js';
 import { ftsSearchData } from './keyword.js';
 import { searchData } from './semantic.js';
@@ -9,9 +10,11 @@ import { searchData } from './semantic.js';
  * or null if no FTS5 index (caller should fall back to semantic-only).
  */
 export async function hybridSearchData(query, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const k = opts.rrfK || 60;
-  const topK = (opts.limit || 15) * 5;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
+  const topK = (opts.limit ?? searchCfg.topK ?? 15) * 5;
 
   // Split semicolons for multi-query support
   const queries =
@@ -49,7 +52,7 @@ export async function hybridSearchData(query, customDbPath, opts = {}) {
     const semData = await searchData(q, customDbPath, {
       ...opts,
       limit: topK,
-      minScore: opts.minScore || 0.2,
+      minScore: opts.minScore ?? 0.2,
     });
     if (semData?.results) {
       rankedLists.push(

package/src/domain/search/search/keyword.js

@@ -1,4 +1,5 @@
 import { openReadonlyOrFail } from '../../../db/index.js';
+import { buildFileConditionSQL } from '../../../db/query-builder.js';
 import { normalizeSymbol } from '../../queries.js';
 import { hasFtsIndex, sanitizeFtsQuery } from '../stores/fts5.js';
 import { applyFilters } from './filters.js';
@@ -36,10 +37,16 @@ export function ftsSearchData(query, customDbPath, opts = {}) {
       params.push(opts.kind);
     }
 
-    const isGlob = opts.filePattern && /[*?[\]]/.test(opts.filePattern);
-    if (opts.filePattern && !isGlob) {
-      sql += ' AND n.file LIKE ?';
-      params.push(`%${opts.filePattern}%`);
+    const fp = opts.filePattern;
+    const fpArr = Array.isArray(fp) ? fp : fp ? [fp] : [];
+    const isGlob = fpArr.length > 0 && fpArr.some((p) => /[*?[\]]/.test(p));
+    // For non-glob patterns, push filtering into SQL via buildFileConditionSQL
+    // (handles escapeLike + ESCAPE clause). Glob patterns are handled post-query
+    // by applyFilters.
+    if (fpArr.length > 0 && !isGlob) {
+      const fc = buildFileConditionSQL(fpArr, 'n.file');
+      sql += fc.sql;
+      params.push(...fc.params);
     }
 
     sql += ' ORDER BY rank LIMIT ?';
@@ -53,7 +60,7 @@ export function ftsSearchData(query, customDbPath, opts = {}) {
       return { results: [] };
     }
 
-    rows = applyFilters(rows, { ...opts, isGlob });
+    rows = applyFilters(rows, opts);
 
     const hc = new Map();
     const results = rows.slice(0, limit).map((row) => ({

package/src/domain/search/search/prepare.js

@@ -1,4 +1,5 @@
 import { openReadonlyOrFail } from '../../../db/index.js';
+import { escapeLike } from '../../../db/query-builder.js';
 import { getEmbeddingCount, getEmbeddingMeta } from '../../../db/repository/embeddings.js';
 import { MODELS } from '../models.js';
 import { applyFilters } from './filters.js';
@@ -35,7 +36,9 @@ export function prepareSearch(customDbPath, opts = {}) {
     }
 
     // Pre-filter: allow filtering by kind or file pattern to reduce search space
-    const isGlob = opts.filePattern && /[*?[\]]/.test(opts.filePattern);
+    const fp = opts.filePattern;
+    const fpArr = Array.isArray(fp) ? fp : fp ? [fp] : [];
+    const isGlob = fpArr.length > 0 && fpArr.some((p) => /[*?[\]]/.test(p));
     let sql = `
     SELECT e.node_id, e.vector, e.text_preview, n.name, n.kind, n.file, n.line, n.end_line, n.role
     FROM embeddings e
@@ -47,16 +50,21 @@ export function prepareSearch(customDbPath, opts = {}) {
       conditions.push('n.kind = ?');
       params.push(opts.kind);
     }
-    if (opts.filePattern && !isGlob) {
-      conditions.push('n.file LIKE ?');
-      params.push(`%${opts.filePattern}%`);
+    if (fpArr.length > 0 && !isGlob) {
+      if (fpArr.length === 1) {
+        conditions.push("n.file LIKE ? ESCAPE '\\'");
+        params.push(`%${escapeLike(fpArr[0])}%`);
+      } else {
+        conditions.push(`(${fpArr.map(() => "n.file LIKE ? ESCAPE '\\'").join(' OR ')})`);
+        params.push(...fpArr.map((f) => `%${escapeLike(f)}%`));
+      }
     }
     if (conditions.length > 0) {
       sql += ` WHERE ${conditions.join(' AND ')}`;
     }
 
     let rows = db.prepare(sql).all(...params);
-    rows = applyFilters(rows, { ...opts, isGlob });
+    rows = applyFilters(rows, opts);
 
     return { db, rows, modelKey, storedDim };
   } catch (err) {

package/src/domain/search/search/semantic.js

@@ -1,3 +1,4 @@
+import { loadConfig } from '../../../infrastructure/config.js';
 import { warn } from '../../../infrastructure/logger.js';
 import { normalizeSymbol } from '../../queries.js';
 import { embed } from '../models.js';
@@ -9,8 +10,10 @@ import { prepareSearch } from './prepare.js';
  * Returns { results: [{ name, kind, file, line, similarity }] } or null on failure.
  */
 export async function searchData(query, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const minScore = opts.minScore || 0.2;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const minScore = opts.minScore ?? searchCfg.defaultMinScore ?? 0.2;
 
   const prepared = prepareSearch(customDbPath, opts);
   if (!prepared) return null;
@@ -56,9 +59,11 @@ export async function searchData(query, customDbPath, opts = {}) {
  * Returns { results: [{ name, kind, file, line, rrf, queryScores }] } or null on failure.
  */
 export async function multiSearchData(queries, customDbPath, opts = {}) {
-  const limit = opts.limit || 15;
-  const minScore = opts.minScore || 0.2;
-  const k = opts.rrfK || 60;
+  const config = opts.config || loadConfig();
+  const searchCfg = config.search || {};
+  const limit = opts.limit ?? searchCfg.topK ?? 15;
+  const minScore = opts.minScore ?? searchCfg.defaultMinScore ?? 0.2;
+  const k = opts.rrfK ?? searchCfg.rrfK ?? 60;
 
   const prepared = prepareSearch(customDbPath, opts);
   if (!prepared) return null;
@@ -68,7 +73,7 @@ export async function multiSearchData(queries, customDbPath, opts = {}) {
     const { vectors: queryVecs, dim } = await embed(queries, modelKey);
 
     // Warn about similar queries that may bias RRF results
-    const SIMILARITY_WARN_THRESHOLD = 0.85;
+    const SIMILARITY_WARN_THRESHOLD = searchCfg.similarityWarnThreshold ?? 0.85;
     for (let i = 0; i < queryVecs.length; i++) {
       for (let j = i + 1; j < queryVecs.length; j++) {
         const sim = cosineSim(queryVecs[i], queryVecs[j]);