@optave/codegraph 3.8.0 → 3.9.0

package/src/db/repository/sqlite-repository.ts

@@ -154,6 +154,32 @@ export class SqliteRepository extends Repository {
     return findCallers(this.#db, nodeId);
   }
 
+  findCallersBatch(nodeIds: number[]): Map<number, RelatedNodeRow[]> {
+    if (nodeIds.length === 0) return new Map();
+    const placeholders = nodeIds.map(() => '?').join(',');
+    const rows = this.#db
+      .prepare(
+        `SELECT e.target_id AS queried_id, n.id, n.name, n.kind, n.file, n.line, n.end_line
+         FROM edges e JOIN nodes n ON e.source_id = n.id
+         WHERE e.target_id IN (${placeholders}) AND e.kind = 'calls'`,
+      )
+      .all(...nodeIds) as Array<RelatedNodeRow & { queried_id: number }>;
+    const result = new Map<number, RelatedNodeRow[]>();
+    for (const row of rows) {
+      const qid = row.queried_id;
+      if (!result.has(qid)) result.set(qid, []);
+      result.get(qid)!.push({
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        file: row.file,
+        line: row.line,
+        end_line: row.end_line,
+      });
+    }
+    return result;
+  }
+
   findDistinctCallers(nodeId: number): RelatedNodeRow[] {
     return findDistinctCallers(this.#db, nodeId);
   }
@@ -245,4 +271,33 @@ export class SqliteRepository extends Repository {
   getComplexityForNode(nodeId: number): ComplexityMetrics | undefined {
     return getComplexityForNode(this.#db, nodeId);
   }
+
+  // ── Convenience queries ────────────────────────────────────────────
+
+  getFileHash(file: string): string | null {
+    const row = this.#db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file) as
+      | { hash: string }
+      | undefined;
+    return row?.hash ?? null;
+  }
+
+  #implementsEdgesCache?: boolean;
+  hasImplementsEdges(): boolean {
+    if (this.#implementsEdgesCache !== undefined) return this.#implementsEdgesCache;
+    this.#implementsEdgesCache = !!this.#db
+      .prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1")
+      .get();
+    return this.#implementsEdgesCache;
+  }
+
+  #coChangesTableCache?: boolean;
+  hasCoChangesTable(): boolean {
+    if (this.#coChangesTableCache !== undefined) return this.#coChangesTableCache;
+    try {
+      this.#coChangesTableCache = !!this.#db.prepare('SELECT 1 FROM co_changes LIMIT 1').get();
+    } catch {
+      this.#coChangesTableCache = false;
+    }
+    return this.#coChangesTableCache;
+  }
 }

package/src/domain/analysis/brief.ts

@@ -1,15 +1,8 @@
-import {
-  findDistinctCallers,
-  findFileNodes,
-  findImportDependents,
-  findImportSources,
-  findImportTargets,
-  findNodesByFile,
-  openReadonlyOrFail,
-} from '../../db/index.js';
+import type { Repository } from '../../db/index.js';
 import { loadConfig } from '../../infrastructure/config.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
-import type { BetterSqlite3Database, ImportEdgeRow, NodeRow, RelatedNodeRow } from '../../types.js';
+import type { ImportEdgeRow, NodeRow, RelatedNodeRow } from '../../types.js';
+import { withRepo } from './query-helpers.js';
 
 /** Symbol kinds meaningful for a file brief — excludes parameters, properties, constants. */
 const BRIEF_KINDS = new Set([
@@ -49,7 +42,7 @@ function computeRiskTier(
  * Lightweight variant — only counts, does not collect details.
  */
 function countTransitiveCallers(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   startId: number,
   noTests: boolean,
   maxDepth = 5,
@@ -60,7 +53,7 @@ function countTransitiveCallers(
   for (let d = 1; d <= maxDepth; d++) {
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = findDistinctCallers(db, fid) as RelatedNodeRow[];
+      const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
       for (const c of callers) {
         if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
           visited.add(c.id);
@@ -80,7 +73,7 @@ function countTransitiveCallers(
  * Depth-bounded to match countTransitiveCallers and keep hook latency predictable.
  */
 function countTransitiveImporters(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   fileNodeIds: number[],
   noTests: boolean,
   maxDepth = 5,
@@ -91,7 +84,7 @@ function countTransitiveImporters(
   for (let d = 1; d <= maxDepth; d++) {
     const nextFrontier: number[] = [];
     for (const current of frontier) {
-      const dependents = findImportDependents(db, current) as RelatedNodeRow[];
+      const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
       for (const dep of dependents) {
         if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
           visited.add(dep.id);
@@ -115,38 +108,37 @@ export function briefData(
   customDbPath: string,
   opts: { noTests?: boolean; config?: any } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
     const config = opts.config || loadConfig();
     const callerDepth = config.analysis?.briefCallerDepth ?? 5;
     const importerDepth = config.analysis?.briefImporterDepth ?? 5;
     const highRiskCallers = config.analysis?.briefHighRiskCallers ?? 10;
     const mediumRiskCallers = config.analysis?.briefMediumRiskCallers ?? 3;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, results: [] };
     }
 
     const results = fileNodes.map((fn) => {
       // Direct importers
-      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
+      let importedBy = repo.findImportSources(fn.id) as ImportEdgeRow[];
       if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
       const directImporters = [...new Set(importedBy.map((i) => i.file))];
 
       // Transitive importer count
-      const totalImporterCount = countTransitiveImporters(db, [fn.id], noTests, importerDepth);
+      const totalImporterCount = countTransitiveImporters(repo, [fn.id], noTests, importerDepth);
 
       // Direct imports
-      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
+      let importsTo = repo.findImportTargets(fn.id) as ImportEdgeRow[];
       if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
 
       // Symbol definitions with roles and caller counts
-      const defs = (findNodesByFile(db, fn.file) as NodeRow[]).filter((d) =>
+      const defs = (repo.findNodesByFile(fn.file) as NodeRow[]).filter((d) =>
         BRIEF_KINDS.has(d.kind),
       );
       const symbols = defs.map((d) => {
-        const callerCount = countTransitiveCallers(db, d.id, noTests, callerDepth);
+        const callerCount = countTransitiveCallers(repo, d.id, noTests, callerDepth);
         return {
           name: d.name,
           kind: d.kind,
@@ -169,7 +161,5 @@ export function briefData(
     });
 
     return { file, results };
-  } finally {
-    db.close();
-  }
+  });
 }

package/src/domain/analysis/context.ts

@@ -264,6 +264,22 @@ function getNodeChildrenSafe(db: BetterSqlite3Database, nodeId: number) {
   }
 }
 
+function buildIntraFileDataFlow(
+  db: BetterSqlite3Database,
+  file: string,
+): Array<{ caller: string; callees: string[] }> {
+  const intraEdges = findIntraFileCallEdges(db, file) as IntraFileCallEdge[];
+  const dataFlowMap = new Map<string, string[]>();
+  for (const edge of intraEdges) {
+    if (!dataFlowMap.has(edge.caller_name)) dataFlowMap.set(edge.caller_name, []);
+    dataFlowMap.get(edge.caller_name)!.push(edge.callee_name);
+  }
+  return [...dataFlowMap.entries()].map(([caller, callees]) => ({
+    caller,
+    callees,
+  }));
+}
+
 function explainFileImpl(
   db: BetterSqlite3Database,
   target: string,
@@ -299,16 +315,7 @@ function explainFileImpl(
       file: r.file,
     }));
 
-    const intraEdges = findIntraFileCallEdges(db, fn.file) as IntraFileCallEdge[];
-    const dataFlowMap = new Map<string, string[]>();
-    for (const edge of intraEdges) {
-      if (!dataFlowMap.has(edge.caller_name)) dataFlowMap.set(edge.caller_name, []);
-      dataFlowMap.get(edge.caller_name)!.push(edge.callee_name);
-    }
-    const dataFlow = [...dataFlowMap.entries()].map(([caller, callees]) => ({
-      caller,
-      callees,
-    }));
+    const dataFlow = buildIntraFileDataFlow(db, fn.file);
 
     const metric = getLineCountForNode(db, fn.id) as { line_count: number } | undefined;
     let lineCount: number | null = metric?.line_count || null;

package/src/domain/analysis/dependencies.ts

@@ -1,11 +1,4 @@
-import {
-  findCallees,
-  findCallers,
-  findFileNodes,
-  findImportSources,
-  findImportTargets,
-  findNodesByFile,
-} from '../../db/index.js';
+import { findFileNodes, type Repository } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
@@ -18,13 +11,11 @@ import type {
   RelatedNodeRow,
   StmtCache,
 } from '../../types.js';
-import { withReadonlyDb } from './query-helpers.js';
+import { withReadonlyDb, withRepo } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
-type UpstreamRow = { id: number; name: string; kind: string; file: string; line: number };
 type NodeByIdRow = { name: string; kind: string; file: string; line: number };
 
-const _upstreamStmtCache: StmtCache<UpstreamRow> = new WeakMap();
 const _nodeByIdStmtCache: StmtCache<NodeByIdRow> = new WeakMap();
 
 export function fileDepsData(
@@ -32,21 +23,21 @@ export function fileDepsData(
   customDbPath: string,
   opts: { noTests?: boolean; limit?: number; offset?: number } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, results: [] };
     }
 
     const results = fileNodes.map((fn) => {
-      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
+      let importsTo = repo.findImportTargets(fn.id) as ImportEdgeRow[];
       if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
 
-      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
+      let importedBy = repo.findImportSources(fn.id) as ImportEdgeRow[];
       if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
 
-      const defs = findNodesByFile(db, fn.file) as NodeRow[];
+      const defs = repo.findNodesByFile(fn.file) as NodeRow[];
 
       return {
         file: fn.file,
@@ -64,9 +55,11 @@ export function fileDepsData(
 /**
  * BFS transitive caller traversal starting from `callers` of `nodeId`.
  * Returns an object keyed by depth (2..depth) -> array of caller descriptors.
+ *
+ * Uses Repository.findCallers() so it works with both native and WASM engines.
  */
 function buildTransitiveCallers(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   callers: Array<{ id: number; name: string; kind: string; file: string; line: number }>,
   nodeId: number,
   depth: number,
@@ -81,31 +74,21 @@ function buildTransitiveCallers(
   const visited = new Set([nodeId]);
   let frontier = callers;
 
-  const upstreamStmt = cachedStmt(
-    _upstreamStmtCache,
-    db,
-    `
-    SELECT 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'
-  `,
-  );
-
   for (let d = 2; d <= depth; d++) {
+    // Collect unvisited frontier IDs for a single batched query per depth
+    const unvisited = frontier.filter((f) => !visited.has(f.id));
+    for (const f of unvisited) visited.add(f.id);
+    if (unvisited.length === 0) break;
+
+    const batchCallers = repo.findCallersBatch(unvisited.map((f) => f.id));
     const nextFrontier: typeof frontier = [];
-    for (const f of frontier) {
-      if (visited.has(f.id)) continue;
-      visited.add(f.id);
-      const upstream = upstreamStmt.all(f.id) as Array<{
-        id: number;
-        name: string;
-        kind: string;
-        file: string;
-        line: number;
-      }>;
+    const nextFrontierIds = new Set<number>();
+    for (const f of unvisited) {
+      const upstream = batchCallers.get(f.id) || [];
       for (const u of upstream) {
         if (noTests && isTestFile(u.file)) continue;
-        if (!visited.has(u.id)) {
+        if (!visited.has(u.id) && !nextFrontierIds.has(u.id)) {
+          nextFrontierIds.add(u.id);
           nextFrontier.push(u);
         }
       }
@@ -119,12 +102,64 @@ function buildTransitiveCallers(
       }));
     }
     frontier = nextFrontier;
-    if (frontier.length === 0) break;
   }
 
   return transitiveCallers;
 }
 
+function collectCallersWithHierarchy(
+  repo: InstanceType<typeof Repository>,
+  node: NodeRow,
+  noTests: boolean,
+): Array<RelatedNodeRow & { viaHierarchy?: string }> {
+  let callers: Array<RelatedNodeRow & { viaHierarchy?: string }> = repo.findCallers(
+    node.id,
+  ) as RelatedNodeRow[];
+
+  if (node.kind === 'method' && node.name.includes('.')) {
+    const methodName = node.name.split('.').pop()!;
+    const relatedMethods = resolveMethodViaHierarchy(repo, methodName);
+    for (const rm of relatedMethods) {
+      if (rm.id === node.id) continue;
+      const extraCallers = repo.findCallers(rm.id) as RelatedNodeRow[];
+      callers.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
+    }
+  }
+  if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
+  return callers;
+}
+
+function buildNodeDepsResult(
+  repo: InstanceType<typeof Repository>,
+  node: NodeRow,
+  hc: Map<string, string | null>,
+  depth: number,
+  noTests: boolean,
+) {
+  const callees = repo.findCallees(node.id) as RelatedNodeRow[];
+  const filteredCallees = noTests ? callees.filter((c) => !isTestFile(c.file)) : callees;
+  const callers = collectCallersWithHierarchy(repo, node, noTests);
+  const transitiveCallers = buildTransitiveCallers(repo, callers, node.id, depth, noTests);
+
+  return {
+    ...normalizeSymbol(node, repo, hc),
+    callees: filteredCallees.map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+    })),
+    callers: callers.map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+      viaHierarchy: c.viaHierarchy || undefined,
+    })),
+    transitiveCallers,
+  };
+}
+
 export function fnDepsData(
   name: string,
   customDbPath: string,
@@ -137,56 +172,17 @@ export function fnDepsData(
     offset?: number;
   } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const depth = opts.depth || 3;
     const noTests = opts.noTests || false;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findMatchingNodes(repo, name, { noTests, file: opts.file, kind: opts.kind });
     if (nodes.length === 0) {
       return { name, results: [] };
     }
 
-    const results = nodes.map((node) => {
-      const callees = findCallees(db, node.id) as RelatedNodeRow[];
-      const filteredCallees = noTests ? callees.filter((c) => !isTestFile(c.file)) : callees;
-
-      let callers: Array<RelatedNodeRow & { viaHierarchy?: string }> = findCallers(
-        db,
-        node.id,
-      ) as RelatedNodeRow[];
-
-      if (node.kind === 'method' && node.name.includes('.')) {
-        const methodName = node.name.split('.').pop()!;
-        const relatedMethods = resolveMethodViaHierarchy(db, methodName);
-        for (const rm of relatedMethods) {
-          if (rm.id === node.id) continue;
-          const extraCallers = findCallers(db, rm.id) as RelatedNodeRow[];
-          callers.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
-        }
-      }
-      if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
-
-      const transitiveCallers = buildTransitiveCallers(db, callers, node.id, depth, noTests);
-
-      return {
-        ...normalizeSymbol(node, db, hc),
-        callees: filteredCallees.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          file: c.file,
-          line: c.line,
-        })),
-        callers: callers.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          file: c.file,
-          line: c.line,
-          viaHierarchy: c.viaHierarchy || undefined,
-        })),
-        transitiveCallers,
-      };
-    });
+    const results = nodes.map((node) => buildNodeDepsResult(repo, node, hc, depth, noTests));
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });

package/src/domain/analysis/fn-impact.ts

@@ -1,40 +1,32 @@
-import {
-  findDistinctCallers,
-  findFileNodes,
-  findImplementors,
-  findImportDependents,
-  findNodeById,
-} from '../../db/index.js';
+import { Repository, SqliteRepository } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
-import { resolveAnalysisOpts, withReadonlyDb } from './query-helpers.js';
+import { resolveAnalysisOpts, withRepo } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
+/** Cache so repeated raw-db calls reuse the same SqliteRepository (preserves per-instance memoization). */
+const repoCache = new WeakMap<BetterSqlite3Database, InstanceType<typeof SqliteRepository>>();
+
+/** Coerce a raw db handle or Repository into a Repository instance. */
+function toRepo(
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
+): InstanceType<typeof Repository> {
+  if (dbOrRepo instanceof Repository) return dbOrRepo;
+  const db = dbOrRepo as BetterSqlite3Database;
+  let repo = repoCache.get(db);
+  if (!repo) {
+    repo = new SqliteRepository(db);
+    repoCache.set(db, repo);
+  }
+  return repo;
+}
+
 // --- Shared BFS: transitive callers ---
 
 const INTERFACE_LIKE_KINDS = new Set(['interface', 'trait']);
 
-/**
- * Check whether the graph contains any 'implements' edges.
- * Cached per db handle so the query runs at most once per connection.
- */
-const _hasImplementsCache: WeakMap<BetterSqlite3Database, boolean> = new WeakMap();
-function hasImplementsEdges(db: BetterSqlite3Database): boolean {
-  if (_hasImplementsCache.has(db)) return _hasImplementsCache.get(db)!;
-  const row = db.prepare("SELECT 1 FROM edges WHERE kind = 'implements' LIMIT 1").get();
-  const result = !!row;
-  _hasImplementsCache.set(db, result);
-  return result;
-}
-
-/**
- * BFS traversal to find transitive callers of a node.
- * When an interface/trait node is encountered (either as the start node or
- * during traversal), its concrete implementors are also added to the frontier
- * so that changes to an interface signature propagate to all implementors.
- */
 type BfsLevel = Array<{
   name: string;
   kind: string;
@@ -76,7 +68,7 @@ function recordImplementor(
 
 /** Expand implementors for an interface/trait node into the BFS frontier. */
 function expandImplementors(
-  db: BetterSqlite3Database,
+  repo: InstanceType<typeof Repository>,
   nodeId: number,
   depth: number,
   visited: Set<number>,
@@ -85,14 +77,14 @@ function expandImplementors(
   noTests: boolean,
   onVisit?: BfsOnVisit,
 ): void {
-  const impls = findImplementors(db, nodeId) as RelatedNodeRow[];
+  const impls = repo.findImplementors(nodeId) as RelatedNodeRow[];
   for (const impl of impls) {
     recordImplementor(impl, nodeId, depth, visited, frontier, levels, noTests, onVisit);
   }
 }
 
 export function bfsTransitiveCallers(
-  db: BetterSqlite3Database,
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
   startId: number,
   {
     noTests = false,
@@ -106,7 +98,8 @@ export function bfsTransitiveCallers(
     onVisit?: BfsOnVisit;
   } = {},
 ) {
-  const resolveImplementors = includeImplementors && hasImplementsEdges(db);
+  const repo = toRepo(dbOrRepo);
+  const resolveImplementors = includeImplementors && repo.hasImplementsEdges();
   const visited = new Set([startId]);
   const levels: BfsLevels = {};
   let frontier = [startId];
@@ -114,9 +107,9 @@ export function bfsTransitiveCallers(
   // Seed: if start node is an interface/trait, include its implementors at depth 1
   const implNextFrontier: number[] = [];
   if (resolveImplementors) {
-    const startNode = findNodeById(db, startId) as NodeRow | undefined;
+    const startNode = repo.findNodeById(startId) as NodeRow | undefined;
     if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
-      expandImplementors(db, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
+      expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
     }
   }
 
@@ -126,7 +119,7 @@ export function bfsTransitiveCallers(
     }
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = findDistinctCallers(db, fid) as RelatedNodeRow[];
+      const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
       for (const c of callers) {
         if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
           visited.add(c.id);
@@ -136,7 +129,7 @@ export function bfsTransitiveCallers(
           if (onVisit) onVisit(c, fid, d);
         }
         if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          expandImplementors(db, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
+          expandImplementors(repo, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
         }
       }
     }
@@ -152,9 +145,9 @@ export function impactAnalysisData(
   customDbPath: string,
   opts: { noTests?: boolean } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const noTests = opts.noTests || false;
-    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
+    const fileNodes = repo.findFileNodes(`%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, sources: [], levels: {}, totalDependents: 0 };
     }
@@ -172,7 +165,7 @@ export function impactAnalysisData(
     while (queue.length > 0) {
       const current = queue.shift()!;
       const level = levels.get(current)!;
-      const dependents = findImportDependents(db, current) as RelatedNodeRow[];
+      const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
       for (const dep of dependents) {
         if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
           visited.add(dep.id);
@@ -186,7 +179,7 @@ export function impactAnalysisData(
     for (const [id, level] of levels) {
       if (level === 0) continue;
       if (!byLevel[level]) byLevel[level] = [];
-      const node = findNodeById(db, id) as NodeRow | undefined;
+      const node = repo.findNodeById(id) as NodeRow | undefined;
       if (node) byLevel[level].push({ file: node.file });
     }
 
@@ -213,12 +206,12 @@ export function fnImpactData(
     config?: any;
   } = {},
 ) {
-  return withReadonlyDb(customDbPath, (db) => {
+  return withRepo(customDbPath, (repo) => {
     const { noTests, config } = resolveAnalysisOpts(opts);
     const maxDepth = opts.depth || config.analysis?.fnImpactDepth || 5;
     const hc = new Map();
 
-    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findMatchingNodes(repo, name, { noTests, file: opts.file, kind: opts.kind });
     if (nodes.length === 0) {
       return { name, results: [] };
     }
@@ -226,13 +219,13 @@ export function fnImpactData(
     const includeImplementors = opts.includeImplementors !== false;
 
     const results = nodes.map((node) => {
-      const { levels, totalDependents } = bfsTransitiveCallers(db, node.id, {
+      const { levels, totalDependents } = bfsTransitiveCallers(repo, node.id, {
         noTests,
         maxDepth,
         includeImplementors,
       });
       return {
-        ...normalizeSymbol(node, db, hc),
+        ...normalizeSymbol(node, repo, hc),
         levels,
         totalDependents,
       };