@kodus/kodus-graph 0.2.7 → 0.2.9

package/src/analysis/blast-radius.ts

@@ -1,54 +0,0 @@
-import type { BlastRadiusResult, GraphData } from '../graph/types';
-
-export function computeBlastRadius(graph: GraphData, changedFiles: string[], maxDepth: number = 2): BlastRadiusResult {
-  // Build adjacency list from CALLS edges (callers of changed nodes)
-  const adj = new Map<string, Set<string>>();
-  for (const edge of graph.edges) {
-    if (edge.kind !== 'CALLS' && edge.kind !== 'IMPORTS') continue;
-    // Reverse direction: target -> source (who calls/imports this?)
-    if (!adj.has(edge.target_qualified)) adj.set(edge.target_qualified, new Set());
-    adj.get(edge.target_qualified)!.add(edge.source_qualified);
-    // Forward direction too for IMPORTS
-    if (edge.kind === 'IMPORTS') {
-      if (!adj.has(edge.source_qualified)) adj.set(edge.source_qualified, new Set());
-      adj.get(edge.source_qualified)!.add(edge.target_qualified);
-    }
-  }
-
-  // Seed: all nodes in changed files
-  const changedSet = new Set(changedFiles);
-  const seeds = graph.nodes.filter((n) => changedSet.has(n.file_path)).map((n) => n.qualified_name);
-
-  // BFS
-  const visited = new Set<string>(seeds);
-  const byDepth: Record<string, string[]> = {};
-  let frontier = seeds;
-
-  for (let depth = 1; depth <= maxDepth; depth++) {
-    const next: string[] = [];
-    for (const node of frontier) {
-      for (const neighbor of adj.get(node) || []) {
-        if (!visited.has(neighbor)) {
-          visited.add(neighbor);
-          next.push(neighbor);
-        }
-      }
-    }
-    if (next.length > 0) byDepth[String(depth)] = next;
-    frontier = next;
-  }
-
-  // Count unique files
-  const nodeIndex = new Map(graph.nodes.map((n) => [n.qualified_name, n]));
-  const impactedFiles = new Set<string>();
-  for (const q of visited) {
-    const node = nodeIndex.get(q);
-    if (node) impactedFiles.add(node.file_path);
-  }
-
-  return {
-    total_functions: visited.size,
-    total_files: impactedFiles.size,
-    by_depth: byDepth,
-  };
-}

package/src/analysis/communities.ts

@@ -1,135 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-
-export interface CommunityOptions {
-  depth: number;
-  minSize: number;
-}
-
-export interface Community {
-  name: string;
-  files: string[];
-  node_count: number;
-  cohesion: number;
-  language: string;
-}
-
-export interface CouplingPair {
-  source: string;
-  target: string;
-  edges: number;
-  strength: 'HIGH' | 'MEDIUM' | 'LOW';
-}
-
-export interface CommunitiesResult {
-  communities: Community[];
-  coupling: CouplingPair[];
-  summary: { total_communities: number; avg_cohesion: number; high_coupling_pairs: number };
-}
-
-function getCommunityKey(filePath: string, depth: number): string {
-  const parts = filePath.split('/');
-  return parts.slice(0, depth).join('/');
-}
-
-export function detectCommunities(graph: IndexedGraph, opts: CommunityOptions): CommunitiesResult {
-  const { depth, minSize } = opts;
-
-  // Group nodes by directory
-  const groups = new Map<string, Set<string>>(); // community -> files
-  const nodeComm = new Map<string, string>(); // qualified_name -> community
-
-  for (const node of graph.nodes) {
-    const key = getCommunityKey(node.file_path, depth);
-    if (!groups.has(key)) groups.set(key, new Set());
-    groups.get(key)!.add(node.file_path);
-    nodeComm.set(node.qualified_name, key);
-  }
-
-  // Count internal and cross edges per community pair
-  const internalEdges = new Map<string, number>();
-  const crossEdges = new Map<string, number>(); // "a|b" -> count
-
-  for (const edge of graph.edges) {
-    if (edge.kind !== 'CALLS' && edge.kind !== 'IMPORTS') continue;
-    const srcComm = nodeComm.get(edge.source_qualified);
-    const tgtComm = nodeComm.get(edge.target_qualified);
-    if (!srcComm || !tgtComm) continue;
-
-    if (srcComm === tgtComm) {
-      internalEdges.set(srcComm, (internalEdges.get(srcComm) || 0) + 1);
-    } else {
-      const pairKey = [srcComm, tgtComm].sort().join('|');
-      crossEdges.set(pairKey, (crossEdges.get(pairKey) || 0) + 1);
-    }
-  }
-
-  // Build communities
-  const communities: Community[] = [];
-  for (const [name, files] of groups) {
-    const nodeCount = graph.nodes.filter((n) => getCommunityKey(n.file_path, depth) === name).length;
-    if (nodeCount < minSize) continue;
-
-    const internal = internalEdges.get(name) || 0;
-    const maxPossible = nodeCount * (nodeCount - 1);
-    const cohesion = maxPossible > 0 ? Math.round((internal / maxPossible) * 100) / 100 : 0;
-
-    const langs = new Map<string, number>();
-    for (const n of graph.nodes) {
-      if (getCommunityKey(n.file_path, depth) === name) {
-        langs.set(n.language, (langs.get(n.language) || 0) + 1);
-      }
-    }
-    let dominant = 'unknown';
-    let maxCount = 0;
-    for (const [lang, count] of langs) {
-      if (count > maxCount) {
-        dominant = lang;
-        maxCount = count;
-      }
-    }
-
-    communities.push({
-      name,
-      files: [...files].sort(),
-      node_count: nodeCount,
-      cohesion,
-      language: dominant,
-    });
-  }
-
-  communities.sort((a, b) => b.node_count - a.node_count);
-
-  // Build coupling pairs
-  const communityNames = new Set(communities.map((c) => c.name));
-  const coupling: CouplingPair[] = [];
-  for (const [pairKey, count] of crossEdges) {
-    const [src, tgt] = pairKey.split('|');
-    if (!communityNames.has(src) || !communityNames.has(tgt)) continue;
-
-    const srcTotal = graph.edges.filter((e) => {
-      const c = nodeComm.get(e.source_qualified);
-      return c === src || c === tgt;
-    }).length;
-    const ratio = srcTotal > 0 ? count / srcTotal : 0;
-    const strength = ratio > 0.3 ? 'HIGH' : ratio > 0.1 ? 'MEDIUM' : 'LOW';
-
-    coupling.push({ source: src, target: tgt, edges: count, strength });
-  }
-
-  coupling.sort((a, b) => b.edges - a.edges);
-
-  const avgCohesion =
-    communities.length > 0
-      ? Math.round((communities.reduce((s, c) => s + c.cohesion, 0) / communities.length) * 100) / 100
-      : 0;
-
-  return {
-    communities,
-    coupling,
-    summary: {
-      total_communities: communities.length,
-      avg_cohesion: avgCohesion,
-      high_coupling_pairs: coupling.filter((c) => c.strength === 'HIGH').length,
-    },
-  };
-}

package/src/analysis/context-builder.ts

@@ -1,130 +0,0 @@
-import { performance } from 'perf_hooks';
-import { type IndexedGraph, indexGraph } from '../graph/loader';
-import type {
-  AffectedFlow,
-  ContextAnalysisMetadata,
-  GraphData,
-  GraphEdge,
-  GraphNode,
-  ParseMetadata,
-} from '../graph/types';
-import { computeBlastRadius } from './blast-radius';
-import { computeStructuralDiff, type DiffResult } from './diff';
-import { enrichChangedFunctions } from './enrich';
-import { detectFlows } from './flows';
-import { extractInheritance } from './inheritance';
-import { computeRiskScore } from './risk-score';
-import { findTestGaps } from './test-gaps';
-
-export interface ContextV2Output {
-  graph: {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-    metadata: ParseMetadata;
-  };
-  analysis: {
-    changed_functions: ReturnType<typeof enrichChangedFunctions>;
-    structural_diff: DiffResult;
-    blast_radius: ReturnType<typeof computeBlastRadius>;
-    affected_flows: AffectedFlow[];
-    inheritance: ReturnType<typeof extractInheritance>;
-    test_gaps: ReturnType<typeof findTestGaps>;
-    risk: ReturnType<typeof computeRiskScore>;
-    metadata: ContextAnalysisMetadata;
-  };
-}
-
-interface BuildContextV2Options {
-  mergedGraph: GraphData;
-  oldGraph: GraphData | null;
-  changedFiles: string[];
-  minConfidence: number;
-  maxDepth: number;
-}
-
-export function buildContextV2(opts: BuildContextV2Options): ContextV2Output {
-  const t0 = performance.now();
-  const { mergedGraph, oldGraph, changedFiles, minConfidence, maxDepth } = opts;
-
-  // Phase 1: Index
-  const indexed = indexGraph(mergedGraph);
-  const oldIndexed: IndexedGraph = oldGraph ? indexGraph(oldGraph) : indexGraph({ nodes: [], edges: [] });
-
-  // Phase 2: Independent analyses
-  const changedSet = new Set(changedFiles);
-  const newNodesInChanged = mergedGraph.nodes.filter((n) => changedSet.has(n.file_path));
-  const newEdgesInChanged = mergedGraph.edges.filter((e) => changedSet.has(e.file_path));
-
-  const structuralDiff = computeStructuralDiff(oldIndexed, newNodesInChanged, newEdgesInChanged, changedFiles);
-  const blastRadius = computeBlastRadius(mergedGraph, changedFiles, maxDepth);
-  const allFlows = detectFlows(indexed, { maxDepth: 10, type: 'all' });
-  const testGaps = findTestGaps(mergedGraph, changedFiles);
-  const risk = computeRiskScore(mergedGraph, changedFiles, blastRadius);
-  const inheritance = extractInheritance(indexed, changedFiles);
-
-  // Phase 3: Filter affected flows
-  const changedFuncSet = new Set(
-    mergedGraph.nodes.filter((n) => changedSet.has(n.file_path) && !n.is_test).map((n) => n.qualified_name),
-  );
-
-  const affectedFlows: AffectedFlow[] = [];
-  for (const flow of allFlows.flows) {
-    const touches = flow.path.filter((qn) => changedFuncSet.has(qn));
-    if (touches.length > 0) {
-      affectedFlows.push({
-        entry_point: flow.entry_point,
-        type: flow.type,
-        touches_changed: touches,
-        depth: flow.depth,
-        path: flow.path,
-      });
-    }
-  }
-
-  // Phase 3: Enrichment
-  const enriched = enrichChangedFunctions(indexed, changedFiles, structuralDiff, allFlows.flows, minConfidence);
-
-  // Phase 4: Assembly
-  const totalCallers = enriched.reduce((s, f) => s + f.callers.length, 0);
-  const totalCallees = enriched.reduce((s, f) => s + f.callees.length, 0);
-
-  const metadata: ContextAnalysisMetadata = {
-    changed_functions_count: enriched.length,
-    total_callers: totalCallers,
-    total_callees: totalCallees,
-    untested_count: testGaps.length,
-    affected_flows_count: affectedFlows.length,
-    duration_ms: Math.round(performance.now() - t0),
-    min_confidence: minConfidence,
-  };
-
-  const graphMetadata: ParseMetadata = indexed.metadata.repo_dir
-    ? indexed.metadata
-    : {
-        repo_dir: '',
-        files_parsed: changedFiles.length,
-        total_nodes: mergedGraph.nodes.length,
-        total_edges: mergedGraph.edges.length,
-        duration_ms: 0,
-        parse_errors: 0,
-        extract_errors: 0,
-      };
-
-  return {
-    graph: {
-      nodes: mergedGraph.nodes,
-      edges: mergedGraph.edges,
-      metadata: graphMetadata,
-    },
-    analysis: {
-      changed_functions: enriched,
-      structural_diff: structuralDiff,
-      blast_radius: blastRadius,
-      affected_flows: affectedFlows,
-      inheritance,
-      test_gaps: testGaps,
-      risk,
-      metadata,
-    },
-  };
-}

package/src/analysis/diff.ts

@@ -1,131 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-import type { GraphEdge, GraphNode } from '../graph/types';
-
-export interface NodeChange {
-  qualified_name: string;
-  kind: string;
-  file_path: string;
-  line_start: number;
-  line_end: number;
-}
-
-export interface ModifiedNode {
-  qualified_name: string;
-  changes: string[];
-}
-
-export interface DiffResult {
-  changed_files: string[];
-  summary: { added: number; removed: number; modified: number };
-  nodes: { added: NodeChange[]; removed: NodeChange[]; modified: ModifiedNode[] };
-  edges: {
-    added: Pick<GraphEdge, 'kind' | 'source_qualified' | 'target_qualified'>[];
-    removed: Pick<GraphEdge, 'kind' | 'source_qualified' | 'target_qualified'>[];
-  };
-  risk_by_file: Record<string, { dependents: number; risk: 'HIGH' | 'MEDIUM' | 'LOW' }>;
-}
-
-export function computeStructuralDiff(
-  oldGraph: IndexedGraph,
-  newNodes: GraphNode[],
-  newEdges: GraphEdge[],
-  changedFiles: string[],
-): DiffResult {
-  const changedSet = new Set(changedFiles);
-
-  // Old nodes in changed files
-  const oldNodesInChanged = new Map<string, GraphNode>();
-  for (const n of oldGraph.nodes) {
-    if (changedSet.has(n.file_path)) oldNodesInChanged.set(n.qualified_name, n);
-  }
-
-  // New nodes in changed files
-  const newNodesMap = new Map<string, GraphNode>();
-  for (const n of newNodes) {
-    if (changedSet.has(n.file_path)) newNodesMap.set(n.qualified_name, n);
-  }
-
-  // Classify nodes
-  const added: NodeChange[] = [];
-  const removed: NodeChange[] = [];
-  const modified: ModifiedNode[] = [];
-
-  for (const [qn, n] of newNodesMap) {
-    if (!oldNodesInChanged.has(qn)) {
-      added.push({
-        qualified_name: qn,
-        kind: n.kind,
-        file_path: n.file_path,
-        line_start: n.line_start,
-        line_end: n.line_end,
-      });
-    }
-  }
-
-  for (const [qn, n] of oldNodesInChanged) {
-    if (!newNodesMap.has(qn)) {
-      removed.push({
-        qualified_name: qn,
-        kind: n.kind,
-        file_path: n.file_path,
-        line_start: n.line_start,
-        line_end: n.line_end,
-      });
-    } else {
-      const newN = newNodesMap.get(qn)!;
-      const changes: string[] = [];
-      // Detect real content changes vs. pure displacement.
-      // content_hash = SHA256 of the node's source text (position-independent).
-      if (n.content_hash && newN.content_hash) {
-        // Definitive: hash comparison catches ALL content changes,
-        // even same-line-count edits (e.g. `return 1` → `return 2`).
-        if (n.content_hash !== newN.content_hash) changes.push('body');
-      } else if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) {
-        // Fallback (legacy data without content_hash): size heuristic.
-        const oldSize = n.line_end - n.line_start;
-        const newSize = newN.line_end - newN.line_start;
-        if (oldSize !== newSize) changes.push('line_range');
-      }
-      if ((n.params || '') !== (newN.params || '')) changes.push('params');
-      if ((n.return_type || '') !== (newN.return_type || '')) changes.push('return_type');
-      if (changes.length > 0) modified.push({ qualified_name: qn, changes });
-    }
-  }
-
-  // Classify edges
-  const oldEdgesInChanged = oldGraph.edges.filter((e) => changedSet.has(e.file_path));
-  const oldEdgeKeys = new Set(oldEdgesInChanged.map((e) => `${e.kind}|${e.source_qualified}|${e.target_qualified}`));
-  const newEdgesInChanged = newEdges.filter((e) => changedSet.has(e.file_path));
-  const newEdgeKeys = new Set(newEdgesInChanged.map((e) => `${e.kind}|${e.source_qualified}|${e.target_qualified}`));
-
-  const addedEdges = newEdgesInChanged
-    .filter((e) => !oldEdgeKeys.has(`${e.kind}|${e.source_qualified}|${e.target_qualified}`))
-    .map((e) => ({ kind: e.kind, source_qualified: e.source_qualified, target_qualified: e.target_qualified }));
-
-  const removedEdges = oldEdgesInChanged
-    .filter((e) => !newEdgeKeys.has(`${e.kind}|${e.source_qualified}|${e.target_qualified}`))
-    .map((e) => ({ kind: e.kind, source_qualified: e.source_qualified, target_qualified: e.target_qualified }));
-
-  // Risk by file: count unique dependents via reverse adjacency
-  const riskByFile: Record<string, { dependents: number; risk: 'HIGH' | 'MEDIUM' | 'LOW' }> = {};
-  for (const file of changedFiles) {
-    const nodesInFile = oldGraph.byFile.get(file) || [];
-    const dependents = new Set<string>();
-    for (const n of nodesInFile) {
-      for (const edge of oldGraph.reverseAdjacency.get(n.qualified_name) || []) {
-        if (!changedSet.has(edge.file_path)) dependents.add(edge.source_qualified);
-      }
-    }
-    const count = dependents.size;
-    const risk = count >= 10 ? 'HIGH' : count >= 3 ? 'MEDIUM' : 'LOW';
-    riskByFile[file] = { dependents: count, risk };
-  }
-
-  return {
-    changed_files: changedFiles,
-    summary: { added: added.length, removed: removed.length, modified: modified.length },
-    nodes: { added, removed, modified },
-    edges: { added: addedEdges, removed: removedEdges },
-    risk_by_file: riskByFile,
-  };
-}

package/src/analysis/enrich.ts

@@ -1,110 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-import type { CalleeRef, CallerRef, EnrichedFunction } from '../graph/types';
-import type { DiffResult } from './diff';
-import type { Flow } from './flows';
-
-export function enrichChangedFunctions(
-  graph: IndexedGraph,
-  changedFiles: string[],
-  diff: DiffResult,
-  allFlows: Flow[],
-  minConfidence: number,
-): EnrichedFunction[] {
-  const changedSet = new Set(changedFiles);
-
-  // Pre-index diff results
-  const addedSet = new Set(diff.nodes.added.map((n) => n.qualified_name));
-  const modifiedMap = new Map(diff.nodes.modified.map((m) => [m.qualified_name, m.changes]));
-
-  // Pre-index TESTED_BY
-  const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
-
-  // Pre-index flows by function
-  const flowsByFunction = new Map<string, string[]>();
-  for (const flow of allFlows) {
-    for (const qn of flow.path) {
-      const list = flowsByFunction.get(qn);
-      if (list) {
-        if (!list.includes(flow.entry_point)) list.push(flow.entry_point);
-      } else {
-        flowsByFunction.set(qn, [flow.entry_point]);
-      }
-    }
-  }
-
-  // Filter functions in changed files
-  const changedFunctions = graph.nodes.filter(
-    (n) =>
-      changedSet.has(n.file_path) &&
-      !n.is_test &&
-      n.kind !== 'Constructor' &&
-      n.kind !== 'Class' &&
-      n.kind !== 'Interface' &&
-      n.kind !== 'Enum',
-  );
-
-  return changedFunctions
-    .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start)
-    .map((node) => {
-      // Callers
-      const callers: CallerRef[] = [];
-      for (const edge of graph.reverseAdjacency.get(node.qualified_name) || []) {
-        if (edge.kind !== 'CALLS') continue;
-        // null/undefined confidence = high confidence (edge came from DB or parser without scoring)
-        if ((edge.confidence ?? 1.0) < minConfidence) continue;
-        const sourceNode = graph.byQualified.get(edge.source_qualified);
-        callers.push({
-          qualified_name: edge.source_qualified,
-          name: sourceNode?.name || edge.source_qualified.split('::').pop() || 'unknown',
-          file_path: sourceNode?.file_path || edge.file_path,
-          line: edge.line,
-          confidence: edge.confidence ?? 1.0,
-        });
-      }
-
-      // Callees
-      const callees: CalleeRef[] = [];
-      const seenCallees = new Set<string>();
-      for (const edge of graph.adjacency.get(node.qualified_name) || []) {
-        if (edge.kind !== 'CALLS') continue;
-        if (seenCallees.has(edge.target_qualified)) continue;
-        seenCallees.add(edge.target_qualified);
-        const targetNode = graph.byQualified.get(edge.target_qualified);
-        const name = targetNode?.name || edge.target_qualified.split('::').pop() || 'unknown';
-        const params = targetNode?.params && targetNode.params !== '()' ? targetNode.params : '';
-        const ret = targetNode?.return_type ? ` -> ${targetNode.return_type}` : '';
-        callees.push({
-          qualified_name: edge.target_qualified,
-          name,
-          file_path: targetNode?.file_path || '',
-          signature: `${name}${params}${ret}`,
-        });
-      }
-
-      // Signature
-      const shortName = node.name.includes('.') ? node.name.split('.').pop()! : node.name;
-      const params = node.params && node.params !== '()' ? node.params : '';
-      const ret = node.return_type ? ` -> ${node.return_type}` : '';
-      const signature = `${shortName}${params}${ret}`;
-
-      // Diff
-      const isNew = addedSet.has(node.qualified_name);
-      const diffChanges = isNew ? [] : modifiedMap.get(node.qualified_name) || [];
-
-      return {
-        qualified_name: node.qualified_name,
-        name: node.name,
-        kind: node.kind,
-        signature,
-        file_path: node.file_path,
-        line_start: node.line_start,
-        line_end: node.line_end,
-        callers,
-        callees,
-        has_test_coverage: testedFiles.has(node.file_path),
-        diff_changes: diffChanges,
-        is_new: isNew,
-        in_flows: flowsByFunction.get(node.qualified_name) || [],
-      };
-    });
-}

package/src/analysis/flows.ts

@@ -1,112 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-
-export interface FlowOptions {
-  maxDepth: number;
-  type: 'test' | 'http' | 'all';
-}
-
-export interface Flow {
-  entry_point: string;
-  type: 'test' | 'http';
-  depth: number;
-  node_count: number;
-  file_count: number;
-  criticality: number;
-  path: string[];
-}
-
-export interface FlowsResult {
-  flows: Flow[];
-  summary: {
-    total_flows: number;
-    by_type: { test: number; http: number };
-    avg_depth: number;
-    max_criticality: number;
-  };
-}
-
-const HTTP_METHOD_NAMES = new Set(['get', 'post', 'put', 'delete', 'patch', 'handle', 'handler']);
-
-function isHttpHandler(_qualifiedName: string, name: string, parentName?: string): boolean {
-  if (HTTP_METHOD_NAMES.has(name.toLowerCase())) return true;
-  if (parentName?.toLowerCase().endsWith('controller')) return true;
-  return false;
-}
-
-export function detectFlows(graph: IndexedGraph, opts: FlowOptions): FlowsResult {
-  const { maxDepth, type } = opts;
-
-  // Find entry points
-  const entryPoints: { qualified: string; type: 'test' | 'http' }[] = [];
-
-  for (const node of graph.nodes) {
-    if (type !== 'http' && node.kind === 'Test') {
-      entryPoints.push({ qualified: node.qualified_name, type: 'test' });
-    }
-    if (type !== 'test' && (node.kind === 'Method' || node.kind === 'Function')) {
-      if (isHttpHandler(node.qualified_name, node.name, node.parent_name)) {
-        entryPoints.push({ qualified: node.qualified_name, type: 'http' });
-      }
-    }
-  }
-
-  // BFS for each entry point
-  const flows: Flow[] = [];
-
-  for (const ep of entryPoints) {
-    const path: string[] = [ep.qualified];
-    const visited = new Set<string>([ep.qualified]);
-    const files = new Set<string>();
-
-    const startNode = graph.byQualified.get(ep.qualified);
-    if (startNode) files.add(startNode.file_path);
-
-    let frontier = [ep.qualified];
-    let depth = 0;
-
-    while (frontier.length > 0 && depth < maxDepth) {
-      const next: string[] = [];
-      for (const q of frontier) {
-        for (const edge of graph.adjacency.get(q) || []) {
-          if (edge.kind !== 'CALLS') continue;
-          if (visited.has(edge.target_qualified)) continue;
-          visited.add(edge.target_qualified);
-          next.push(edge.target_qualified);
-          path.push(edge.target_qualified);
-          const targetNode = graph.byQualified.get(edge.target_qualified);
-          if (targetNode) files.add(targetNode.file_path);
-        }
-      }
-      if (next.length === 0) break;
-      frontier = next;
-      depth++;
-    }
-
-    flows.push({
-      entry_point: ep.qualified,
-      type: ep.type,
-      depth,
-      node_count: visited.size,
-      file_count: files.size,
-      criticality: visited.size * files.size,
-      path,
-    });
-  }
-
-  flows.sort((a, b) => b.criticality - a.criticality);
-
-  const testFlows = flows.filter((f) => f.type === 'test').length;
-  const httpFlows = flows.filter((f) => f.type === 'http').length;
-  const avgDepth = flows.length > 0 ? Math.round((flows.reduce((s, f) => s + f.depth, 0) / flows.length) * 10) / 10 : 0;
-  const maxCriticality = flows.length > 0 ? flows[0].criticality : 0;
-
-  return {
-    flows,
-    summary: {
-      total_flows: flows.length,
-      by_type: { test: testFlows, http: httpFlows },
-      avg_depth: avgDepth,
-      max_criticality: maxCriticality,
-    },
-  };
-}