@optave/codegraph 3.1.4 → 3.1.5

package/src/cli/shared/options.js

@@ -1,4 +1,4 @@
-import { loadConfig } from '../../config.js';
+import { loadConfig } from '../../infrastructure/config.js';
 
 const config = loadConfig(process.cwd());
 
@@ -15,7 +15,9 @@ export function applyQueryOpts(cmd) {
     .option('-j, --json', 'Output as JSON')
     .option('--limit <number>', 'Max results to return')
     .option('--offset <number>', 'Skip N results (default: 0)')
-    .option('--ndjson', 'Newline-delimited JSON output');
+    .option('--ndjson', 'Newline-delimited JSON output')
+    .option('--table', 'Output as aligned table')
+    .option('--csv', 'Output as CSV');
 }
 
 /**
@@ -30,6 +32,24 @@ export function resolveNoTests(opts) {
   return config.query?.excludeTests || false;
 }
 
+/**
+ * Extract the common query option fields shared by most analysis commands.
+ *
+ * Spreads cleanly into per-command option objects:
+ *   `{ ...resolveQueryOpts(opts), depth: parseInt(opts.depth, 10) }`
+ */
+export function resolveQueryOpts(opts) {
+  return {
+    noTests: resolveNoTests(opts),
+    json: opts.json,
+    ndjson: opts.ndjson,
+    table: opts.table,
+    csv: opts.csv,
+    limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+    offset: opts.offset ? parseInt(opts.offset, 10) : undefined,
+  };
+}
+
 export function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;

package/src/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { run } from './cli/index.js';
-import { CodegraphError } from './errors.js';
+import { CodegraphError } from './shared/errors.js';
 
 run().catch((err) => {
   if (err instanceof CodegraphError) {

package/src/db/connection.js

@@ -1,8 +1,60 @@
+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 {
+      root = path.resolve(raw);
+    }
+  } catch {
+    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 {
@@ -44,6 +96,22 @@ function releaseAdvisoryLock(lockPath) {
   }
 }
 
+/**
+ * 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 {
+    return false;
+  }
+}
+
 export function openDb(dbPath) {
   const dir = path.dirname(dbPath);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -62,15 +130,41 @@ 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 {
+      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 {
+    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 +180,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 = [

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,13 @@ function validateEdgeKind(edgeKind) {
   }
 }
 
+// ─── LIKE Escaping ──────────────────────────────────────────────────
+
+/** Escape LIKE wildcards in a literal string segment. */
+export function escapeLike(s) {
+  return s.replace(/[%_\\]/g, '\\$&');
+}
+
 // ─── Standalone Helpers ──────────────────────────────────────────────
 
 /**
@@ -164,11 +171,11 @@ export class NodeQuery {
     return this;
   }
 
-  /** WHERE n.file LIKE ? (no-op if falsy). */
+  /** WHERE n.file LIKE ? (no-op if falsy). Escapes LIKE wildcards in the value. */
   fileFilter(file) {
     if (!file) return this;
-    this.#conditions.push('n.file LIKE ?');
-    this.#params.push(`%${file}%`);
+    this.#conditions.push("n.file LIKE ? ESCAPE '\\'");
+    this.#params.push(`%${escapeLike(file)}%`);
     return this;
   }
 
@@ -188,11 +195,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 } 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).
@@ -498,7 +489,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() {

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 { escapeLike, 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.

package/src/{analysis → domain/analysis}/context.js

@@ -12,18 +12,18 @@ import {
   findNodesByFile,
   getComplexityForNode,
   openReadonlyOrFail,
-} from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { paginateResult } from '../paginate.js';
+} from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
 import {
   createFileLinesReader,
   extractSignature,
   extractSummary,
   isFileLikeTarget,
   readSourceRange,
-} from '../shared/file-utils.js';
-import { resolveMethodViaHierarchy } from '../shared/hierarchy.js';
-import { normalizeSymbol } from '../shared/normalize.js';
+} from '../../shared/file-utils.js';
+import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 function explainFileImpl(db, target, getFileLines) {

package/src/{analysis → domain/analysis}/dependencies.js

@@ -6,11 +6,11 @@ import {
   findImportTargets,
   findNodesByFile,
   openReadonlyOrFail,
-} from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { paginateResult } from '../paginate.js';
-import { resolveMethodViaHierarchy } from '../shared/hierarchy.js';
-import { normalizeSymbol } from '../shared/normalize.js';
+} from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 export function fileDepsData(file, customDbPath, opts = {}) {

package/src/{analysis → domain/analysis}/exports.js

@@ -5,10 +5,14 @@ import {
   findFileNodes,
   findNodesByFile,
   openReadonlyOrFail,
-} from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { paginateResult } from '../paginate.js';
-import { createFileLinesReader, extractSignature, extractSummary } from '../shared/file-utils.js';
+} from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import {
+  createFileLinesReader,
+  extractSignature,
+  extractSummary,
+} from '../../shared/file-utils.js';
+import { paginateResult } from '../../shared/paginate.js';
 
 export function exportsData(file, customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);

package/src/{analysis → domain/analysis}/impact.js

@@ -1,9 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { evaluateBoundaries } from '../boundaries.js';
-import { coChangeForFiles } from '../cochange.js';
-import { loadConfig } from '../config.js';
 import {
   findDbPath,
   findDistinctCallers,
@@ -11,13 +8,52 @@ import {
   findImportDependents,
   findNodeById,
   openReadonlyOrFail,
-} from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { ownersForFiles } from '../owners.js';
-import { paginateResult } from '../paginate.js';
-import { normalizeSymbol } from '../shared/normalize.js';
+} from '../../db/index.js';
+import { evaluateBoundaries } from '../../features/boundaries.js';
+import { coChangeForFiles } from '../../features/cochange.js';
+import { ownersForFiles } from '../../features/owners.js';
+import { loadConfig } from '../../infrastructure/config.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
+// ─── Shared BFS: transitive callers ────────────────────────────────────
+
+/**
+ * BFS traversal to find transitive callers of a node.
+ *
+ * @param {import('better-sqlite3').Database} db - Open read-only SQLite database handle (not a Repository)
+ * @param {number} startId - Starting node ID
+ * @param {{ noTests?: boolean, maxDepth?: number, onVisit?: (caller: object, parentId: number, depth: number) => void }} options
+ * @returns {{ totalDependents: number, levels: Record<number, Array<{name:string, kind:string, file:string, line:number}>> }}
+ */
+export function bfsTransitiveCallers(db, startId, { noTests = false, maxDepth = 3, onVisit } = {}) {
+  const visited = new Set([startId]);
+  const levels = {};
+  let frontier = [startId];
+
+  for (let d = 1; d <= maxDepth; d++) {
+    const nextFrontier = [];
+    for (const fid of frontier) {
+      const callers = findDistinctCallers(db, fid);
+      for (const c of callers) {
+        if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
+          visited.add(c.id);
+          nextFrontier.push(c.id);
+          if (!levels[d]) levels[d] = [];
+          levels[d].push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
+          if (onVisit) onVisit(c, fid, d);
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+
+  return { totalDependents: visited.size - 1, levels };
+}
+
 export function impactAnalysisData(file, customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   try {
@@ -82,31 +118,11 @@ export function fnImpactData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      const visited = new Set([node.id]);
-      const levels = {};
-      let frontier = [node.id];
-
-      for (let d = 1; d <= maxDepth; d++) {
-        const nextFrontier = [];
-        for (const fid of frontier) {
-          const callers = findDistinctCallers(db, fid);
-          for (const c of callers) {
-            if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-              visited.add(c.id);
-              nextFrontier.push(c.id);
-              if (!levels[d]) levels[d] = [];
-              levels[d].push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
-            }
-          }
-        }
-        frontier = nextFrontier;
-        if (frontier.length === 0) break;
-      }
-
+      const { levels, totalDependents } = bfsTransitiveCallers(db, node.id, { noTests, maxDepth });
       return {
         ...normalizeSymbol(node, db, hc),
         levels,
-        totalDependents: visited.size - 1,
+        totalDependents,
       };
     });
 
@@ -232,40 +248,27 @@ export function diffImpactData(customDbPath, opts = {}) {
 
     const allAffected = new Set();
     const functionResults = affectedFunctions.map((fn) => {
-      const visited = new Set([fn.id]);
-      let frontier = [fn.id];
-      let totalCallers = 0;
-      const levels = {};
       const edges = [];
       const idToKey = new Map();
       idToKey.set(fn.id, `${fn.file}::${fn.name}:${fn.line}`);
-      for (let d = 1; d <= maxDepth; d++) {
-        const nextFrontier = [];
-        for (const fid of frontier) {
-          const callers = findDistinctCallers(db, fid);
-          for (const c of callers) {
-            if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-              visited.add(c.id);
-              nextFrontier.push(c.id);
-              allAffected.add(`${c.file}:${c.name}`);
-              const callerKey = `${c.file}::${c.name}:${c.line}`;
-              idToKey.set(c.id, callerKey);
-              if (!levels[d]) levels[d] = [];
-              levels[d].push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
-              edges.push({ from: idToKey.get(fid), to: callerKey });
-              totalCallers++;
-            }
-          }
-        }
-        frontier = nextFrontier;
-        if (frontier.length === 0) break;
-      }
+
+      const { levels, totalDependents } = bfsTransitiveCallers(db, fn.id, {
+        noTests,
+        maxDepth,
+        onVisit(c, parentId) {
+          allAffected.add(`${c.file}:${c.name}`);
+          const callerKey = `${c.file}::${c.name}:${c.line}`;
+          idToKey.set(c.id, callerKey);
+          edges.push({ from: idToKey.get(parentId), to: callerKey });
+        },
+      });
+
       return {
         name: fn.name,
         kind: fn.kind,
         file: fn.file,
         line: fn.line,
-        transitiveCallers: totalCallers,
+        transitiveCallers: totalDependents,
         levels,
         edges,
       };
@@ -310,8 +313,8 @@ export function diffImpactData(customDbPath, opts = {}) {
     let boundaryViolations = [];
     let boundaryViolationCount = 0;
     try {
-      const config = loadConfig(repoRoot);
-      const boundaryConfig = config.manifesto?.boundaries;
+      const cfg = opts.config || loadConfig(repoRoot);
+      const boundaryConfig = cfg.manifesto?.boundaries;
       if (boundaryConfig) {
         const result = evaluateBoundaries(db, boundaryConfig, {
           scopeFiles: [...changedRanges.keys()],

package/src/{analysis → domain/analysis}/module-map.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import { findCycles } from '../cycles.js';
-import { openReadonlyOrFail, testFilterSQL } from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
+import { openReadonlyOrFail, testFilterSQL } from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { findCycles } from '../graph/cycles.js';
 import { LANGUAGE_REGISTRY } from '../parser.js';
 
 export const FALSE_POSITIVE_NAMES = new Set([

package/src/{analysis → domain/analysis}/roles.js

@@ -1,7 +1,7 @@
-import { openReadonlyOrFail } from '../db.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { paginateResult } from '../paginate.js';
-import { normalizeSymbol } from '../shared/normalize.js';
+import { openReadonlyOrFail } from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
 
 export function rolesData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);