@kodus/kodus-graph 0.2.8 → 0.2.10

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,169 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-import type { GraphEdge, GraphNode } from '../graph/types';
-import { log } from '../shared/logger';
-
-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);
-  }
-
-  log.debug('diff: input', {
-    oldNodesInChanged: oldNodesInChanged.size,
-    newNodesInChanged: newNodesMap.size,
-    changedFiles,
-  });
-
-  // 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');
-          log.debug('diff: body change detected', {
-            node: qn,
-            oldHash: n.content_hash.substring(0, 8),
-            newHash: newN.content_hash.substring(0, 8),
-          });
-        } else {
-          log.debug('diff: hash match (displacement only)', {
-            node: qn,
-            oldLines: `${n.line_start}-${n.line_end}`,
-            newLines: `${newN.line_start}-${newN.line_end}`,
-          });
-        }
-      } 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');
-          log.debug('diff: line_range fallback (no content_hash)', {
-            node: qn,
-            hasOldHash: !!n.content_hash,
-            hasNewHash: !!newN.content_hash,
-            oldSize,
-            newSize,
-          });
-        }
-      }
-      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 };
-  }
-
-  log.info('diff: result', {
-    added: added.length,
-    removed: removed.length,
-    modified: modified.length,
-    edgesAdded: addedEdges.length,
-    edgesRemoved: removedEdges.length,
-    modifiedDetails: modified.map((m) => `${m.qualified_name} [${m.changes.join(',')}]`),
-  });
-
-  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,
-    },
-  };
-}

package/src/analysis/inheritance.ts

@@ -1,34 +0,0 @@
-import type { IndexedGraph } from '../graph/loader';
-import type { InheritanceEntry } from '../graph/types';
-
-export function extractInheritance(graph: IndexedGraph, changedFiles: string[]): InheritanceEntry[] {
-  const changedSet = new Set(changedFiles);
-  const entries: InheritanceEntry[] = [];
-
-  const changedClasses = graph.nodes.filter((n) => changedSet.has(n.file_path) && n.kind === 'Class');
-
-  for (const cls of changedClasses) {
-    let extendsClass: string | undefined;
-    const implementsList: string[] = [];
-    const children: string[] = [];
-
-    for (const edge of graph.adjacency.get(cls.qualified_name) || []) {
-      if (edge.kind === 'INHERITS') extendsClass = edge.target_qualified;
-      if (edge.kind === 'IMPLEMENTS') implementsList.push(edge.target_qualified);
-    }
-
-    for (const edge of graph.reverseAdjacency.get(cls.qualified_name) || []) {
-      if (edge.kind === 'INHERITS') children.push(edge.source_qualified);
-    }
-
-    entries.push({
-      qualified_name: cls.qualified_name,
-      file_path: cls.file_path,
-      extends: extendsClass,
-      implements: implementsList,
-      children,
-    });
-  }
-
-  return entries;
-}