@optave/codegraph 3.1.4 → 3.2.0

package/src/db/connection.js

@@ -1,14 +1,69 @@
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { DbError } from '../errors.js';
-import { warn } from '../logger.js';
+import { debug, warn } from '../infrastructure/logger.js';
+import { DbError } from '../shared/errors.js';
+import { Repository } from './repository/base.js';
+import { SqliteRepository } from './repository/sqlite-repository.js';
+
+let _cachedRepoRoot; // undefined = not computed, null = not a git repo
+let _cachedRepoRootCwd; // cwd at the time the cache was populated
+
+/**
+ * Return the git worktree/repo root for the given directory (or cwd).
+ * Uses `git rev-parse --show-toplevel` which returns the correct root
+ * for both regular repos and git worktrees.
+ * Results are cached per-process when called without arguments.
+ * The cache is keyed on cwd so it invalidates if the working directory changes
+ * (e.g. MCP server serving multiple sessions).
+ * @param {string} [fromDir] - Directory to resolve from (defaults to cwd)
+ * @returns {string | null} Absolute path to repo root, or null if not in a git repo
+ */
+export function findRepoRoot(fromDir) {
+  const dir = fromDir || process.cwd();
+  if (!fromDir && _cachedRepoRoot !== undefined && _cachedRepoRootCwd === dir) {
+    return _cachedRepoRoot;
+  }
+  let root = null;
+  try {
+    const raw = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: dir,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    // Use realpathSync to resolve symlinks (macOS /var → /private/var) and
+    // 8.3 short names (Windows RUNNER~1 → runneradmin) so the ceiling path
+    // matches the realpathSync'd dir in findDbPath.
+    try {
+      root = fs.realpathSync(raw);
+    } catch (e) {
+      debug(`realpathSync failed for git root "${raw}", using resolve: ${e.message}`);
+      root = path.resolve(raw);
+    }
+  } catch (e) {
+    debug(`git rev-parse failed for "${dir}": ${e.message}`);
+    root = null;
+  }
+  if (!fromDir) {
+    _cachedRepoRoot = root;
+    _cachedRepoRootCwd = dir;
+  }
+  return root;
+}
+
+/** Reset the cached repo root (for testing). */
+export function _resetRepoRootCache() {
+  _cachedRepoRoot = undefined;
+  _cachedRepoRootCwd = undefined;
+}
 
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (e) {
+    debug(`PID ${pid} not alive: ${e.code || e.message}`);
     return false;
   }
 }
@@ -23,13 +78,13 @@ function acquireAdvisoryLock(dbPath) {
         warn(`Another process (PID ${pid}) may be using this database. Proceeding with caution.`);
       }
     }
-  } catch {
-    /* ignore read errors */
+  } catch (e) {
+    debug(`Advisory lock read failed: ${e.message}`);
   }
   try {
     fs.writeFileSync(lockPath, String(process.pid), 'utf-8');
-  } catch {
-    /* best-effort */
+  } catch (e) {
+    debug(`Advisory lock write failed: ${e.message}`);
   }
 }
 
@@ -39,8 +94,25 @@ function releaseAdvisoryLock(lockPath) {
     if (Number(content) === process.pid) {
       fs.unlinkSync(lockPath);
     }
-  } catch {
-    /* ignore */
+  } catch (e) {
+    debug(`Advisory lock release failed for ${lockPath}: ${e.message}`);
+  }
+}
+
+/**
+ * Check if two paths refer to the same directory.
+ * Handles Windows 8.3 short names (RUNNER~1 vs runneradmin) and macOS
+ * symlinks (/tmp vs /private/tmp) where string comparison fails.
+ */
+function isSameDirectory(a, b) {
+  if (path.resolve(a) === path.resolve(b)) return true;
+  try {
+    const sa = fs.statSync(a);
+    const sb = fs.statSync(b);
+    return sa.dev === sb.dev && sa.ino === sb.ino;
+  } catch (e) {
+    debug(`isSameDirectory stat failed: ${e.message}`);
+    return false;
   }
 }
 
@@ -62,15 +134,43 @@ export function closeDb(db) {
 
 export function findDbPath(customPath) {
   if (customPath) return path.resolve(customPath);
-  let dir = process.cwd();
+  const rawCeiling = findRepoRoot();
+  // Normalize ceiling with realpathSync to resolve 8.3 short names (Windows
+  // RUNNER~1 → runneradmin) and symlinks (macOS /var → /private/var).
+  // findRepoRoot already applies realpathSync internally, but the git output
+  // may still contain short names on some Windows CI environments.
+  let ceiling;
+  if (rawCeiling) {
+    try {
+      ceiling = fs.realpathSync(rawCeiling);
+    } catch (e) {
+      debug(`realpathSync failed for ceiling "${rawCeiling}": ${e.message}`);
+      ceiling = rawCeiling;
+    }
+  } else {
+    ceiling = null;
+  }
+  // Resolve symlinks (e.g. macOS /var → /private/var) so dir matches ceiling from git
+  let dir;
+  try {
+    dir = fs.realpathSync(process.cwd());
+  } catch (e) {
+    debug(`realpathSync failed for cwd: ${e.message}`);
+    dir = process.cwd();
+  }
   while (true) {
     const candidate = path.join(dir, '.codegraph', 'graph.db');
     if (fs.existsSync(candidate)) return candidate;
+    if (ceiling && isSameDirectory(dir, ceiling)) {
+      debug(`findDbPath: stopped at git ceiling ${ceiling}`);
+      break;
+    }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path.join(process.cwd(), '.codegraph', 'graph.db');
+  const base = ceiling || process.cwd();
+  return path.join(base, '.codegraph', 'graph.db');
 }
 
 /**
@@ -86,3 +186,32 @@ export function openReadonlyOrFail(customPath) {
   }
   return new Database(dbPath, { readonly: true });
 }
+
+/**
+ * Open a Repository from either an injected instance or a DB path.
+ *
+ * When `opts.repo` is a Repository instance, returns it directly (no DB opened).
+ * Otherwise opens a readonly SQLite DB and wraps it in SqliteRepository.
+ *
+ * @param {string} [customDbPath] - Path to graph.db (ignored when opts.repo is set)
+ * @param {object} [opts]
+ * @param {Repository} [opts.repo] - Pre-built Repository to use instead of SQLite
+ * @returns {{ repo: Repository, close(): void }}
+ */
+export function openRepo(customDbPath, opts = {}) {
+  if (opts.repo != null) {
+    if (!(opts.repo instanceof Repository)) {
+      throw new TypeError(
+        `openRepo: opts.repo must be a Repository instance, got ${Object.prototype.toString.call(opts.repo)}`,
+      );
+    }
+    return { repo: opts.repo, close() {} };
+  }
+  const db = openReadonlyOrFail(customDbPath);
+  return {
+    repo: new SqliteRepository(db),
+    close() {
+      db.close();
+    },
+  };
+}

package/src/{db.js → db/index.js}

@@ -1,13 +1,20 @@
-// Barrel re-export — keeps all existing `import { ... } from './db.js'` working.
-export { closeDb, findDbPath, openDb, openReadonlyOrFail } from './db/connection.js';
-export { getBuildMeta, initSchema, MIGRATIONS, setBuildMeta } from './db/migrations.js';
+// Barrel re-export — keeps all existing `import { ... } from '…/db/index.js'` working.
+export {
+  closeDb,
+  findDbPath,
+  findRepoRoot,
+  openDb,
+  openReadonlyOrFail,
+  openRepo,
+} from './connection.js';
+export { getBuildMeta, initSchema, MIGRATIONS, setBuildMeta } from './migrations.js';
 export {
   fanInJoinSQL,
   fanOutJoinSQL,
   kindInClause,
   NodeQuery,
   testFilterSQL,
-} from './db/query-builder.js';
+} from './query-builder.js';
 export {
   bulkNodeIdsByFile,
   countCrossFileCallers,
@@ -60,4 +67,4 @@ export {
   Repository,
   SqliteRepository,
   upsertCoChangeMeta,
-} from './db/repository/index.js';
+} from './repository/index.js';

package/src/db/migrations.js

@@ -1,4 +1,4 @@
-import { debug } from '../logger.js';
+import { debug } from '../infrastructure/logger.js';
 
 // ─── Schema Migrations ─────────────────────────────────────────────────
 export const MIGRATIONS = [
@@ -242,11 +242,23 @@ export const MIGRATIONS = [
   },
 ];
 
+function hasColumn(db, table, column) {
+  const cols = db.pragma(`table_info(${table})`);
+  return cols.some((c) => c.name === column);
+}
+
+function hasTable(db, table) {
+  const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table);
+  return !!row;
+}
+
 export function getBuildMeta(db, key) {
+  if (!hasTable(db, 'build_meta')) return null;
   try {
     const row = db.prepare('SELECT value FROM build_meta WHERE key = ?').get(key);
     return row ? row.value : null;
-  } catch {
+  } catch (e) {
+    debug(`getBuildMeta failed for key "${key}": ${e.message}`);
     return null;
   }
 }
@@ -280,74 +292,39 @@ export function initSchema(db) {
     }
   }
 
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN end_line INTEGER');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE edges ADD COLUMN dynamic INTEGER DEFAULT 0');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN role TEXT');
-  } catch {
-    /* already exists */
-  }
-  try {
+  // Legacy column compat — add columns that may be missing from pre-migration DBs
+  if (hasTable(db, 'nodes')) {
+    if (!hasColumn(db, 'nodes', 'end_line')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN end_line INTEGER');
+    }
+    if (!hasColumn(db, 'nodes', 'role')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN role TEXT');
+    }
     db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_role ON nodes(role)');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id)');
-  } catch {
-    /* already exists */
-  }
-  try {
+    if (!hasColumn(db, 'nodes', 'parent_id')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id)');
+    }
     db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_parent ON nodes(parent_id)');
-  } catch {
-    /* already exists */
-  }
-  try {
     db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_kind_parent ON nodes(kind, parent_id)');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN qualified_name TEXT');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN scope TEXT');
-  } catch {
-    /* already exists */
-  }
-  try {
-    db.exec('ALTER TABLE nodes ADD COLUMN visibility TEXT');
-  } catch {
-    /* already exists */
-  }
-  try {
+    if (!hasColumn(db, 'nodes', 'qualified_name')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN qualified_name TEXT');
+    }
+    if (!hasColumn(db, 'nodes', 'scope')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN scope TEXT');
+    }
+    if (!hasColumn(db, 'nodes', 'visibility')) {
+      db.exec('ALTER TABLE nodes ADD COLUMN visibility TEXT');
+    }
     db.exec('UPDATE nodes SET qualified_name = name WHERE qualified_name IS NULL');
-  } catch {
-    /* nodes table may not exist yet */
-  }
-  try {
     db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_qualified_name ON nodes(qualified_name)');
-  } catch {
-    /* already exists */
-  }
-  try {
     db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_scope ON nodes(scope)');
-  } catch {
-    /* already exists */
+  }
+  if (hasTable(db, 'edges')) {
+    if (!hasColumn(db, 'edges', 'confidence')) {
+      db.exec('ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0');
+    }
+    if (!hasColumn(db, 'edges', 'dynamic')) {
+      db.exec('ALTER TABLE edges ADD COLUMN dynamic INTEGER DEFAULT 0');
+    }
   }
 }

package/src/db/query-builder.js

@@ -1,5 +1,5 @@
-import { DbError } from '../errors.js';
-import { EVERY_EDGE_KIND } from '../kinds.js';
+import { DbError } from '../shared/errors.js';
+import { EVERY_EDGE_KIND } from '../shared/kinds.js';
 
 // ─── Validation Helpers ─────────────────────────────────────────────
 
@@ -65,6 +65,62 @@ function validateEdgeKind(edgeKind) {
   }
 }
 
+// ─── LIKE Escaping ──────────────────────────────────────────────────
+
+/** Escape LIKE wildcards in a literal string segment. */
+export function escapeLike(s) {
+  return s.replace(/[%_\\]/g, '\\$&');
+}
+
+/**
+ * Normalize a file filter value (string, string[], or falsy) into a flat array.
+ * Returns an empty array when the input is falsy.
+ * @param {string|string[]|undefined|null} file
+ * @returns {string[]}
+ */
+export function normalizeFileFilter(file) {
+  if (!file) return [];
+  return Array.isArray(file) ? file : [file];
+}
+
+/**
+ * Build a SQL condition + params for a multi-value file LIKE filter.
+ * Returns `{ sql: '', params: [] }` when the filter is empty.
+ *
+ * @param {string|string[]} file - One or more partial file paths
+ * @param {string} [column='file'] - The column name to filter on (e.g. 'n.file', 'a.file')
+ * @returns {{ sql: string, params: string[] }}
+ */
+export function buildFileConditionSQL(file, column = 'file') {
+  validateColumn(column);
+  const files = normalizeFileFilter(file);
+  if (files.length === 0) return { sql: '', params: [] };
+  if (files.length === 1) {
+    return {
+      sql: ` AND ${column} LIKE ? ESCAPE '\\'`,
+      params: [`%${escapeLike(files[0])}%`],
+    };
+  }
+  const clauses = files.map(() => `${column} LIKE ? ESCAPE '\\'`);
+  return {
+    sql: ` AND (${clauses.join(' OR ')})`,
+    params: files.map((f) => `%${escapeLike(f)}%`),
+  };
+}
+
+/**
+ * Commander option accumulator for repeatable `--file` flag.
+ * Use as: `['-f, --file <path>', 'Scope to file (partial match, repeatable)', collectFile]`
+ * @param {string} val - New value from Commander
+ * @param {string[]} acc - Accumulated values (undefined on first call)
+ * @returns {string[]}
+ */
+export function collectFile(val, acc) {
+  acc = acc || [];
+  acc.push(val);
+  return acc;
+}
+
 // ─── Standalone Helpers ──────────────────────────────────────────────
 
 /**
@@ -164,11 +220,18 @@ export class NodeQuery {
     return this;
   }
 
-  /** WHERE n.file LIKE ? (no-op if falsy). */
+  /** WHERE n.file LIKE ? (no-op if falsy). Accepts a single string or string[]. */
   fileFilter(file) {
-    if (!file) return this;
-    this.#conditions.push('n.file LIKE ?');
-    this.#params.push(`%${file}%`);
+    const files = normalizeFileFilter(file);
+    if (files.length === 0) return this;
+    if (files.length === 1) {
+      this.#conditions.push("n.file LIKE ? ESCAPE '\\'");
+      this.#params.push(`%${escapeLike(files[0])}%`);
+    } else {
+      const clauses = files.map(() => "n.file LIKE ? ESCAPE '\\'");
+      this.#conditions.push(`(${clauses.join(' OR ')})`);
+      this.#params.push(...files.map((f) => `%${escapeLike(f)}%`));
+    }
     return this;
   }
 
@@ -188,11 +251,11 @@ export class NodeQuery {
     return this;
   }
 
-  /** WHERE n.name LIKE ? (no-op if falsy). */
+  /** WHERE n.name LIKE ? (no-op if falsy). Escapes LIKE wildcards in the value. */
   nameLike(pattern) {
     if (!pattern) return this;
-    this.#conditions.push('n.name LIKE ?');
-    this.#params.push(`%${pattern}%`);
+    this.#conditions.push("n.name LIKE ? ESCAPE '\\'");
+    this.#params.push(`%${escapeLike(pattern)}%`);
     return this;
   }
 

package/src/db/repository/base.js

@@ -163,7 +163,7 @@ export class Repository {
     throw new Error('not implemented');
   }
 
-  /** @returns {{ source_id: number, target_id: number }[]} */
+  /** @returns {{ source_id: number, target_id: number, confidence: number|null }[]} */
   getCallEdges() {
     throw new Error('not implemented');
   }

package/src/db/repository/graph-read.js

@@ -1,4 +1,4 @@
-import { CORE_SYMBOL_KINDS } from '../../kinds.js';
+import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Statement caches (one prepared statement per db instance) ────────────
@@ -25,13 +25,13 @@ export function getCallableNodes(db) {
 /**
  * Get all 'calls' edges.
  * @param {object} db
- * @returns {{ source_id: number, target_id: number }[]}
+ * @returns {{ source_id: number, target_id: number, confidence: number|null }[]}
  */
 export function getCallEdges(db) {
   return cachedStmt(
     _getCallEdgesStmt,
     db,
-    "SELECT source_id, target_id FROM edges WHERE kind = 'calls'",
+    "SELECT source_id, target_id, confidence FROM edges WHERE kind = 'calls'",
   ).all();
 }
 

package/src/db/repository/in-memory-repository.js

@@ -1,17 +1,8 @@
-import { ConfigError } from '../../errors.js';
-import { CORE_SYMBOL_KINDS, EVERY_SYMBOL_KIND, VALID_ROLES } from '../../kinds.js';
+import { ConfigError } from '../../shared/errors.js';
+import { CORE_SYMBOL_KINDS, EVERY_SYMBOL_KIND, VALID_ROLES } from '../../shared/kinds.js';
+import { escapeLike, normalizeFileFilter } from '../query-builder.js';
 import { Repository } from './base.js';
 
-/**
- * Escape LIKE special characters so they are treated as literals.
- * Mirrors the `escapeLike` function in `nodes.js`.
- * @param {string} s
- * @returns {string}
- */
-function escapeLike(s) {
-  return s.replace(/[%_\\]/g, '\\$&');
-}
-
 /**
  * Convert a SQL LIKE pattern to a RegExp (case-insensitive).
  * Supports `%` (any chars) and `_` (single char).
@@ -36,6 +27,17 @@ function likeToRegex(pattern) {
   return new RegExp(`^${regex}$`, 'i');
 }
 
+/**
+ * Build a filter predicate for file matching.
+ * Accepts string, string[], or falsy. Returns null when no filtering needed.
+ */
+function buildFileFilterFn(file) {
+  const files = normalizeFileFilter(file);
+  if (files.length === 0) return null;
+  const regexes = files.map((f) => likeToRegex(`%${escapeLike(f)}%`));
+  return (filePath) => regexes.some((re) => re.test(filePath));
+}
+
 /**
  * In-memory Repository implementation backed by Maps.
  * No SQLite dependency — suitable for fast unit tests.
@@ -130,9 +132,9 @@ export class InMemoryRepository extends Repository {
     if (opts.kinds) {
       nodes = nodes.filter((n) => opts.kinds.includes(n.kind));
     }
-    if (opts.file) {
-      const fileRe = likeToRegex(`%${escapeLike(opts.file)}%`);
-      nodes = nodes.filter((n) => fileRe.test(n.file));
+    {
+      const fileFn = buildFileFilterFn(opts.file);
+      if (fileFn) nodes = nodes.filter((n) => fileFn(n.file));
     }
 
     // Compute fan-in per node
@@ -206,9 +208,9 @@ export class InMemoryRepository extends Repository {
     if (opts.kind) {
       nodes = nodes.filter((n) => n.kind === opts.kind);
     }
-    if (opts.file) {
-      const fileRe = likeToRegex(`%${escapeLike(opts.file)}%`);
-      nodes = nodes.filter((n) => fileRe.test(n.file));
+    {
+      const fileFn = buildFileFilterFn(opts.file);
+      if (fileFn) nodes = nodes.filter((n) => fileFn(n.file));
     }
 
     return nodes.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
@@ -217,9 +219,9 @@ export class InMemoryRepository extends Repository {
   findNodeByQualifiedName(qualifiedName, opts = {}) {
     let nodes = [...this.#nodes.values()].filter((n) => n.qualified_name === qualifiedName);
 
-    if (opts.file) {
-      const fileRe = likeToRegex(`%${escapeLike(opts.file)}%`);
-      nodes = nodes.filter((n) => fileRe.test(n.file));
+    {
+      const fileFn = buildFileFilterFn(opts.file);
+      if (fileFn) nodes = nodes.filter((n) => fileFn(n.file));
     }
 
     return nodes.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
@@ -257,9 +259,9 @@ export class InMemoryRepository extends Repository {
           !n.file.includes('.stories.'),
       );
     }
-    if (opts.file) {
-      const fileRe = likeToRegex(`%${escapeLike(opts.file)}%`);
-      nodes = nodes.filter((n) => fileRe.test(n.file));
+    {
+      const fileFn = buildFileFilterFn(opts.file);
+      if (fileFn) nodes = nodes.filter((n) => fileFn(n.file));
     }
     if (opts.role) {
       nodes = nodes.filter((n) => n.role === opts.role);
@@ -498,7 +500,7 @@ export class InMemoryRepository extends Repository {
   getCallEdges() {
     return [...this.#edges.values()]
       .filter((e) => e.kind === 'calls')
-      .map((e) => ({ source_id: e.source_id, target_id: e.target_id }));
+      .map((e) => ({ source_id: e.source_id, target_id: e.target_id, confidence: e.confidence }));
   }
 
   getFileNodesAll() {
@@ -550,9 +552,9 @@ export class InMemoryRepository extends Repository {
       ['function', 'method', 'class'].includes(n.kind),
     );
 
-    if (opts.file) {
-      const fileRe = likeToRegex(`%${escapeLike(opts.file)}%`);
-      nodes = nodes.filter((n) => fileRe.test(n.file));
+    {
+      const fileFn = buildFileFilterFn(opts.file);
+      if (fileFn) nodes = nodes.filter((n) => fileFn(n.file));
     }
     if (opts.pattern) {
       const patternRe = likeToRegex(`%${escapeLike(opts.pattern)}%`);

package/src/db/repository/nodes.js

@@ -1,6 +1,6 @@
-import { ConfigError } from '../../errors.js';
-import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../kinds.js';
-import { NodeQuery } from '../query-builder.js';
+import { ConfigError } from '../../shared/errors.js';
+import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../shared/kinds.js';
+import { buildFileConditionSQL, NodeQuery } from '../query-builder.js';
 import { cachedStmt } from './cached-stmt.js';
 
 // ─── Query-builder based lookups (moved from src/db/repository.js) ─────
@@ -250,11 +250,6 @@ export function findNodeChildren(db, parentId) {
   ).all(parentId);
 }
 
-/** Escape LIKE wildcards in a literal string segment. */
-function escapeLike(s) {
-  return s.replace(/[%_\\]/g, '\\$&');
-}
-
 /**
  * Find all nodes that belong to a given scope (by scope column).
  * Enables "all methods of class X" without traversing edges.
@@ -272,10 +267,9 @@ export function findNodesByScope(db, scopeName, opts = {}) {
     sql += ' AND kind = ?';
     params.push(opts.kind);
   }
-  if (opts.file) {
-    sql += " AND file LIKE ? ESCAPE '\\'";
-    params.push(`%${escapeLike(opts.file)}%`);
-  }
+  const fc = buildFileConditionSQL(opts.file, 'file');
+  sql += fc.sql;
+  params.push(...fc.params);
   sql += ' ORDER BY file, line';
   return db.prepare(sql).all(...params);
 }
@@ -291,12 +285,11 @@ export function findNodesByScope(db, scopeName, opts = {}) {
  * @returns {object[]}
  */
 export function findNodeByQualifiedName(db, qualifiedName, opts = {}) {
-  if (opts.file) {
+  const fc = buildFileConditionSQL(opts.file, 'file');
+  if (fc.sql) {
     return db
-      .prepare(
-        "SELECT * FROM nodes WHERE qualified_name = ? AND file LIKE ? ESCAPE '\\' ORDER BY file, line",
-      )
-      .all(qualifiedName, `%${escapeLike(opts.file)}%`);
+      .prepare(`SELECT * FROM nodes WHERE qualified_name = ?${fc.sql} ORDER BY file, line`)
+      .all(qualifiedName, ...fc.params);
   }
   return cachedStmt(
     _findNodeByQualifiedNameStmt,