@optave/codegraph 3.11.0 → 3.11.1

package/src/domain/analysis/dependencies.ts

@@ -58,9 +58,32 @@ export function fileDepsData(
  *
  * Uses Repository.findCallers() so it works with both native and WASM engines.
  */
+type CallerRow = { id: number; name: string; kind: string; file: string; line: number };
+
+/** Compute the next BFS frontier from a batched upstream-callers lookup. */
+function buildNextCallerFrontier(
+  unvisited: CallerRow[],
+  batchCallers: Map<number, CallerRow[]>,
+  visited: Set<number>,
+  noTests: boolean,
+): CallerRow[] {
+  const nextFrontier: CallerRow[] = [];
+  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) || nextFrontierIds.has(u.id)) continue;
+      nextFrontierIds.add(u.id);
+      nextFrontier.push(u);
+    }
+  }
+  return nextFrontier;
+}
+
 function buildTransitiveCallers(
   repo: InstanceType<typeof Repository>,
-  callers: Array<{ id: number; name: string; kind: string; file: string; line: number }>,
+  callers: CallerRow[],
   nodeId: number,
   depth: number,
   noTests: boolean,
@@ -81,18 +104,8 @@ function buildTransitiveCallers(
     if (unvisited.length === 0) break;
 
     const batchCallers = repo.findCallersBatch(unvisited.map((f) => f.id));
-    const nextFrontier: typeof frontier = [];
-    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) && !nextFrontierIds.has(u.id)) {
-          nextFrontierIds.add(u.id);
-          nextFrontier.push(u);
-        }
-      }
-    }
+    const nextFrontier = buildNextCallerFrontier(unvisited, batchCallers, visited, noTests);
+
     if (nextFrontier.length > 0) {
       transitiveCallers[d] = nextFrontier.map((n) => ({
         name: n.name,
@@ -258,22 +271,30 @@ function resolveEndpoints(
   };
 }
 
-/**
- * BFS from sourceId toward targetId.
- * Returns { found, parent, alternateCount, foundDepth }.
- * `parent` maps nodeId -> { parentId, edgeKind }.
- */
-function bfsShortestPath(
+type NeighborRow = {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  edge_kind: string;
+};
+
+type BfsShortestState = {
+  visited: Set<number>;
+  parent: Map<number, { parentId: number; edgeKind: string }>;
+  found: boolean;
+  foundDepth: number;
+  alternateCount: number;
+};
+
+/** Build the SQL statement that yields neighbors of a node id in the requested direction. */
+function buildNeighborStmt(
   db: BetterSqlite3Database,
-  sourceId: number,
-  targetId: number,
   edgeKinds: string[],
   reverse: boolean,
-  maxDepth: number,
-  noTests: boolean,
-) {
+): ReturnType<BetterSqlite3Database['prepare']> {
   const kindPlaceholders = edgeKinds.map(() => '?').join(', ');
-
   // Forward: source_id -> target_id (A calls... calls B)
   // Reverse: target_id -> source_id (B is called by... called by A)
   const neighborQuery = reverse
@@ -283,50 +304,78 @@ function bfsShortestPath(
     : `SELECT n.id, n.name, n.kind, n.file, n.line, e.kind AS edge_kind
        FROM edges e JOIN nodes n ON e.target_id = n.id
        WHERE e.source_id = ? AND e.kind IN (${kindPlaceholders})`;
-  const neighborStmt = db.prepare(neighborQuery);
+  return db.prepare(neighborQuery);
+}
+
+/** Process a single neighbor row during BFS; returns true once the target has been reached. */
+function visitNeighbor(
+  n: NeighborRow,
+  currentId: number,
+  depth: number,
+  targetId: number,
+  state: BfsShortestState,
+  nextQueue: number[],
+  noTests: boolean,
+): void {
+  if (noTests && isTestFile(n.file)) return;
+  if (n.id === targetId) {
+    if (!state.found) {
+      state.found = true;
+      state.foundDepth = depth;
+      state.parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
+    }
+    state.alternateCount++;
+    return;
+  }
+  if (state.visited.has(n.id)) return;
+  state.visited.add(n.id);
+  state.parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
+  nextQueue.push(n.id);
+}
 
-  const visited = new Set([sourceId]);
-  const parent = new Map<number, { parentId: number; edgeKind: string }>();
+/**
+ * BFS from sourceId toward targetId.
+ * Returns { found, parent, alternateCount, foundDepth }.
+ * `parent` maps nodeId -> { parentId, edgeKind }.
+ */
+function bfsShortestPath(
+  db: BetterSqlite3Database,
+  sourceId: number,
+  targetId: number,
+  edgeKinds: string[],
+  reverse: boolean,
+  maxDepth: number,
+  noTests: boolean,
+) {
+  const neighborStmt = buildNeighborStmt(db, edgeKinds, reverse);
+  const state: BfsShortestState = {
+    visited: new Set([sourceId]),
+    parent: new Map(),
+    found: false,
+    foundDepth: -1,
+    alternateCount: 0,
+  };
   let queue = [sourceId];
-  let found = false;
-  let alternateCount = 0;
-  let foundDepth = -1;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
     const nextQueue: number[] = [];
     for (const currentId of queue) {
-      const neighbors = neighborStmt.all(currentId, ...edgeKinds) as Array<{
-        id: number;
-        name: string;
-        kind: string;
-        file: string;
-        line: number;
-        edge_kind: string;
-      }>;
+      const neighbors = neighborStmt.all(currentId, ...edgeKinds) as NeighborRow[];
       for (const n of neighbors) {
-        if (noTests && isTestFile(n.file)) continue;
-        if (n.id === targetId) {
-          if (!found) {
-            found = true;
-            foundDepth = depth;
-            parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
-          }
-          alternateCount++;
-          continue;
-        }
-        if (!visited.has(n.id)) {
-          visited.add(n.id);
-          parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
-          nextQueue.push(n.id);
-        }
+        visitNeighbor(n, currentId, depth, targetId, state, nextQueue, noTests);
       }
     }
-    if (found) break;
+    if (state.found) break;
     queue = nextQueue;
     if (queue.length === 0) break;
   }
 
-  return { found, parent, alternateCount, foundDepth };
+  return {
+    found: state.found,
+    parent: state.parent,
+    alternateCount: state.alternateCount,
+    foundDepth: state.foundDepth,
+  };
 }
 
 /**
@@ -474,6 +523,53 @@ export function pathData(
 
 // ── File-level shortest path ────────────────────────────────────────────
 
+type FileBfsState = {
+  visited: Set<string>;
+  parentMap: Map<string, string>;
+  found: boolean;
+  alternateCount: number;
+};
+
+/** Process a neighbor file during file-level BFS; updates state in place. */
+function visitFileNeighbor(
+  neighborFile: string,
+  currentFile: string,
+  targetFile: string,
+  state: FileBfsState,
+  nextQueue: string[],
+  noTests: boolean,
+): void {
+  if (noTests && isTestFile(neighborFile)) return;
+  if (neighborFile === targetFile) {
+    if (!state.found) {
+      state.found = true;
+      state.parentMap.set(neighborFile, currentFile);
+    }
+    state.alternateCount++;
+    return;
+  }
+  if (state.visited.has(neighborFile)) return;
+  state.visited.add(neighborFile);
+  state.parentMap.set(neighborFile, currentFile);
+  nextQueue.push(neighborFile);
+}
+
+/** Reconstruct file path from target back to source using parent links. */
+function reconstructFilePath(
+  parentMap: Map<string, string>,
+  sourceFile: string,
+  targetFile: string,
+): string[] {
+  const filePath: string[] = [targetFile];
+  let cur = targetFile;
+  while (cur !== sourceFile) {
+    cur = parentMap.get(cur)!;
+    filePath.push(cur);
+  }
+  filePath.reverse();
+  return filePath;
+}
+
 /** BFS over file adjacency graph to find shortest path. */
 function bfsFilePath(
   neighborStmt: ReturnType<BetterSqlite3Database['prepare']>,
@@ -483,11 +579,13 @@ function bfsFilePath(
   maxDepth: number,
   noTests: boolean,
 ): { found: boolean; path: string[]; alternateCount: number } {
-  const visited = new Set([sourceFile]);
-  const parentMap = new Map<string, string>();
+  const state: FileBfsState = {
+    visited: new Set([sourceFile]),
+    parentMap: new Map<string, string>(),
+    found: false,
+    alternateCount: 0,
+  };
   let queue = [sourceFile];
-  let found = false;
-  let alternateCount = 0;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
     const nextQueue: string[] = [];
@@ -496,38 +594,21 @@ function bfsFilePath(
         neighbor_file: string;
       }>;
       for (const n of neighbors) {
-        if (noTests && isTestFile(n.neighbor_file)) continue;
-        if (n.neighbor_file === targetFile) {
-          if (!found) {
-            found = true;
-            parentMap.set(n.neighbor_file, currentFile);
-          }
-          alternateCount++;
-          continue;
-        }
-        if (!visited.has(n.neighbor_file)) {
-          visited.add(n.neighbor_file);
-          parentMap.set(n.neighbor_file, currentFile);
-          nextQueue.push(n.neighbor_file);
-        }
+        visitFileNeighbor(n.neighbor_file, currentFile, targetFile, state, nextQueue, noTests);
       }
     }
-    if (found) break;
+    if (state.found) break;
     queue = nextQueue;
     if (queue.length === 0) break;
   }
 
-  if (!found) return { found: false, path: [], alternateCount: 0 };
+  if (!state.found) return { found: false, path: [], alternateCount: 0 };
 
-  // Reconstruct path
-  const filePath: string[] = [targetFile];
-  let cur = targetFile;
-  while (cur !== sourceFile) {
-    cur = parentMap.get(cur)!;
-    filePath.push(cur);
-  }
-  filePath.reverse();
-  return { found: true, path: filePath, alternateCount: Math.max(0, alternateCount - 1) };
+  return {
+    found: true,
+    path: reconstructFilePath(state.parentMap, sourceFile, targetFile),
+    alternateCount: Math.max(0, state.alternateCount - 1),
+  };
 }
 
 /**

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

@@ -83,6 +83,63 @@ function expandImplementors(
   }
 }
 
+/** Record a caller node at depth `d`, adding to frontier and levels. */
+function recordCaller(
+  caller: RelatedNodeRow,
+  parentId: number,
+  depth: number,
+  visited: Set<number>,
+  nextFrontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  if (visited.has(caller.id) || (noTests && isTestFile(caller.file))) return;
+  visited.add(caller.id);
+  nextFrontier.push(caller.id);
+  if (!levels[depth]) levels[depth] = [];
+  levels[depth]!.push(toSymbolRef(caller));
+  if (onVisit) onVisit(caller, parentId, depth);
+}
+
+/** Process all callers of one frontier node, recording new nodes and expanding implementors. */
+function processFrontierNode(
+  repo: InstanceType<typeof Repository>,
+  fid: number,
+  depth: number,
+  visited: Set<number>,
+  nextFrontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  resolveImplementors: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
+  for (const c of callers) {
+    recordCaller(c, fid, depth, visited, nextFrontier, levels, noTests, onVisit);
+    if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
+      expandImplementors(repo, c.id, depth + 1, visited, nextFrontier, levels, noTests, onVisit);
+    }
+  }
+}
+
+/** Seed BFS with implementors of the start node when it is an interface/trait. */
+function seedInterfaceImplementors(
+  repo: InstanceType<typeof Repository>,
+  startId: number,
+  visited: Set<number>,
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): number[] {
+  const implNextFrontier: number[] = [];
+  const startNode = repo.findNodeById(startId) as NodeRow | undefined;
+  if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
+    expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
+  }
+  return implNextFrontier;
+}
+
 export function bfsTransitiveCallers(
   dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
   startId: number,
@@ -105,13 +162,9 @@ export function bfsTransitiveCallers(
   let frontier = [startId];
 
   // Seed: if start node is an interface/trait, include its implementors at depth 1
-  const implNextFrontier: number[] = [];
-  if (resolveImplementors) {
-    const startNode = repo.findNodeById(startId) as NodeRow | undefined;
-    if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
-      expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
-    }
-  }
+  const implNextFrontier = resolveImplementors
+    ? seedInterfaceImplementors(repo, startId, visited, levels, noTests, onVisit)
+    : [];
 
   for (let d = 1; d <= maxDepth; d++) {
     if (d === 1 && implNextFrontier.length > 0) {
@@ -119,19 +172,17 @@ export function bfsTransitiveCallers(
     }
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      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);
-          nextFrontier.push(c.id);
-          if (!levels[d]) levels[d] = [];
-          levels[d]!.push(toSymbolRef(c));
-          if (onVisit) onVisit(c, fid, d);
-        }
-        if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          expandImplementors(repo, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
-        }
-      }
+      processFrontierNode(
+        repo,
+        fid,
+        d,
+        visited,
+        nextFrontier,
+        levels,
+        noTests,
+        resolveImplementors,
+        onVisit,
+      );
     }
     frontier = nextFrontier;
     if (frontier.length === 0) break;
@@ -140,6 +191,53 @@ export function bfsTransitiveCallers(
   return { totalDependents: visited.size - 1, levels };
 }
 
+/** BFS over import dependents, returning visited node IDs and depth-per-id map. */
+function bfsImportDependents(
+  repo: InstanceType<typeof Repository>,
+  seedNodes: NodeRow[],
+  noTests: boolean,
+): { visited: Set<number>; levels: Map<number, number> } {
+  const visited = new Set<number>();
+  const queue: number[] = [];
+  const levels = new Map<number, number>();
+
+  for (const fn of seedNodes) {
+    visited.add(fn.id);
+    queue.push(fn.id);
+    levels.set(fn.id, 0);
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const level = levels.get(current)!;
+    const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
+    for (const dep of dependents) {
+      if (visited.has(dep.id)) continue;
+      if (noTests && isTestFile(dep.file)) continue;
+      visited.add(dep.id);
+      queue.push(dep.id);
+      levels.set(dep.id, level + 1);
+    }
+  }
+
+  return { visited, levels };
+}
+
+/** Group visited dependents by depth (excluding seed depth 0). */
+function groupDependentsByLevel(
+  repo: InstanceType<typeof Repository>,
+  levels: Map<number, number>,
+): Record<number, Array<{ file: string }>> {
+  const byLevel: Record<number, Array<{ file: string }>> = {};
+  for (const [id, level] of levels) {
+    if (level === 0) continue;
+    if (!byLevel[level]) byLevel[level] = [];
+    const node = repo.findNodeById(id) as NodeRow | undefined;
+    if (node) byLevel[level].push({ file: node.file });
+  }
+  return byLevel;
+}
+
 export function impactAnalysisData(
   file: string,
   customDbPath: string,
@@ -152,36 +250,8 @@ export function impactAnalysisData(
       return { file, sources: [], levels: {}, totalDependents: 0 };
     }
 
-    const visited = new Set<number>();
-    const queue: number[] = [];
-    const levels = new Map<number, number>();
-
-    for (const fn of fileNodes) {
-      visited.add(fn.id);
-      queue.push(fn.id);
-      levels.set(fn.id, 0);
-    }
-
-    while (queue.length > 0) {
-      const current = queue.shift()!;
-      const level = levels.get(current)!;
-      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);
-          queue.push(dep.id);
-          levels.set(dep.id, level + 1);
-        }
-      }
-    }
-
-    const byLevel: Record<number, Array<{ file: string }>> = {};
-    for (const [id, level] of levels) {
-      if (level === 0) continue;
-      if (!byLevel[level]) byLevel[level] = [];
-      const node = repo.findNodeById(id) as NodeRow | undefined;
-      if (node) byLevel[level].push({ file: node.file });
-    }
+    const { visited, levels } = bfsImportDependents(repo, fileNodes, noTests);
+    const byLevel = groupDependentsByLevel(repo, levels);
 
     return {
       file,