@optave/codegraph 3.8.0 → 3.9.0

package/src/features/dataflow.ts

@@ -24,7 +24,7 @@ import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
 import { debug, info } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { paginateResult } from '../shared/paginate.js';
-import type { BetterSqlite3Database, NodeRow, TreeSitterNode } from '../types.js';
+import type { BetterSqlite3Database, NativeDatabase, NodeRow, TreeSitterNode } from '../types.js';
 import { findNodes } from './shared/find-nodes.js';
 
 // Re-export for backward compatibility
@@ -237,6 +237,86 @@ function insertDataflowEdges(
 
 // ── buildDataflowEdges ──────────────────────────────────────────────────────
 
+function prepareNodeResolvers(db: BetterSqlite3Database): {
+  getNodeByNameAndFile: ReturnType<BetterSqlite3Database['prepare']>;
+  getNodeByName: ReturnType<BetterSqlite3Database['prepare']>;
+} {
+  return {
+    getNodeByNameAndFile: db.prepare(
+      `SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND file = ? AND kind IN ('function', 'method')`,
+    ),
+    getNodeByName: db.prepare(
+      `SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND kind IN ('function', 'method')
+       ORDER BY file, line LIMIT 10`,
+    ),
+  };
+}
+
+function makeNodeResolver(
+  stmts: ReturnType<typeof prepareNodeResolvers>,
+  relPath: string,
+): (funcName: string) => { id: number } | null {
+  return (funcName: string): { id: number } | null => {
+    const local = stmts.getNodeByNameAndFile.all(funcName, relPath) as { id: number }[];
+    if (local.length > 0) return local[0]!;
+    const global = stmts.getNodeByName.all(funcName) as { id: number }[];
+    return global.length > 0 ? global[0]! : null;
+  };
+}
+
+function collectNativeEdges(
+  data: DataflowResult,
+  resolveNode: (name: string) => { id: number } | null,
+  edges: Array<Record<string, unknown>>,
+): void {
+  for (const flow of data.argFlows as ArgFlow[]) {
+    const sourceNode = resolveNode(flow.callerFunc);
+    const targetNode = resolveNode(flow.calleeName);
+    if (sourceNode && targetNode) {
+      edges.push({
+        sourceId: sourceNode.id,
+        targetId: targetNode.id,
+        kind: 'flows_to',
+        paramIndex: flow.argIndex,
+        expression: flow.expression,
+        line: flow.line,
+        confidence: flow.confidence,
+      });
+    }
+  }
+  for (const assignment of data.assignments as Assignment[]) {
+    const producerNode = resolveNode(assignment.sourceCallName);
+    const consumerNode = resolveNode(assignment.callerFunc);
+    if (producerNode && consumerNode) {
+      edges.push({
+        sourceId: producerNode.id,
+        targetId: consumerNode.id,
+        kind: 'returns',
+        paramIndex: undefined,
+        expression: assignment.expression,
+        line: assignment.line,
+        confidence: 1.0,
+      });
+    }
+  }
+  for (const mut of data.mutations as Mutation[]) {
+    const mutatorNode = resolveNode(mut.funcName);
+    if (mutatorNode && mut.binding?.type === 'param') {
+      edges.push({
+        sourceId: mutatorNode.id,
+        targetId: mutatorNode.id,
+        kind: 'mutates',
+        paramIndex: undefined,
+        expression: mut.mutatingExpr,
+        line: mut.line,
+        confidence: 1.0,
+      });
+    }
+  }
+}
+
 export async function buildDataflowEdges(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbolsDataflow>,
@@ -254,28 +334,7 @@ export async function buildDataflowEdges(
   if (nativeDb?.bulkInsertDataflow) {
     let needsJsFallback = false;
     const nativeEdges: Array<Record<string, unknown>> = [];
-
-    const getNodeByNameAndFile = db.prepare<{
-      id: number;
-      name: string;
-      kind: string;
-      file: string;
-      line: number;
-    }>(
-      `SELECT id, name, kind, file, line FROM nodes
-       WHERE name = ? AND file = ? AND kind IN ('function', 'method')`,
-    );
-    const getNodeByName = db.prepare<{
-      id: number;
-      name: string;
-      kind: string;
-      file: string;
-      line: number;
-    }>(
-      `SELECT id, name, kind, file, line FROM nodes
-       WHERE name = ? AND kind IN ('function', 'method')
-       ORDER BY file, line LIMIT 10`,
-    );
+    const stmts = prepareNodeResolvers(db);
 
     for (const [relPath, symbols] of fileSymbols) {
       const ext = path.extname(relPath).toLowerCase();
@@ -285,58 +344,7 @@ export async function buildDataflowEdges(
         break;
       }
 
-      const resolveNode = (funcName: string): { id: number } | null => {
-        const local = getNodeByNameAndFile.all(funcName, relPath);
-        if (local.length > 0) return local[0]!;
-        const global = getNodeByName.all(funcName);
-        return global.length > 0 ? global[0]! : null;
-      };
-
-      const data = symbols.dataflow;
-      for (const flow of data.argFlows as ArgFlow[]) {
-        const sourceNode = resolveNode(flow.callerFunc);
-        const targetNode = resolveNode(flow.calleeName);
-        if (sourceNode && targetNode) {
-          nativeEdges.push({
-            sourceId: sourceNode.id,
-            targetId: targetNode.id,
-            kind: 'flows_to',
-            paramIndex: flow.argIndex,
-            expression: flow.expression,
-            line: flow.line,
-            confidence: flow.confidence,
-          });
-        }
-      }
-      for (const assignment of data.assignments as Assignment[]) {
-        const producerNode = resolveNode(assignment.sourceCallName);
-        const consumerNode = resolveNode(assignment.callerFunc);
-        if (producerNode && consumerNode) {
-          nativeEdges.push({
-            sourceId: producerNode.id,
-            targetId: consumerNode.id,
-            kind: 'returns',
-            paramIndex: null,
-            expression: assignment.expression,
-            line: assignment.line,
-            confidence: 1.0,
-          });
-        }
-      }
-      for (const mut of data.mutations as Mutation[]) {
-        const mutatorNode = resolveNode(mut.funcName);
-        if (mutatorNode && mut.binding?.type === 'param') {
-          nativeEdges.push({
-            sourceId: mutatorNode.id,
-            targetId: mutatorNode.id,
-            kind: 'mutates',
-            paramIndex: null,
-            expression: mut.mutatingExpr,
-            line: mut.line,
-            confidence: 1.0,
-          });
-        }
-      }
+      collectNativeEdges(symbols.dataflow, makeNodeResolver(stmts, relPath), nativeEdges);
     }
 
     if (!needsJsFallback) {
@@ -363,29 +371,7 @@ export async function buildDataflowEdges(
      VALUES (?, ?, ?, ?, ?, ?, ?)`,
   );
 
-  const getNodeByNameAndFile = db.prepare<{
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    line: number;
-  }>(
-    `SELECT id, name, kind, file, line FROM nodes
-     WHERE name = ? AND file = ? AND kind IN ('function', 'method')`,
-  );
-
-  const getNodeByName = db.prepare<{
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    line: number;
-  }>(
-    `SELECT id, name, kind, file, line FROM nodes
-     WHERE name = ? AND kind IN ('function', 'method')
-     ORDER BY file, line LIMIT 10`,
-  );
-
+  const stmts = prepareNodeResolvers(db);
   let totalEdges = 0;
 
   const tx = db.transaction(() => {
@@ -396,14 +382,7 @@ export async function buildDataflowEdges(
       const data = getDataflowForFile(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
       if (!data) continue;
 
-      const resolveNode = (funcName: string): { id: number } | null => {
-        const local = getNodeByNameAndFile.all(funcName, relPath);
-        if (local.length > 0) return local[0]!;
-        const global = getNodeByName.all(funcName);
-        return global.length > 0 ? global[0]! : null;
-      };
-
-      totalEdges += insertDataflowEdges(insert, data, resolveNode);
+      totalEdges += insertDataflowEdges(insert, data, makeNodeResolver(stmts, relPath));
     }
   });
 
@@ -540,6 +519,83 @@ function buildNodeDataflowResult(
   };
 }
 
+function buildNativeDataflowResult(
+  node: NodeRow,
+  nativeDb: NativeDatabase,
+  db: BetterSqlite3Database,
+  hc: Map<string, string | null>,
+  noTests: boolean,
+): Record<string, unknown> {
+  const sym = normalizeSymbol(node, db, hc);
+  const d = nativeDb.getDataflowEdges!(node.id);
+
+  const flowsTo = d.flowsToOut.map((r: any) => ({
+    target: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line,
+    paramIndex: r.paramIndex,
+    expression: r.expression,
+    confidence: r.confidence,
+  }));
+  const flowsFrom = d.flowsToIn.map((r: any) => ({
+    source: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line,
+    paramIndex: r.paramIndex,
+    expression: r.expression,
+    confidence: r.confidence,
+  }));
+  const returnConsumers = d.returnsOut.map((r: any) => ({
+    consumer: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line,
+    expression: r.expression,
+  }));
+  const returnedBy = d.returnsIn.map((r: any) => ({
+    producer: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line,
+    expression: r.expression,
+  }));
+  const mutatesTargets = d.mutatesOut.map((r: any) => ({
+    target: r.name,
+    expression: r.expression,
+    line: r.line,
+  }));
+  const mutatedBy = d.mutatesIn.map((r: any) => ({
+    source: r.name,
+    expression: r.expression,
+    line: r.line,
+  }));
+
+  if (noTests) {
+    const filter = (arr: any[]) => arr.filter((r: any) => !isTestFile(r.file));
+    return {
+      ...sym,
+      flowsTo: filter(flowsTo),
+      flowsFrom: filter(flowsFrom),
+      returns: returnConsumers.filter((r: any) => !isTestFile(r.file)),
+      returnedBy: returnedBy.filter((r: any) => !isTestFile(r.file)),
+      mutates: mutatesTargets,
+      mutatedBy,
+    };
+  }
+
+  return {
+    ...sym,
+    flowsTo,
+    flowsFrom,
+    returns: returnConsumers,
+    returnedBy,
+    mutates: mutatesTargets,
+    mutatedBy,
+  };
+}
+
 export function dataflowData(
   name: string,
   customDbPath?: string,
@@ -571,75 +627,9 @@ export function dataflowData(
     // ── Native fast path: 6 queries per node → 1 napi call per node ──
     if (nativeDb?.getDataflowEdges) {
       const hc = new Map<string, string | null>();
-      const results = nodes.map((node: NodeRow) => {
-        const sym = normalizeSymbol(node, db, hc);
-        const d = nativeDb.getDataflowEdges!(node.id);
-
-        const flowsTo = d.flowsToOut.map((r) => ({
-          target: r.name,
-          kind: r.kind,
-          file: r.file,
-          line: r.line,
-          paramIndex: r.paramIndex,
-          expression: r.expression,
-          confidence: r.confidence,
-        }));
-        const flowsFrom = d.flowsToIn.map((r) => ({
-          source: r.name,
-          kind: r.kind,
-          file: r.file,
-          line: r.line,
-          paramIndex: r.paramIndex,
-          expression: r.expression,
-          confidence: r.confidence,
-        }));
-        const returnConsumers = d.returnsOut.map((r) => ({
-          consumer: r.name,
-          kind: r.kind,
-          file: r.file,
-          line: r.line,
-          expression: r.expression,
-        }));
-        const returnedBy = d.returnsIn.map((r) => ({
-          producer: r.name,
-          kind: r.kind,
-          file: r.file,
-          line: r.line,
-          expression: r.expression,
-        }));
-        const mutatesTargets = d.mutatesOut.map((r) => ({
-          target: r.name,
-          expression: r.expression,
-          line: r.line,
-        }));
-        const mutatedBy = d.mutatesIn.map((r) => ({
-          source: r.name,
-          expression: r.expression,
-          line: r.line,
-        }));
-
-        if (noTests) {
-          const filter = (arr: any[]) => arr.filter((r: any) => !isTestFile(r.file));
-          return {
-            ...sym,
-            flowsTo: filter(flowsTo),
-            flowsFrom: filter(flowsFrom),
-            returns: returnConsumers.filter((r) => !isTestFile(r.file)),
-            returnedBy: returnedBy.filter((r) => !isTestFile(r.file)),
-            mutates: mutatesTargets,
-            mutatedBy,
-          };
-        }
-        return {
-          ...sym,
-          flowsTo,
-          flowsFrom,
-          returns: returnConsumers,
-          returnedBy,
-          mutates: mutatesTargets,
-          mutatedBy,
-        };
-      });
+      const results = nodes.map((node: NodeRow) =>
+        buildNativeDataflowResult(node, nativeDb, db, hc, noTests),
+      );
       const base = { name, results };
       return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
     }

package/src/features/flow.ts

@@ -96,6 +96,128 @@ interface NodeInfo {
   type?: string;
 }
 
+/** Resolve the entry node by direct match or framework-prefix matching. */
+function resolveEntryNode(
+  db: ReturnType<typeof openReadonlyOrFail>,
+  name: string,
+  flowOpts: { noTests?: boolean; file?: string; kinds?: string[] },
+): {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  role?: string | null;
+} | null {
+  // Phase 1: Direct LIKE match on full name
+  let matchNode = findMatchingNodes(db, name, flowOpts)[0] ?? null;
+
+  // Phase 2: Prefix-stripped matching — try adding framework prefixes
+  if (!matchNode) {
+    for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
+      matchNode = findMatchingNodes(db, `${prefix}${name}`, flowOpts)[0] ?? null;
+      if (matchNode) break;
+    }
+  }
+
+  return matchNode;
+}
+
+interface BfsState {
+  visited: Set<number>;
+  steps: Array<{ depth: number; nodes: NodeInfo[] }>;
+  cycles: Array<{ from: string; to: string; depth: number }>;
+  nodeDepths: Map<number, number>;
+  idToNode: Map<number, NodeInfo>;
+  truncated: boolean;
+}
+
+/** Forward BFS through callees, collecting steps, cycles, and node depth info. */
+function bfsCallees(
+  db: ReturnType<typeof openReadonlyOrFail>,
+  entryId: number,
+  entryInfo: NodeInfo,
+  maxDepth: number,
+  noTests: boolean,
+): BfsState {
+  const visited = new Set<number>([entryId]);
+  let frontier = [entryId];
+  const steps: Array<{ depth: number; nodes: NodeInfo[] }> = [];
+  const cycles: Array<{ from: string; to: string; depth: number }> = [];
+  const nodeDepths = new Map<number, number>();
+  const idToNode = new Map<number, NodeInfo>();
+  idToNode.set(entryId, entryInfo);
+  let truncated = false;
+
+  const calleesStmt = db.prepare<CalleeRow>(
+    `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line, n.role
+     FROM edges e JOIN nodes n ON e.target_id = n.id
+     WHERE e.source_id = ? AND e.kind = 'calls'`,
+  );
+
+  for (let d = 1; d <= maxDepth; d++) {
+    const nextFrontier: number[] = [];
+    const levelNodes: NodeInfo[] = [];
+
+    for (const fid of frontier) {
+      const callees = calleesStmt.all(fid);
+
+      for (const c of callees) {
+        if (noTests && isTestFile(c.file)) continue;
+
+        if (visited.has(c.id)) {
+          const fromNode = idToNode.get(fid);
+          if (fromNode) {
+            cycles.push({ from: fromNode.name, to: c.name, depth: d });
+          }
+          continue;
+        }
+
+        visited.add(c.id);
+        nextFrontier.push(c.id);
+        const nodeInfo: NodeInfo = { name: c.name, kind: c.kind, file: c.file, line: c.line };
+        levelNodes.push(nodeInfo);
+        nodeDepths.set(c.id, d);
+        idToNode.set(c.id, nodeInfo);
+      }
+    }
+
+    if (levelNodes.length > 0) {
+      steps.push({ depth: d, nodes: levelNodes });
+    }
+
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+    if (d === maxDepth && frontier.length > 0) truncated = true;
+  }
+
+  return { visited, steps, cycles, nodeDepths, idToNode, truncated };
+}
+
+/** Identify leaf nodes — visited nodes with no outgoing 'calls' edges. */
+function findLeafNodes(
+  db: ReturnType<typeof openReadonlyOrFail>,
+  nodeDepths: Map<number, number>,
+  idToNode: Map<number, NodeInfo>,
+): Array<NodeInfo & { depth: number }> {
+  const leaves: Array<NodeInfo & { depth: number }> = [];
+  const outgoingStmt = db.prepare<{ id: number }>(
+    `SELECT DISTINCT n.id
+     FROM edges e JOIN nodes n ON e.target_id = n.id
+     WHERE e.source_id = ? AND e.kind = 'calls'`,
+  );
+
+  for (const [id, depth] of nodeDepths) {
+    const outgoing = outgoingStmt.all(id);
+    if (outgoing.length === 0) {
+      const node = idToNode.get(id);
+      if (node) leaves.push({ ...node, depth });
+    }
+  }
+
+  return leaves;
+}
+
 export function flowData(
   name: string,
   dbPath?: string,
@@ -117,17 +239,7 @@ export function flowData(
       kinds: opts.kind ? [opts.kind] : (CORE_SYMBOL_KINDS as unknown as string[]),
     };
 
-    // Phase 1: Direct LIKE match on full name (use all 10 core symbol kinds,
-    // not just FUNCTION_KINDS, so flow can trace from interfaces/types/structs/etc.)
-    let matchNode = findMatchingNodes(db, name, flowOpts)[0] ?? null;
-
-    // Phase 2: Prefix-stripped matching — try adding framework prefixes
-    if (!matchNode) {
-      for (const prefix of FRAMEWORK_ENTRY_PREFIXES) {
-        matchNode = findMatchingNodes(db, `${prefix}${name}`, flowOpts)[0] ?? null;
-        if (matchNode) break;
-      }
-    }
+    const matchNode = resolveEntryNode(db, name, flowOpts);
 
     if (!matchNode) {
       return {
@@ -151,92 +263,17 @@ export function flowData(
       role: matchNode.role,
     };
 
-    // Forward BFS through callees
-    const visited = new Set<number>([matchNode.id]);
-    let frontier = [matchNode.id];
-    const steps: Array<{ depth: number; nodes: NodeInfo[] }> = [];
-    const cycles: Array<{ from: string; to: string; depth: number }> = [];
-    let truncated = false;
-
-    // Track which nodes are at each depth and their depth for leaf detection
-    const nodeDepths = new Map<number, number>();
-    const idToNode = new Map<number, NodeInfo>();
-    idToNode.set(matchNode.id, entry);
-
-    for (let d = 1; d <= maxDepth; d++) {
-      const nextFrontier: number[] = [];
-      const levelNodes: NodeInfo[] = [];
-
-      for (const fid of frontier) {
-        const callees = db
-          .prepare<CalleeRow>(
-            `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line, n.role
-             FROM edges e JOIN nodes n ON e.target_id = n.id
-             WHERE e.source_id = ? AND e.kind = 'calls'`,
-          )
-          .all(fid);
-
-        for (const c of callees) {
-          if (noTests && isTestFile(c.file)) continue;
-
-          if (visited.has(c.id)) {
-            // Cycle detected
-            const fromNode = idToNode.get(fid);
-            if (fromNode) {
-              cycles.push({ from: fromNode.name, to: c.name, depth: d });
-            }
-            continue;
-          }
-
-          visited.add(c.id);
-          nextFrontier.push(c.id);
-          const nodeInfo: NodeInfo = { name: c.name, kind: c.kind, file: c.file, line: c.line };
-          levelNodes.push(nodeInfo);
-          nodeDepths.set(c.id, d);
-          idToNode.set(c.id, nodeInfo);
-        }
-      }
-
-      if (levelNodes.length > 0) {
-        steps.push({ depth: d, nodes: levelNodes });
-      }
-
-      frontier = nextFrontier;
-      if (frontier.length === 0) break;
-
-      if (d === maxDepth && frontier.length > 0) {
-        truncated = true;
-      }
-    }
-
-    // Identify leaves: visited nodes that have no outgoing 'calls' edges to other visited nodes
-    // (or no outgoing calls at all)
-    const leaves: Array<NodeInfo & { depth: number }> = [];
-    for (const [id, depth] of nodeDepths) {
-      const outgoing = db
-        .prepare<{ id: number }>(
-          `SELECT DISTINCT n.id
-           FROM edges e JOIN nodes n ON e.target_id = n.id
-           WHERE e.source_id = ? AND e.kind = 'calls'`,
-        )
-        .all(id);
-
-      if (outgoing.length === 0) {
-        const node = idToNode.get(id);
-        if (node) {
-          leaves.push({ ...node, depth });
-        }
-      }
-    }
+    const bfs = bfsCallees(db, matchNode.id, entry, maxDepth, noTests);
+    const leaves = findLeafNodes(db, bfs.nodeDepths, bfs.idToNode);
 
     const base = {
       entry,
       depth: maxDepth,
-      steps,
+      steps: bfs.steps,
       leaves,
-      cycles,
-      totalReached: visited.size - 1, // exclude the entry node itself
-      truncated,
+      cycles: bfs.cycles,
+      totalReached: bfs.visited.size - 1,
+      truncated: bfs.truncated,
     };
     return paginateResult(base, 'steps', { limit: opts.limit, offset: opts.offset });
   } finally {