@optave/codegraph 3.1.4 → 3.2.0

package/src/{boundaries.js → features/boundaries.js}

@@ -1,5 +1,5 @@
-import { isTestFile } from './infrastructure/test-filter.js';
-import { debug } from './logger.js';
+import { debug } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
 
 // ─── Glob-to-Regex ───────────────────────────────────────────────────
 
@@ -94,104 +94,119 @@ export function resolveModules(boundaryConfig) {
 // ─── Validation ──────────────────────────────────────────────────────
 
 /**
- * Validate a boundary configuration object.
- * @param {object} config - The `manifesto.boundaries` config
- * @returns {{ valid: boolean, errors: string[] }}
+ * Validate the `modules` section of a boundary config.
+ * @param {object} modules
+ * @param {string[]} errors - Mutated: push any validation errors
  */
-export function validateBoundaryConfig(config) {
-  const errors = [];
+function validateModules(modules, errors) {
+  if (!modules || typeof modules !== 'object' || Object.keys(modules).length === 0) {
+    errors.push('boundaries.modules must be a non-empty object');
+    return;
+  }
+  for (const [name, value] of Object.entries(modules)) {
+    if (typeof value === 'string') continue;
+    if (value && typeof value === 'object' && typeof value.match === 'string') continue;
+    errors.push(`boundaries.modules.${name}: must be a glob string or { match: "<glob>" }`);
+  }
+}
 
-  if (!config || typeof config !== 'object') {
-    return { valid: false, errors: ['boundaries config must be an object'] };
+/**
+ * Validate the `preset` field of a boundary config.
+ * @param {string|null|undefined} preset
+ * @param {string[]} errors - Mutated: push any validation errors
+ */
+function validatePreset(preset, errors) {
+  if (preset == null) return;
+  if (typeof preset !== 'string' || !PRESETS[preset]) {
+    errors.push(
+      `boundaries.preset: must be one of ${Object.keys(PRESETS).join(', ')} (got "${preset}")`,
+    );
   }
+}
 
-  // Validate modules
-  if (
-    !config.modules ||
-    typeof config.modules !== 'object' ||
-    Object.keys(config.modules).length === 0
-  ) {
-    errors.push('boundaries.modules must be a non-empty object');
-  } else {
-    for (const [name, value] of Object.entries(config.modules)) {
-      if (typeof value === 'string') continue;
-      if (value && typeof value === 'object' && typeof value.match === 'string') continue;
-      errors.push(`boundaries.modules.${name}: must be a glob string or { match: "<glob>" }`);
+/**
+ * Validate a single rule's target list (`notTo` or `onlyTo`).
+ * @param {*} list - The target list value
+ * @param {string} field - "notTo" or "onlyTo"
+ * @param {number} idx - Rule index for error messages
+ * @param {Set<string>} moduleNames
+ * @param {string[]} errors - Mutated
+ */
+function validateTargetList(list, field, idx, moduleNames, errors) {
+  if (!Array.isArray(list)) {
+    errors.push(`boundaries.rules[${idx}]: "${field}" must be an array`);
+    return;
+  }
+  for (const target of list) {
+    if (!moduleNames.has(target)) {
+      errors.push(`boundaries.rules[${idx}]: "${field}" references unknown module "${target}"`);
     }
   }
+}
 
-  // Validate preset
-  if (config.preset != null) {
-    if (typeof config.preset !== 'string' || !PRESETS[config.preset]) {
-      errors.push(
-        `boundaries.preset: must be one of ${Object.keys(PRESETS).join(', ')} (got "${config.preset}")`,
-      );
+/**
+ * Validate the `rules` array of a boundary config.
+ * @param {Array} rules
+ * @param {object|undefined} modules - The modules config (for cross-referencing names)
+ * @param {string[]} errors - Mutated
+ */
+function validateRules(rules, modules, errors) {
+  if (!rules) return;
+  if (!Array.isArray(rules)) {
+    errors.push('boundaries.rules must be an array');
+    return;
+  }
+  const moduleNames = modules ? new Set(Object.keys(modules)) : new Set();
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if (!rule.from) {
+      errors.push(`boundaries.rules[${i}]: missing "from" field`);
+    } else if (!moduleNames.has(rule.from)) {
+      errors.push(`boundaries.rules[${i}]: "from" references unknown module "${rule.from}"`);
+    }
+    if (rule.notTo && rule.onlyTo) {
+      errors.push(`boundaries.rules[${i}]: cannot have both "notTo" and "onlyTo"`);
+    }
+    if (!rule.notTo && !rule.onlyTo) {
+      errors.push(`boundaries.rules[${i}]: must have either "notTo" or "onlyTo"`);
     }
+    if (rule.notTo) validateTargetList(rule.notTo, 'notTo', i, moduleNames, errors);
+    if (rule.onlyTo) validateTargetList(rule.onlyTo, 'onlyTo', i, moduleNames, errors);
   }
+}
 
-  // Validate rules
-  if (config.rules) {
-    if (!Array.isArray(config.rules)) {
-      errors.push('boundaries.rules must be an array');
-    } else {
-      const moduleNames = config.modules ? new Set(Object.keys(config.modules)) : new Set();
-      for (let i = 0; i < config.rules.length; i++) {
-        const rule = config.rules[i];
-        if (!rule.from) {
-          errors.push(`boundaries.rules[${i}]: missing "from" field`);
-        } else if (!moduleNames.has(rule.from)) {
-          errors.push(`boundaries.rules[${i}]: "from" references unknown module "${rule.from}"`);
-        }
-        if (rule.notTo && rule.onlyTo) {
-          errors.push(`boundaries.rules[${i}]: cannot have both "notTo" and "onlyTo"`);
-        }
-        if (!rule.notTo && !rule.onlyTo) {
-          errors.push(`boundaries.rules[${i}]: must have either "notTo" or "onlyTo"`);
-        }
-        if (rule.notTo) {
-          if (!Array.isArray(rule.notTo)) {
-            errors.push(`boundaries.rules[${i}]: "notTo" must be an array`);
-          } else {
-            for (const target of rule.notTo) {
-              if (!moduleNames.has(target)) {
-                errors.push(
-                  `boundaries.rules[${i}]: "notTo" references unknown module "${target}"`,
-                );
-              }
-            }
-          }
-        }
-        if (rule.onlyTo) {
-          if (!Array.isArray(rule.onlyTo)) {
-            errors.push(`boundaries.rules[${i}]: "onlyTo" must be an array`);
-          } else {
-            for (const target of rule.onlyTo) {
-              if (!moduleNames.has(target)) {
-                errors.push(
-                  `boundaries.rules[${i}]: "onlyTo" references unknown module "${target}"`,
-                );
-              }
-            }
-          }
-        }
-      }
+/**
+ * Validate that module layer assignments match preset layers.
+ * @param {object} config
+ * @param {string[]} errors - Mutated
+ */
+function validateLayerAssignments(config, errors) {
+  if (!config.preset || !PRESETS[config.preset] || !config.modules) return;
+  const presetLayers = new Set(PRESETS[config.preset].layers);
+  for (const [name, value] of Object.entries(config.modules)) {
+    if (typeof value === 'object' && value.layer && !presetLayers.has(value.layer)) {
+      errors.push(
+        `boundaries.modules.${name}: layer "${value.layer}" not in preset "${config.preset}" (valid: ${[...presetLayers].join(', ')})`,
+      );
     }
   }
+}
 
-  // Validate preset + layer assignments
-  if (config.preset && PRESETS[config.preset] && config.modules) {
-    const presetLayers = new Set(PRESETS[config.preset].layers);
-    for (const [name, value] of Object.entries(config.modules)) {
-      if (typeof value === 'object' && value.layer) {
-        if (!presetLayers.has(value.layer)) {
-          errors.push(
-            `boundaries.modules.${name}: layer "${value.layer}" not in preset "${config.preset}" (valid: ${[...presetLayers].join(', ')})`,
-          );
-        }
-      }
-    }
+/**
+ * Validate a boundary configuration object.
+ * @param {object} config - The `manifesto.boundaries` config
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateBoundaryConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return { valid: false, errors: ['boundaries config must be an object'] };
   }
 
+  const errors = [];
+  validateModules(config.modules, errors);
+  validatePreset(config.preset, errors);
+  validateRules(config.rules, config.modules, errors);
+  validateLayerAssignments(config, errors);
   return { valid: errors.length === 0, errors };
 }
 

package/src/{branch-compare.js → features/branch-compare.js}

@@ -11,9 +11,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { buildGraph } from './builder.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { kindIcon } from './queries.js';
+import { buildGraph } from '../domain/graph/builder.js';
+import { kindIcon } from '../domain/queries.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
 

package/src/{cfg.js → features/cfg.js}

@@ -7,14 +7,14 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { CFG_RULES } from './ast-analysis/rules/index.js';
+import { CFG_RULES } from '../ast-analysis/rules/index.js';
 import {
   makeCfgRules as _makeCfgRules,
   buildExtensionSet,
   buildExtToLangMap,
-} from './ast-analysis/shared.js';
-import { walkWithVisitors } from './ast-analysis/visitor.js';
-import { createCfgVisitor } from './ast-analysis/visitors/cfg-visitor.js';
+} from '../ast-analysis/shared.js';
+import { walkWithVisitors } from '../ast-analysis/visitor.js';
+import { createCfgVisitor } from '../ast-analysis/visitors/cfg-visitor.js';
 import {
   deleteCfgForNode,
   getCfgBlocks,
@@ -22,10 +22,10 @@ import {
   getFunctionNodeId,
   hasCfgTables,
   openReadonlyOrFail,
-} from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { info } from './logger.js';
-import { paginateResult } from './paginate.js';
+} from '../db/index.js';
+import { debug, info } from '../infrastructure/logger.js';
+import { paginateResult } from '../shared/paginate.js';
+import { findNodes } from './shared/find-nodes.js';
 
 // Re-export for backward compatibility
 export { _makeCfgRules as makeCfgRules, CFG_RULES };
@@ -68,30 +68,15 @@ export function buildFunctionCFG(functionNode, langId) {
   return { blocks: r.blocks, edges: r.edges, cyclomatic: r.cyclomatic };
 }
 
-// ─── Build-Time: Compute CFG for Changed Files ─────────────────────────
+// ─── Build-Time Helpers ─────────────────────────────────────────────────
 
-/**
- * Build CFG data for all function/method definitions and persist to DB.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, _tree, _langId }>
- * @param {string} rootDir - absolute project root path
- * @param {object} [_engineOpts] - engine options (unused; always uses WASM for AST)
- */
-export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
-  // Lazily init WASM parsers if needed
-  let parsers = null;
+async function initCfgParsers(fileSymbols) {
   let needsFallback = false;
 
-  // Always build ext→langId map so native-only builds (where _langId is unset)
-  // can still derive the language from the file extension.
-  const extToLang = buildExtToLangMap();
-
   for (const [relPath, symbols] of fileSymbols) {
     if (!symbols._tree) {
       const ext = path.extname(relPath).toLowerCase();
       if (CFG_EXTENSIONS.has(ext)) {
-        // Check if all function/method defs already have native CFG data
         const hasNativeCfg = symbols.definitions
           .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
           .every((d) => d.cfg === null || d.cfg?.blocks?.length);
@@ -103,18 +88,131 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
     }
   }
 
+  let parsers = null;
+  let getParserFn = null;
+
   if (needsFallback) {
-    const { createParsers } = await import('./parser.js');
+    const { createParsers } = await import('../domain/parser.js');
     parsers = await createParsers();
+    const mod = await import('../domain/parser.js');
+    getParserFn = mod.getParser;
   }
 
-  let getParserFn = null;
-  if (parsers) {
-    const mod = await import('./parser.js');
-    getParserFn = mod.getParser;
+  return { parsers, getParserFn };
+}
+
+function getTreeAndLang(symbols, relPath, rootDir, extToLang, parsers, getParserFn) {
+  const ext = path.extname(relPath).toLowerCase();
+  let tree = symbols._tree;
+  let langId = symbols._langId;
+
+  const allNative = symbols.definitions
+    .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
+    .every((d) => d.cfg === null || d.cfg?.blocks?.length);
+
+  if (!tree && !allNative) {
+    if (!getParserFn) return null;
+    langId = extToLang.get(ext);
+    if (!langId || !CFG_RULES.has(langId)) return null;
+
+    const absPath = path.join(rootDir, relPath);
+    let code;
+    try {
+      code = fs.readFileSync(absPath, 'utf-8');
+    } catch (e) {
+      debug(`cfg: cannot read ${relPath}: ${e.message}`);
+      return null;
+    }
+
+    const parser = getParserFn(parsers, absPath);
+    if (!parser) return null;
+
+    try {
+      tree = parser.parse(code);
+    } catch (e) {
+      debug(`cfg: parse failed for ${relPath}: ${e.message}`);
+      return null;
+    }
+  }
+
+  if (!langId) {
+    langId = extToLang.get(ext);
+    if (!langId) return null;
+  }
+
+  return { tree, langId };
+}
+
+function buildVisitorCfgMap(tree, cfgRules, symbols, langId) {
+  const needsVisitor =
+    tree &&
+    symbols.definitions.some(
+      (d) =>
+        (d.kind === 'function' || d.kind === 'method') &&
+        d.line &&
+        d.cfg !== null &&
+        !d.cfg?.blocks?.length,
+    );
+  if (!needsVisitor) return null;
+
+  const visitor = createCfgVisitor(cfgRules);
+  const walkerOpts = {
+    functionNodeTypes: new Set(cfgRules.functionNodes),
+    nestingNodeTypes: new Set(),
+    getFunctionName: (node) => {
+      const nameNode = node.childForFieldName('name');
+      return nameNode ? nameNode.text : null;
+    },
+  };
+  const walkResults = walkWithVisitors(tree.rootNode, [visitor], langId, walkerOpts);
+  const cfgResults = walkResults.cfg || [];
+  const visitorCfgByLine = new Map();
+  for (const r of cfgResults) {
+    if (r.funcNode) {
+      const line = r.funcNode.startPosition.row + 1;
+      if (!visitorCfgByLine.has(line)) visitorCfgByLine.set(line, []);
+      visitorCfgByLine.get(line).push(r);
+    }
   }
+  return visitorCfgByLine;
+}
+
+function persistCfg(cfg, nodeId, insertBlock, insertEdge) {
+  const blockDbIds = new Map();
+  for (const block of cfg.blocks) {
+    const result = insertBlock.run(
+      nodeId,
+      block.index,
+      block.type,
+      block.startLine,
+      block.endLine,
+      block.label,
+    );
+    blockDbIds.set(block.index, result.lastInsertRowid);
+  }
+
+  for (const edge of cfg.edges) {
+    const sourceDbId = blockDbIds.get(edge.sourceIndex);
+    const targetDbId = blockDbIds.get(edge.targetIndex);
+    if (sourceDbId && targetDbId) {
+      insertEdge.run(nodeId, sourceDbId, targetDbId, edge.kind);
+    }
+  }
+}
 
-  // findFunctionNode imported from ./ast-analysis/shared.js at module level
+// ─── Build-Time: Compute CFG for Changed Files ─────────────────────────
+
+/**
+ * Build CFG data for all function/method definitions and persist to DB.
+ *
+ * @param {object} db - open better-sqlite3 database (read-write)
+ * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, _tree, _langId }>
+ * @param {string} rootDir - absolute project root path
+ * @param {object} [_engineOpts] - engine options (unused; always uses WASM for AST)
+ */
+export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
+  const extToLang = buildExtToLangMap();
+  const { parsers, getParserFn } = await initCfgParsers(fileSymbols);
 
   const insertBlock = db.prepare(
     `INSERT INTO cfg_blocks (function_node_id, block_index, block_type, start_line, end_line, label)
@@ -131,79 +229,14 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
       const ext = path.extname(relPath).toLowerCase();
       if (!CFG_EXTENSIONS.has(ext)) continue;
 
-      let tree = symbols._tree;
-      let langId = symbols._langId;
-
-      // Check if all defs already have native CFG — skip WASM parse if so
-      const allNative = symbols.definitions
-        .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
-        .every((d) => d.cfg === null || d.cfg?.blocks?.length);
-
-      // WASM fallback if no cached tree and not all native
-      if (!tree && !allNative) {
-        if (!getParserFn) continue;
-        langId = extToLang.get(ext);
-        if (!langId || !CFG_RULES.has(langId)) continue;
-
-        const absPath = path.join(rootDir, relPath);
-        let code;
-        try {
-          code = fs.readFileSync(absPath, 'utf-8');
-        } catch {
-          continue;
-        }
-
-        const parser = getParserFn(parsers, absPath);
-        if (!parser) continue;
-
-        try {
-          tree = parser.parse(code);
-        } catch {
-          continue;
-        }
-      }
-
-      if (!langId) {
-        langId = extToLang.get(ext);
-        if (!langId) continue;
-      }
+      const treeLang = getTreeAndLang(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
+      if (!treeLang) continue;
+      const { tree, langId } = treeLang;
 
       const cfgRules = CFG_RULES.get(langId);
       if (!cfgRules) continue;
 
-      // WASM fallback: run file-level visitor walk to compute CFG for all functions
-      // that don't already have pre-computed data (from native engine or unified walk)
-      let visitorCfgByLine = null;
-      const needsVisitor =
-        tree &&
-        symbols.definitions.some(
-          (d) =>
-            (d.kind === 'function' || d.kind === 'method') &&
-            d.line &&
-            d.cfg !== null &&
-            !d.cfg?.blocks?.length,
-        );
-      if (needsVisitor) {
-        const visitor = createCfgVisitor(cfgRules);
-        const walkerOpts = {
-          functionNodeTypes: new Set(cfgRules.functionNodes),
-          nestingNodeTypes: new Set(),
-          getFunctionName: (node) => {
-            const nameNode = node.childForFieldName('name');
-            return nameNode ? nameNode.text : null;
-          },
-        };
-        const walkResults = walkWithVisitors(tree.rootNode, [visitor], langId, walkerOpts);
-        const cfgResults = walkResults.cfg || [];
-        visitorCfgByLine = new Map();
-        for (const r of cfgResults) {
-          if (r.funcNode) {
-            const line = r.funcNode.startPosition.row + 1;
-            if (!visitorCfgByLine.has(line)) visitorCfgByLine.set(line, []);
-            visitorCfgByLine.get(line).push(r);
-          }
-        }
-      }
+      const visitorCfgByLine = buildVisitorCfgMap(tree, cfgRules, symbols, langId);
 
       for (const def of symbols.definitions) {
         if (def.kind !== 'function' && def.kind !== 'method') continue;
@@ -212,7 +245,6 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
         const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
         if (!nodeId) continue;
 
-        // Use pre-computed CFG (native engine or unified walk), then visitor fallback
         let cfg = null;
         if (def.cfg?.blocks?.length) {
           cfg = def.cfg;
@@ -231,36 +263,10 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
 
         if (!cfg || cfg.blocks.length === 0) continue;
 
-        // Clear old CFG data for this function
         deleteCfgForNode(db, nodeId);
-
-        // Insert blocks and build index→dbId mapping
-        const blockDbIds = new Map();
-        for (const block of cfg.blocks) {
-          const result = insertBlock.run(
-            nodeId,
-            block.index,
-            block.type,
-            block.startLine,
-            block.endLine,
-            block.label,
-          );
-          blockDbIds.set(block.index, result.lastInsertRowid);
-        }
-
-        // Insert edges
-        for (const edge of cfg.edges) {
-          const sourceDbId = blockDbIds.get(edge.sourceIndex);
-          const targetDbId = blockDbIds.get(edge.targetIndex);
-          if (sourceDbId && targetDbId) {
-            insertEdge.run(nodeId, sourceDbId, targetDbId, edge.kind);
-          }
-        }
-
+        persistCfg(cfg, nodeId, insertBlock, insertEdge);
         analyzed++;
       }
-
-      // Don't release _tree here — complexity/dataflow may still need it
     }
   });
 
@@ -273,27 +279,7 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
 
 // ─── Query-Time Functions ───────────────────────────────────────────────
 
-function findNodes(db, name, opts = {}) {
-  const kinds = opts.kind ? [opts.kind] : ['function', 'method'];
-  const placeholders = kinds.map(() => '?').join(', ');
-  const params = [`%${name}%`, ...kinds];
-
-  let fileCondition = '';
-  if (opts.file) {
-    fileCondition = ' AND n.file LIKE ?';
-    params.push(`%${opts.file}%`);
-  }
-
-  const rows = db
-    .prepare(
-      `SELECT n.id, n.name, n.kind, n.file, n.line, n.end_line
-       FROM nodes n
-       WHERE n.name LIKE ? AND n.kind IN (${placeholders})${fileCondition}`,
-    )
-    .all(...params);
-
-  return opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
-}
+const CFG_DEFAULT_KINDS = ['function', 'method'];
 
 /**
  * Load CFG data for a function from the database.
@@ -317,7 +303,12 @@ export function cfgData(name, customDbPath, opts = {}) {
       };
     }
 
-    const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findNodes(
+      db,
+      name,
+      { noTests, file: opts.file, kind: opts.kind },
+      CFG_DEFAULT_KINDS,
+    );
     if (nodes.length === 0) {
       return { name, results: [] };
     }

package/src/{check.js → features/check.js}

@@ -1,10 +1,11 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadConfig } from './config.js';
-import { findCycles } from './cycles.js';
-import { findDbPath, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
+import { findDbPath, openReadonlyOrFail } from '../db/index.js';
+import { bfsTransitiveCallers } from '../domain/analysis/impact.js';
+import { findCycles } from '../domain/graph/cycles.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
 import { matchOwners, parseCodeowners } from './owners.js';
 
 // ─── Diff Parser ──────────────────────────────────────────────────────
@@ -96,31 +97,10 @@ export function checkMaxBlastRadius(db, changedRanges, threshold, noTests, maxDe
       }
       if (!overlaps) continue;
 
-      // BFS transitive callers
-      const visited = new Set([def.id]);
-      let frontier = [def.id];
-      let totalCallers = 0;
-      for (let d = 1; d <= maxDepth; d++) {
-        const nextFrontier = [];
-        for (const fid of frontier) {
-          const callers = db
-            .prepare(
-              `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line
-               FROM edges e JOIN nodes n ON e.source_id = n.id
-               WHERE e.target_id = ? AND e.kind = 'calls'`,
-            )
-            .all(fid);
-          for (const c of callers) {
-            if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-              visited.add(c.id);
-              nextFrontier.push(c.id);
-              totalCallers++;
-            }
-          }
-        }
-        frontier = nextFrontier;
-        if (frontier.length === 0) break;
-      }
+      const { totalDependents: totalCallers } = bfsTransitiveCallers(db, def.id, {
+        noTests,
+        maxDepth,
+      });
 
       if (totalCallers > maxFound) maxFound = totalCallers;
       if (totalCallers > threshold) {
@@ -240,7 +220,10 @@ export function checkData(customDbPath, opts = {}) {
     const maxDepth = opts.depth || 3;
 
     // Load config defaults for check predicates
-    const config = loadConfig(repoRoot);
+    // NOTE: opts.config is loaded from process.cwd() at startup (via CLI context),
+    // which may differ from the DB's parent repo root when --db points to an external
+    // project. This is an acceptable trade-off to avoid duplicate I/O on the hot path.
+    const config = opts.config || loadConfig(repoRoot);
     const checkConfig = config.check || {};
 
     // Resolve which predicates are enabled: CLI flags ?? config ?? built-in defaults