@optave/codegraph 3.1.5 → 3.2.0

package/src/domain/graph/builder/stages/insert-nodes.js

@@ -15,23 +15,159 @@ import {
   readFileSafe,
 } from '../helpers.js';
 
+// ── Phase 1: Insert file nodes, definitions, exports ────────────────────
+
+function insertDefinitionsAndExports(db, allSymbols) {
+  const phase1Rows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
+    for (const def of symbols.definitions) {
+      const dotIdx = def.name.lastIndexOf('.');
+      const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
+      phase1Rows.push([
+        def.name,
+        def.kind,
+        relPath,
+        def.line,
+        def.endLine || null,
+        null,
+        def.name,
+        scope,
+        def.visibility || null,
+      ]);
+    }
+    for (const exp of symbols.exports) {
+      phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
+    }
+  }
+  batchInsertNodes(db, phase1Rows);
+
+  // Mark exported symbols
+  const markExported = db.prepare(
+    'UPDATE nodes SET exported = 1 WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+  );
+  for (const [relPath, symbols] of allSymbols) {
+    for (const exp of symbols.exports) {
+      markExported.run(exp.name, exp.kind, relPath, exp.line);
+    }
+  }
+}
+
+// ── Phase 2: Insert children (needs parent IDs) ────────────────────────
+
+function insertChildren(db, allSymbols) {
+  const childRows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+    for (const def of symbols.definitions) {
+      if (!def.children?.length) continue;
+      const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+      if (!defId) continue;
+      for (const child of def.children) {
+        const qualifiedName = `${def.name}.${child.name}`;
+        childRows.push([
+          child.name,
+          child.kind,
+          relPath,
+          child.line,
+          child.endLine || null,
+          defId,
+          qualifiedName,
+          def.name,
+          child.visibility || null,
+        ]);
+      }
+    }
+  }
+  batchInsertNodes(db, childRows);
+}
+
+// ── Phase 3: Insert containment + parameter_of edges ────────────────────
+
+function insertContainmentEdges(db, allSymbols) {
+  const edgeRows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+    const fileId = nodeIdMap.get(`${relPath}|file|0`);
+    for (const def of symbols.definitions) {
+      const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+      if (fileId && defId) {
+        edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
+      }
+      if (def.children?.length && defId) {
+        for (const child of def.children) {
+          const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
+          if (childId) {
+            edgeRows.push([defId, childId, 'contains', 1.0, 0]);
+            if (child.kind === 'parameter') {
+              edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
+            }
+          }
+        }
+      }
+    }
+  }
+  batchInsertEdges(db, edgeRows);
+}
+
+// ── Phase 4: Update file hashes ─────────────────────────────────────────
+
+function updateFileHashes(_db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash) {
+  if (!upsertHash) return;
+
+  for (const [relPath] of allSymbols) {
+    const precomputed = precomputedData.get(relPath);
+    if (precomputed?._reverseDepOnly) {
+      // no-op: file unchanged, hash already correct
+    } else if (precomputed?.hash) {
+      const stat = precomputed.stat || fileStat(path.join(rootDir, relPath));
+      const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+      const size = stat ? stat.size : 0;
+      upsertHash.run(relPath, precomputed.hash, mtime, size);
+    } else {
+      const absPath = path.join(rootDir, relPath);
+      let code;
+      try {
+        code = readFileSafe(absPath);
+      } catch {
+        code = null;
+      }
+      if (code !== null) {
+        const stat = fileStat(absPath);
+        const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+        const size = stat ? stat.size : 0;
+        upsertHash.run(relPath, fileHash(code), mtime, size);
+      }
+    }
+  }
+
+  // Also update metadata-only entries (self-heal mtime/size without re-parse)
+  for (const item of metadataUpdates) {
+    const mtime = item.stat ? Math.floor(item.stat.mtimeMs) : 0;
+    const size = item.stat ? item.stat.size : 0;
+    upsertHash.run(item.relPath, item.hash, mtime, size);
+  }
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
 /**
  * @param {import('../context.js').PipelineContext} ctx
  */
 export async function insertNodes(ctx) {
   const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
 
-  // Build lookup from incremental data (pre-computed hashes + stats)
   const precomputedData = new Map();
   for (const item of filesToParse) {
-    if (item.relPath) {
-      precomputedData.set(item.relPath, item);
-    }
+    if (item.relPath) precomputedData.set(item.relPath, item);
   }
 
-  const bulkGetNodeIds = { all: (file) => bulkNodeIdsByFile(db, file) };
-
-  // Prepare hash upsert
   let upsertHash;
   try {
     upsertHash = db.prepare(
@@ -42,143 +178,15 @@ export async function insertNodes(ctx) {
   }
 
   // Populate fileSymbols before the transaction so it is a pure input
-  // to (rather than a side-effect of) the DB write — avoids partial
-  // population if the transaction rolls back.
   for (const [relPath, symbols] of allSymbols) {
     ctx.fileSymbols.set(relPath, symbols);
   }
 
   const insertAll = db.transaction(() => {
-    // Phase 1: Batch insert all file nodes + definitions + exports
-    // Row format: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
-    const phase1Rows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
-      for (const def of symbols.definitions) {
-        // Methods already have 'Class.method' as name — use as qualified_name.
-        // For methods, scope is the class portion; for top-level defs, scope is null.
-        const dotIdx = def.name.lastIndexOf('.');
-        const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
-        phase1Rows.push([
-          def.name,
-          def.kind,
-          relPath,
-          def.line,
-          def.endLine || null,
-          null,
-          def.name,
-          scope,
-          def.visibility || null,
-        ]);
-      }
-      for (const exp of symbols.exports) {
-        phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
-      }
-    }
-    batchInsertNodes(db, phase1Rows);
-
-    // Phase 1b: Mark exported symbols
-    const markExported = db.prepare(
-      'UPDATE nodes SET exported = 1 WHERE name = ? AND kind = ? AND file = ? AND line = ?',
-    );
-    for (const [relPath, symbols] of allSymbols) {
-      for (const exp of symbols.exports) {
-        markExported.run(exp.name, exp.kind, relPath, exp.line);
-      }
-    }
-
-    // Phase 3: Batch insert children (needs parent IDs from Phase 2)
-    const childRows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      const nodeIdMap = new Map();
-      for (const row of bulkGetNodeIds.all(relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      for (const def of symbols.definitions) {
-        if (!def.children?.length) continue;
-        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
-        if (!defId) continue;
-        for (const child of def.children) {
-          const qualifiedName = `${def.name}.${child.name}`;
-          childRows.push([
-            child.name,
-            child.kind,
-            relPath,
-            child.line,
-            child.endLine || null,
-            defId,
-            qualifiedName,
-            def.name,
-            child.visibility || null,
-          ]);
-        }
-      }
-    }
-    batchInsertNodes(db, childRows);
-
-    // Phase 5: Batch insert contains/parameter_of edges
-    const edgeRows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      const nodeIdMap = new Map();
-      for (const row of bulkGetNodeIds.all(relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      const fileId = nodeIdMap.get(`${relPath}|file|0`);
-      for (const def of symbols.definitions) {
-        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
-        if (fileId && defId) {
-          edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
-        }
-        if (def.children?.length && defId) {
-          for (const child of def.children) {
-            const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
-            if (childId) {
-              edgeRows.push([defId, childId, 'contains', 1.0, 0]);
-              if (child.kind === 'parameter') {
-                edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
-              }
-            }
-          }
-        }
-      }
-
-      // Update file hash — skip reverse-dep files (unchanged)
-      if (upsertHash) {
-        const precomputed = precomputedData.get(relPath);
-        if (precomputed?._reverseDepOnly) {
-          // no-op: file unchanged, hash already correct
-        } else if (precomputed?.hash) {
-          const stat = precomputed.stat || fileStat(path.join(rootDir, relPath));
-          const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
-          const size = stat ? stat.size : 0;
-          upsertHash.run(relPath, precomputed.hash, mtime, size);
-        } else {
-          const absPath = path.join(rootDir, relPath);
-          let code;
-          try {
-            code = readFileSafe(absPath);
-          } catch {
-            code = null;
-          }
-          if (code !== null) {
-            const stat = fileStat(absPath);
-            const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
-            const size = stat ? stat.size : 0;
-            upsertHash.run(relPath, fileHash(code), mtime, size);
-          }
-        }
-      }
-    }
-    batchInsertEdges(db, edgeRows);
-
-    // Also update metadata-only entries (self-heal mtime/size without re-parse)
-    if (upsertHash) {
-      for (const item of metadataUpdates) {
-        const mtime = item.stat ? Math.floor(item.stat.mtimeMs) : 0;
-        const size = item.stat ? item.stat.size : 0;
-        upsertHash.run(item.relPath, item.hash, mtime, size);
-      }
-    }
+    insertDefinitionsAndExports(db, allSymbols);
+    insertChildren(db, allSymbols);
+    insertContainmentEdges(db, allSymbols);
+    updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
   });
 
   const t0 = performance.now();

package/src/domain/graph/watcher.js

@@ -57,10 +57,10 @@ export async function watchProject(rootDir, opts = {}) {
     countNodes: db.prepare('SELECT COUNT(*) as c FROM nodes WHERE file = ?'),
     countEdgesForFile: null,
     findNodeInFile: db.prepare(
-      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module') AND file = ?",
+      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant') AND file = ?",
     ),
     findNodeByName: db.prepare(
-      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')",
+      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')",
     ),
     listSymbols: db.prepare("SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file'"),
   };

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}`);
     }
   }
 }
@@ -483,7 +490,9 @@ export function getActiveEngine(opts = {}) {
   if (native) {
     try {
       version = getNativePackageVersion() ?? version;
-    } catch {}
+    } catch (e) {
+      debug(`getNativePackageVersion failed: ${e.message}`);
+    }
   }
   return { name, version };
 }

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';

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/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) {