@optave/codegraph 3.1.4 → 3.2.0

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

@@ -0,0 +1,203 @@
+/**
+ * Stage: insertNodes
+ *
+ * Batch-inserts file nodes, definitions, exports, children, and contains/parameter_of edges.
+ * Updates file hashes for incremental builds.
+ */
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { bulkNodeIdsByFile } from '../../../../db/index.js';
+import {
+  batchInsertEdges,
+  batchInsertNodes,
+  fileHash,
+  fileStat,
+  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;
+
+  const precomputedData = new Map();
+  for (const item of filesToParse) {
+    if (item.relPath) precomputedData.set(item.relPath, item);
+  }
+
+  let upsertHash;
+  try {
+    upsertHash = db.prepare(
+      'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
+    );
+  } catch {
+    upsertHash = null;
+  }
+
+  // Populate fileSymbols before the transaction so it is a pure input
+  for (const [relPath, symbols] of allSymbols) {
+    ctx.fileSymbols.set(relPath, symbols);
+  }
+
+  const insertAll = db.transaction(() => {
+    insertDefinitionsAndExports(db, allSymbols);
+    insertChildren(db, allSymbols);
+    insertContainmentEdges(db, allSymbols);
+    updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
+  });
+
+  const t0 = performance.now();
+  insertAll();
+  ctx.timing.insertMs = performance.now() - t0;
+
+  // Clean up removed file hashes
+  if (upsertHash && removed.length > 0) {
+    const deleteHash = db.prepare('DELETE FROM file_hashes WHERE file = ?');
+    for (const relPath of removed) {
+      deleteHash.run(relPath);
+    }
+  }
+}

package/src/{builder → domain/graph/builder}/stages/parse-files.js

@@ -5,8 +5,8 @@
  * Populates ctx.allSymbols, ctx.fileSymbols, ctx.filesToParse.
  */
 import { performance } from 'node:perf_hooks';
-import { info } from '../../logger.js';
-import { parseFilesAuto } from '../../parser.js';
+import { info } from '../../../../infrastructure/logger.js';
+import { parseFilesAuto } from '../../../parser.js';
 
 /**
  * @param {import('../context.js').PipelineContext} ctx

package/src/{builder → domain/graph/builder}/stages/resolve-imports.js

@@ -6,7 +6,7 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { parseFilesAuto } from '../../parser.js';
+import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
 
 /**

package/src/{builder → domain/graph/builder}/stages/run-analyses.js

@@ -4,7 +4,7 @@
  * Dispatches to the unified AST analysis engine (AST nodes, complexity, CFG, dataflow).
  * Filters out reverse-dep files for incremental builds.
  */
-import { debug, warn } from '../../logger.js';
+import { debug, warn } from '../../../../infrastructure/logger.js';
 
 /**
  * @param {import('../context.js').PipelineContext} ctx
@@ -31,7 +31,7 @@ export async function runAnalyses(ctx) {
     }
   }
 
-  const { runAnalyses: runAnalysesFn } = await import('../../ast-analysis/engine.js');
+  const { runAnalyses: runAnalysesFn } = await import('../../../../ast-analysis/engine.js');
   try {
     const analysisTiming = await runAnalysesFn(db, astComplexitySymbols, rootDir, opts, engineOpts);
     ctx.timing.astMs = analysisTiming.astMs;

package/src/{change-journal.js → domain/graph/change-journal.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, warn } from './logger.js';
+import { debug, warn } from '../../infrastructure/logger.js';
 
 export const CHANGE_EVENTS_FILENAME = 'change-events.ndjson';
 export const DEFAULT_MAX_BYTES = 1024 * 1024; // 1 MB

package/src/{cycles.js → domain/graph/cycles.js}

@@ -1,7 +1,7 @@
-import { tarjan } from './graph/algorithms/tarjan.js';
-import { buildDependencyGraph } from './graph/builders/dependency.js';
-import { CodeGraph } from './graph/model.js';
-import { loadNative } from './native.js';
+import { tarjan } from '../../graph/algorithms/tarjan.js';
+import { buildDependencyGraph } from '../../graph/builders/dependency.js';
+import { CodeGraph } from '../../graph/model.js';
+import { loadNative } from '../../infrastructure/native.js';
 
 /**
  * Detect circular dependencies in the codebase using Tarjan's SCC algorithm.

package/src/{journal.js → domain/graph/journal.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, warn } from './logger.js';
+import { debug, warn } from '../../infrastructure/logger.js';
 
 export const JOURNAL_FILENAME = 'changes.journal';
 const HEADER_PREFIX = '# codegraph-journal v1 ';

package/src/{resolve.js → domain/graph/resolve.js}

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizePath } from './constants.js';
-import { loadNative } from './native.js';
+import { loadNative } from '../../infrastructure/native.js';
+import { normalizePath } from '../../shared/constants.js';
 
 // ── Alias format conversion ─────────────────────────────────────────
 

package/src/{watcher.js → domain/graph/watcher.js}

@@ -1,13 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
+import { info } from '../../infrastructure/logger.js';
+import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../shared/constants.js';
+import { DbError } from '../../shared/errors.js';
+import { createParseTreeCache, getActiveEngine } from '../parser.js';
 import { rebuildFile } from './builder/incremental.js';
 import { appendChangeEvents, buildChangeEvent, diffSymbols } from './change-journal.js';
-import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
-import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from './db.js';
-import { DbError } from './errors.js';
 import { appendJournalEntries } from './journal.js';
-import { info } from './logger.js';
-import { createParseTreeCache, getActiveEngine } from './parser.js';
 
 function shouldIgnore(filePath) {
   const parts = filePath.split(path.sep);
@@ -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/{parser.js → domain/parser.js}

@@ -2,8 +2,8 @@ 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 './logger.js';
-import { getNative, getNativePackageVersion, loadNative } from './native.js';
+import { debug, warn } from '../infrastructure/logger.js';
+import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
 
 // Re-export all extractors for backward compatibility
 export {
@@ -16,7 +16,7 @@ export {
   extractRubySymbols,
   extractRustSymbols,
   extractSymbols,
-} from './extractors/index.js';
+} from '../extractors/index.js';
 
 import {
   extractCSharpSymbols,
@@ -28,12 +28,12 @@ import {
   extractRubySymbols,
   extractRustSymbols,
   extractSymbols,
-} from './extractors/index.js';
+} from '../extractors/index.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 function grammarPath(name) {
-  return path.join(__dirname, '..', 'grammars', name);
+  return path.join(__dirname, '..', '..', 'grammars', name);
 }
 
 let _initialized = false;
@@ -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/{queries.js → domain/queries.js}

@@ -6,6 +6,23 @@
  * importers continue to work without changes.
  */
 
+// ── Re-export from dedicated module for backward compat ───────────────────
+export { isTestFile, TEST_PATTERN } from '../infrastructure/test-filter.js';
+export { iterListFunctions, iterRoles, iterWhere } from '../shared/generators.js';
+// ── Kind/edge constants (canonical source: kinds.js) ─────────────────────
+export {
+  ALL_SYMBOL_KINDS,
+  CORE_EDGE_KINDS,
+  CORE_SYMBOL_KINDS,
+  EVERY_EDGE_KIND,
+  EVERY_SYMBOL_KIND,
+  EXTENDED_SYMBOL_KINDS,
+  STRUCTURAL_EDGE_KINDS,
+  VALID_ROLES,
+} 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';
@@ -30,19 +47,3 @@ export {
   queryNameData,
   whereData,
 } from './analysis/symbol-lookup.js';
-// ── Re-export from dedicated module for backward compat ───────────────────
-export { isTestFile, TEST_PATTERN } from './infrastructure/test-filter.js';
-// ── Kind/edge constants (canonical source: kinds.js) ─────────────────────
-export {
-  ALL_SYMBOL_KINDS,
-  CORE_EDGE_KINDS,
-  CORE_SYMBOL_KINDS,
-  EVERY_EDGE_KIND,
-  EVERY_SYMBOL_KIND,
-  EXTENDED_SYMBOL_KINDS,
-  STRUCTURAL_EDGE_KINDS,
-  VALID_ROLES,
-} from './kinds.js';
-export { iterListFunctions, iterRoles, iterWhere } from './shared/generators.js';
-// ── Shared utilities ─────────────────────────────────────────────────────
-export { kindIcon, normalizeSymbol } from './shared/normalize.js';

package/src/{embeddings → domain/search}/generator.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { closeDb, findDbPath, openDb } from '../db.js';
-import { DbError } from '../errors.js';
-import { warn } from '../logger.js';
+import { closeDb, findDbPath, openDb } from '../../db/index.js';
+import { warn } from '../../infrastructure/logger.js';
+import { DbError } from '../../shared/errors.js';
 import { embed, getModelConfig } from './models.js';
 import { buildSourceText } from './strategies/source.js';
 import { buildStructuredText } from './strategies/structured.js';

package/src/{embeddings → domain/search}/models.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { ConfigError, EngineError } from '../errors.js';
-import { info } from '../logger.js';
+import { info } from '../../infrastructure/logger.js';
+import { ConfigError, EngineError } from '../../shared/errors.js';
 
 // Lazy-load transformers (heavy, optional module)
 let pipeline = null;

package/src/{embeddings → domain/search}/search/cli-formatter.js

@@ -1,4 +1,4 @@
-import { warn } from '../../logger.js';
+import { warn } from '../../../infrastructure/logger.js';
 import { hybridSearchData } from './hybrid.js';
 import { ftsSearchData } from './keyword.js';
 import { multiSearchData, searchData } from './semantic.js';

package/src/{embeddings → 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/{embeddings → domain/search}/search/hybrid.js

@@ -1,4 +1,4 @@
-import { openReadonlyOrFail } from '../../db.js';
+import { openReadonlyOrFail } from '../../../db/index.js';
 import { hasFtsIndex } from '../stores/fts5.js';
 import { ftsSearchData } from './keyword.js';
 import { searchData } from './semantic.js';

package/src/{embeddings → domain/search}/search/keyword.js

@@ -1,4 +1,5 @@
-import { openReadonlyOrFail } from '../../db.js';
+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/{embeddings → domain/search}/search/prepare.js

@@ -1,5 +1,6 @@
-import { getEmbeddingCount, getEmbeddingMeta } from '../../db/repository/embeddings.js';
-import { openReadonlyOrFail } from '../../db.js';
+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/{embeddings → domain/search}/search/semantic.js

@@ -1,4 +1,4 @@
-import { warn } from '../../logger.js';
+import { warn } from '../../../infrastructure/logger.js';
 import { normalizeSymbol } from '../../queries.js';
 import { embed } from '../models.js';
 import { cosineSim } from '../stores/sqlite-blob.js';

package/src/{embeddings → domain/search}/strategies/structured.js

@@ -1,4 +1,4 @@
-import { findCalleeNames, findCallerNames } from '../../db.js';
+import { findCalleeNames, findCallerNames } from '../../../db/index.js';
 import { extractLeadingComment, splitIdentifier } from './text-utils.js';
 
 /**