@kodus/kodus-graph 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis",
   "type": "module",
   "bin": {
@@ -50,13 +50,13 @@
     "@ast-grep/lang-python": "^0.0.6",
     "@ast-grep/lang-ruby": "^0.0.7",
     "@ast-grep/lang-rust": "^0.0.7",
-    "@ast-grep/napi": "^0.42.0",
-    "commander": "^12.0.0",
+    "@ast-grep/napi": "^0.42.1",
+    "commander": "^14.0.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.10",
     "@types/bun": "latest",
-    "typescript": "^5.5.0"
+    "typescript": "^6.0.2"
   }
-}
+}

package/src/analysis/context-builder.ts

@@ -0,0 +1,130 @@
+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/enrich.ts

@@ -0,0 +1,109 @@
+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;
+        if ((edge.confidence ?? 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 || 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/inheritance.ts

@@ -0,0 +1,34 @@
+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;
+}

package/src/analysis/prompt-formatter.ts

@@ -0,0 +1,135 @@
+import type { ContextV2Output } from './context-builder';
+
+export function formatPrompt(output: ContextV2Output): string {
+  const { analysis } = output;
+  const lines: string[] = [];
+
+  // Header
+  const risk = analysis.risk;
+  const br = analysis.blast_radius;
+  const meta = analysis.metadata;
+  lines.push('# Code Review Context');
+  lines.push('');
+  lines.push(
+    `Risk: ${risk.level} (${risk.score}) | ${br.total_functions} functions impacted across ${br.total_files} files | ${meta.untested_count} untested`,
+  );
+  lines.push('');
+
+  // Changed functions
+  if (analysis.changed_functions.length > 0) {
+    lines.push('## Changed Functions');
+    lines.push('');
+
+    for (const fn of analysis.changed_functions) {
+      lines.push(`### ${fn.signature}  [${fn.file_path}:${fn.line_start}-${fn.line_end}]`);
+
+      // Status
+      if (fn.is_new) {
+        lines.push('Status: new');
+      } else if (fn.diff_changes.length > 0) {
+        lines.push(`Status: modified (${fn.diff_changes.join(', ')})`);
+      } else {
+        lines.push('Status: unchanged');
+      }
+
+      // Callers
+      if (fn.callers.length > 0) {
+        lines.push('Callers:');
+        for (const c of fn.callers) {
+          const conf = c.confidence < 0.85 ? ` confidence=${c.confidence.toFixed(2)}` : '';
+          lines.push(`  - ${c.name}  [${c.file_path}:${c.line}]${conf}`);
+        }
+      } else {
+        lines.push('Callers: none');
+      }
+
+      // Callees
+      if (fn.callees.length > 0) {
+        lines.push('Callees:');
+        for (const c of fn.callees) {
+          lines.push(`  - ${c.signature}  [${c.file_path}]`);
+        }
+      } else {
+        lines.push('Callees: none');
+      }
+
+      // Test coverage
+      lines.push(`Test coverage: ${fn.has_test_coverage ? 'yes' : 'no'}`);
+
+      // Affected flows
+      if (fn.in_flows.length > 0) {
+        lines.push('Affected flows:');
+        for (const ep of fn.in_flows) {
+          const flow = analysis.affected_flows.find((f) => f.entry_point === ep);
+          if (flow) {
+            const prefix = flow.type === 'http' ? 'HTTP' : 'TEST';
+            lines.push(`  - ${prefix}: ${flow.path.map((q) => q.split('::').pop()).join(' → ')}`);
+          } else {
+            lines.push(`  - ${ep.split('::').pop()}`);
+          }
+        }
+      } else {
+        lines.push('Affected flows: none');
+      }
+
+      lines.push('');
+    }
+  }
+
+  // Inheritance
+  if (analysis.inheritance.length > 0) {
+    lines.push('## Inheritance');
+    lines.push('');
+    for (const entry of analysis.inheritance) {
+      const name = entry.qualified_name.split('::').pop();
+      const parts: string[] = [];
+      if (entry.extends) parts.push(`extends ${entry.extends.split('::').pop()}`);
+      if (entry.implements.length > 0)
+        parts.push(`implements ${entry.implements.map((i) => i.split('::').pop()).join(', ')}`);
+      lines.push(`- ${name} ${parts.join(', ')}`);
+      if (entry.children.length > 0) {
+        lines.push(`  Children: ${entry.children.map((c) => c.split('::').pop()).join(', ')}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Blast radius by depth
+  const byDepth = analysis.blast_radius.by_depth;
+  const depthKeys = Object.keys(byDepth).sort();
+  if (depthKeys.length > 0) {
+    lines.push('## Blast Radius');
+    lines.push('');
+    for (const depth of depthKeys) {
+      const names = byDepth[depth].map((q) => q.split('::').pop());
+      lines.push(`Depth ${depth}: ${names.join(', ')} (${names.length} functions)`);
+    }
+    lines.push('');
+  }
+
+  // Test gaps
+  if (analysis.test_gaps.length > 0) {
+    lines.push('## Test Gaps');
+    lines.push('');
+    for (const gap of analysis.test_gaps) {
+      const name = gap.function.split('::').pop();
+      lines.push(`- ${name}  [${gap.file_path}:${gap.line_start}]`);
+    }
+    lines.push('');
+  }
+
+  // Structural diff summary
+  const diff = analysis.structural_diff;
+  if (diff.summary.added > 0 || diff.summary.removed > 0 || diff.summary.modified > 0) {
+    lines.push('## Structural Changes');
+    lines.push('');
+    const parts: string[] = [];
+    if (diff.summary.added > 0) parts.push(`${diff.summary.added} added`);
+    if (diff.summary.removed > 0) parts.push(`${diff.summary.removed} removed`);
+    if (diff.summary.modified > 0) parts.push(`${diff.summary.modified} modified`);
+    lines.push(parts.join(', '));
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/src/cli.ts

@@ -13,7 +13,7 @@ import { executeUpdate } from './commands/update';
 
 const program = new Command();
 
-program.name('kodus-graph').description('Code graph builder for Kodus code review').version('0.1.0');
+program.name('kodus-graph').description('Code graph builder for Kodus code review').version('0.2.1');
 
 program
   .command('parse')
@@ -21,6 +21,8 @@ program
   .option('--all', 'Parse all files in repo')
   .option('--files <paths...>', 'Parse specific files')
   .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--include <glob...>', 'Include only files matching glob (repeatable)')
+  .option('--exclude <glob...>', 'Exclude files matching glob (repeatable)')
   .requiredOption('--out <path>', 'Output JSON file path')
   .action(async (opts) => {
     const repoDir = resolve(opts.repoDir);
@@ -33,6 +35,8 @@ program
       files: opts.files,
       all: opts.all ?? false,
       out: opts.out,
+      include: opts.include,
+      exclude: opts.exclude,
     });
   });
 
@@ -64,17 +68,27 @@ program
   .option('--repo-dir <path>', 'Repository root directory', '.')
   .option('--graph <path>', 'Path to main graph JSON')
   .requiredOption('--out <path>', 'Output JSON file path')
+  .option('--min-confidence <n>', 'Minimum CALLS edge confidence', '0.5')
+  .option('--max-depth <n>', 'Blast radius BFS depth', '3')
+  .option('--format <type>', 'Output format: json or prompt', 'json')
   .action(async (opts) => {
     const repoDir = resolve(opts.repoDir);
     if (!existsSync(repoDir)) {
       process.stderr.write(`Error: --repo-dir does not exist: ${repoDir}\n`);
       process.exit(1);
     }
+    if (opts.format !== 'json' && opts.format !== 'prompt') {
+      process.stderr.write('Error: --format must be "json" or "prompt"\n');
+      process.exit(1);
+    }
     await executeContext({
       repoDir: opts.repoDir,
       files: opts.files,
       graph: opts.graph,
       out: opts.out,
+      minConfidence: Number.parseFloat(opts.minConfidence),
+      maxDepth: Number.parseInt(opts.maxDepth, 10),
+      format: opts.format,
     });
   });
 

package/src/commands/context.ts

@@ -1,8 +1,9 @@
 import { readFileSync, rmSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
-import { buildReviewContext } from '../analysis/review-context';
+import { buildContextV2 } from '../analysis/context-builder';
+import { formatPrompt } from '../analysis/prompt-formatter';
 import { mergeGraphs } from '../graph/merger';
-import type { ContextOutput, GraphData, MainGraphInput } from '../graph/types';
+import type { GraphData, MainGraphInput } from '../graph/types';
 import { log } from '../shared/logger';
 import { GraphInputSchema } from '../shared/schemas';
 import { createSecureTempFile } from '../shared/temp';
@@ -13,6 +14,9 @@ interface ContextOptions {
   files: string[];
   graph?: string;
   out: string;
+  minConfidence: number;
+  maxDepth: number;
+  format: 'json' | 'prompt';
 }
 
 export async function executeContext(opts: ContextOptions): Promise<void> {
@@ -31,6 +35,8 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
 
     // Load and merge with main graph if provided
     let mergedGraph: GraphData;
+    let oldGraph: GraphData | null = null;
+
     if (opts.graph) {
       let raw: unknown;
       try {
@@ -44,6 +50,7 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
         process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
         process.exit(1);
       }
+      oldGraph = { nodes: validated.data.nodes, edges: validated.data.edges };
       const mainGraph: MainGraphInput = {
         repo_id: '',
         sha: '',
@@ -55,10 +62,20 @@ export async function executeContext(opts: ContextOptions): Promise<void> {
       mergedGraph = { nodes: parseResult.nodes, edges: parseResult.edges };
     }
 
-    // Build review context
-    const contextOutput: ContextOutput = buildReviewContext(mergedGraph, opts.files);
+    // Build V2 context
+    const output = buildContextV2({
+      mergedGraph,
+      oldGraph,
+      changedFiles: opts.files,
+      minConfidence: opts.minConfidence,
+      maxDepth: opts.maxDepth,
+    });
 
-    writeFileSync(opts.out, JSON.stringify(contextOutput, null, 2));
+    if (opts.format === 'prompt') {
+      writeFileSync(opts.out, formatPrompt(output));
+    } else {
+      writeFileSync(opts.out, JSON.stringify(output, null, 2));
+    }
   } finally {
     try {
       rmSync(tmp.dir, { recursive: true, force: true });

package/src/commands/parse.ts

@@ -1,8 +1,8 @@
-import { writeFileSync } from 'fs';
-import { relative, resolve } from 'path';
+import { resolve, relative } from 'path';
 import { performance } from 'perf_hooks';
 import { buildGraphData } from '../graph/builder';
-import type { ImportEdge, ParseOutput } from '../graph/types';
+import { writeGraphJSON } from '../graph/json-writer';
+import type { ImportEdge } from '../graph/types';
 import { parseBatch } from '../parser/batch';
 import { discoverFiles } from '../parser/discovery';
 import { resolveAllCalls } from '../resolver/call-resolver';
@@ -12,11 +12,13 @@ import { createSymbolTable } from '../resolver/symbol-table';
 import { computeFileHash } from '../shared/file-hash';
 import { log } from '../shared/logger';
 
-interface ParseOptions {
+export interface ParseOptions {
   repoDir: string;
   files?: string[];
   all: boolean;
   out: string;
+  include?: string[];
+  exclude?: string[];
 }
 
 export async function executeParse(opts: ParseOptions): Promise<void> {
@@ -24,27 +26,25 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
   const repoDir = resolve(opts.repoDir);
 
   // Phase 1: Discover files
-  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files);
+  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files, opts.include, opts.exclude);
   process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
 
   // Phase 2: Parse + extract
-  const rawGraph = await parseBatch(files, repoDir);
+  let rawGraph = await parseBatch(files, repoDir);
   process.stderr.write(
     `[2/5] Parsed ${rawGraph.functions.length} functions, ${rawGraph.classes.length} classes, ${rawGraph.rawCalls.length} call sites\n`,
   );
 
   // Phase 3: Resolve imports
   const tsconfigAliases = loadTsconfigAliases(repoDir);
-  const symbolTable = createSymbolTable();
-  const importMap = createImportMap();
-  const importEdges: ImportEdge[] = [];
+  let symbolTable = createSymbolTable();
+  let importMap = createImportMap();
+  let importEdges: ImportEdge[] = [];
 
-  // Populate symbol table
   for (const f of rawGraph.functions) symbolTable.add(f.file, f.name, f.qualified);
   for (const c of rawGraph.classes) symbolTable.add(c.file, c.name, c.qualified);
   for (const i of rawGraph.interfaces) symbolTable.add(i.file, i.name, i.qualified);
 
-  // Resolve each import
   for (const imp of rawGraph.imports) {
     const langKey = imp.lang === 'python' ? 'python' : imp.lang === 'ruby' ? 'ruby' : 'typescript';
     const resolved = resolveImport(resolve(repoDir, imp.file), imp.module, langKey, repoDir, tsconfigAliases);
@@ -64,7 +64,7 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
   );
 
   // Phase 4: Resolve calls
-  const { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+  let { callEdges, stats } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
   process.stderr.write(
     `[4/5] Resolved ${callEdges.length} calls (DI:${stats.di} same:${stats.same} import:${stats.import} unique:${stats.unique} ambiguous:${stats.ambiguous} noise:${stats.noise})\n`,
   );
@@ -79,22 +79,27 @@ export async function executeParse(opts: ParseOptions): Promise<void> {
     }
   }
 
+  const parseErrors = rawGraph.parseErrors;
+  const extractErrors = rawGraph.extractErrors;
   const graphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
   process.stderr.write(`[5/5] Built graph: ${graphData.nodes.length} nodes, ${graphData.edges.length} edges\n`);
 
-  const output: ParseOutput = {
-    metadata: {
-      repo_dir: repoDir,
-      files_parsed: files.length,
-      total_nodes: graphData.nodes.length,
-      total_edges: graphData.edges.length,
-      duration_ms: Math.round(performance.now() - t0),
-      parse_errors: rawGraph.parseErrors,
-      extract_errors: rawGraph.extractErrors,
-    },
-    nodes: graphData.nodes,
-    edges: graphData.edges,
+  // Release intermediaries — no longer needed after buildGraphData
+  rawGraph = null as any;
+  symbolTable = null as any;
+  importMap = null as any;
+  callEdges = null as any;
+  importEdges = null as any;
+
+  const metadata = {
+    repo_dir: repoDir,
+    files_parsed: files.length,
+    total_nodes: graphData.nodes.length,
+    total_edges: graphData.edges.length,
+    duration_ms: Math.round(performance.now() - t0),
+    parse_errors: parseErrors,
+    extract_errors: extractErrors,
   };
 
-  writeFileSync(opts.out, JSON.stringify(output, null, 2));
+  writeGraphJSON(opts.out, metadata, graphData.nodes, graphData.edges);
 }

package/src/graph/json-writer.ts

@@ -0,0 +1,43 @@
+import { openSync, writeSync, closeSync } from 'fs';
+import type { GraphEdge, GraphNode, ParseMetadata } from './types';
+
+/**
+ * Write graph output as JSON to disk using incremental serialization.
+ *
+ * Instead of JSON.stringify on the full output (which creates a ~100-300 MB
+ * string for large repos), this writes each node/edge individually.
+ * Peak memory: only one JSON.stringify(singleNode) string at a time (~1 KB).
+ */
+export function writeGraphJSON(
+  out: string,
+  metadata: ParseMetadata,
+  nodes: GraphNode[],
+  edges: GraphEdge[],
+): void {
+  const fd = openSync(out, 'w');
+
+  try {
+    writeSync(fd, '{"metadata":');
+    writeSync(fd, JSON.stringify(metadata));
+
+    // Nodes
+    writeSync(fd, ',"nodes":[');
+    for (let i = 0; i < nodes.length; i++) {
+      if (i > 0) writeSync(fd, ',');
+      writeSync(fd, '\n');
+      writeSync(fd, JSON.stringify(nodes[i]));
+    }
+    writeSync(fd, '\n]');
+
+    // Edges
+    writeSync(fd, ',"edges":[');
+    for (let i = 0; i < edges.length; i++) {
+      if (i > 0) writeSync(fd, ',');
+      writeSync(fd, '\n');
+      writeSync(fd, JSON.stringify(edges[i]));
+    }
+    writeSync(fd, '\n]}');
+  } finally {
+    closeSync(fd);
+  }
+}

package/src/graph/loader.ts

@@ -1,7 +1,7 @@
 // src/graph/loader.ts
 import { readFileSync } from 'fs';
 import { z } from 'zod';
-import type { GraphEdge, GraphNode, ParseMetadata } from './types';
+import type { GraphData, GraphEdge, GraphNode, ParseMetadata } from './types';
 
 const ParseOutputSchema = z.object({
   metadata: z.object({
@@ -55,19 +55,17 @@ export interface IndexedGraph {
   metadata: ParseMetadata;
 }
 
-export function loadGraph(path: string): IndexedGraph {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf-8'));
-  } catch (err) {
-    throw new Error(`Failed to read graph file: ${path} — ${String(err)}`);
-  }
-
-  const parsed = ParseOutputSchema.parse(raw);
-
-  const nodes = parsed.nodes as GraphNode[];
-  const edges = parsed.edges as GraphEdge[];
-  const metadata = parsed.metadata as ParseMetadata;
+export function indexGraph(data: GraphData, metadata?: ParseMetadata): IndexedGraph {
+  const { nodes, edges } = data;
+  const meta: ParseMetadata = metadata ?? {
+    repo_dir: '',
+    files_parsed: 0,
+    total_nodes: nodes.length,
+    total_edges: edges.length,
+    duration_ms: 0,
+    parse_errors: 0,
+    extract_errors: 0,
+  };
 
   const byQualified = new Map<string, GraphNode>();
   const byFile = new Map<string, GraphNode[]>();
@@ -96,5 +94,20 @@ export function loadGraph(path: string): IndexedGraph {
     else edgesByKind.set(edge.kind, [edge]);
   }
 
-  return { nodes, edges, byQualified, byFile, adjacency, reverseAdjacency, edgesByKind, metadata };
+  return { nodes, edges, byQualified, byFile, adjacency, reverseAdjacency, edgesByKind, metadata: meta };
+}
+
+export function loadGraph(path: string): IndexedGraph {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf-8'));
+  } catch (err) {
+    throw new Error(`Failed to read graph file: ${path} — ${String(err)}`);
+  }
+
+  const parsed = ParseOutputSchema.parse(raw);
+  return indexGraph(
+    { nodes: parsed.nodes as GraphNode[], edges: parsed.edges as GraphEdge[] },
+    parsed.metadata as ParseMetadata,
+  );
 }

package/src/graph/types.ts

@@ -116,6 +116,64 @@ export interface MainGraphInput {
   edges: GraphEdge[];
 }
 
+// ── Context V2 types ──
+export interface CallerRef {
+  qualified_name: string;
+  name: string;
+  file_path: string;
+  line: number;
+  confidence: number;
+}
+
+export interface CalleeRef {
+  qualified_name: string;
+  name: string;
+  file_path: string;
+  signature: string;
+}
+
+export interface EnrichedFunction {
+  qualified_name: string;
+  name: string;
+  kind: NodeKind;
+  signature: string;
+  file_path: string;
+  line_start: number;
+  line_end: number;
+  callers: CallerRef[];
+  callees: CalleeRef[];
+  has_test_coverage: boolean;
+  diff_changes: string[];
+  is_new: boolean;
+  in_flows: string[];
+}
+
+export interface AffectedFlow {
+  entry_point: string;
+  type: 'test' | 'http';
+  touches_changed: string[];
+  depth: number;
+  path: string[];
+}
+
+export interface InheritanceEntry {
+  qualified_name: string;
+  file_path: string;
+  extends?: string;
+  implements: string[];
+  children: string[];
+}
+
+export interface ContextAnalysisMetadata {
+  changed_functions_count: number;
+  total_callers: number;
+  total_callees: number;
+  untested_count: number;
+  affected_flows_count: number;
+  duration_ms: number;
+  min_confidence: number;
+}
+
 // ── Internal types used during parsing pipeline ──
 export interface RawFunction {
   name: string;

package/src/parser/batch.ts

@@ -2,7 +2,8 @@ import type { SgRoot } from '@ast-grep/napi';
 import { parseAsync } from '@ast-grep/napi';
 import { readFileSync } from 'fs';
 import { extname, relative } from 'path';
-import type { ParseBatchResult, RawGraph } from '../graph/types';
+import type { ParseBatchResult, RawCallSite, RawGraph } from '../graph/types';
+import { NOISE } from '../shared/filters';
 import { log } from '../shared/logger';
 import { extractCallsFromFile, extractFromFile } from './extractor';
 import { getLanguage } from './languages';
@@ -60,7 +61,14 @@ export async function parseBatch(files: string[], repoRoot: string): Promise<Par
       }
 
       try {
-        extractCallsFromFile(root, fp, lang, graph.rawCalls);
+        // Extract calls into a temporary buffer, then filter noise before pushing
+        const rawCalls: RawCallSite[] = [];
+        extractCallsFromFile(root, fp, lang, rawCalls);
+        for (const call of rawCalls) {
+          if (!NOISE.has(call.callName)) {
+            graph.rawCalls.push(call);
+          }
+        }
       } catch (err) {
         log.error('Call extraction crashed', { file: fp, error: String(err) });
         extractErrors++;

package/src/parser/discovery.ts

@@ -1,5 +1,5 @@
 import { readdirSync } from 'fs';
-import { extname, join, resolve } from 'path';
+import { extname, join, relative, resolve } from 'path';
 import { isSkippableFile, SKIP_DIRS } from '../shared/filters';
 import { log } from '../shared/logger';
 import { ensureWithinRoot } from '../shared/safe-path';
@@ -8,8 +8,15 @@ import { getLanguage } from './languages';
 /**
  * Walk the filesystem and find all supported source files.
  * If `filterFiles` is provided, only return those specific files (resolved to absolute paths).
+ * If `include` patterns are provided, keep only files matching at least one pattern.
+ * If `exclude` patterns are provided, remove files matching any pattern.
  */
-export function discoverFiles(repoDir: string, filterFiles?: string[]): string[] {
+export function discoverFiles(
+  repoDir: string,
+  filterFiles?: string[],
+  include?: string[],
+  exclude?: string[],
+): string[] {
   const absRepoDir = resolve(repoDir);
 
   if (filterFiles) {
@@ -26,8 +33,34 @@ export function discoverFiles(repoDir: string, filterFiles?: string[]): string[]
       });
   }
 
-  const files: string[] = [];
+  let files: string[] = [];
   walkFiles(absRepoDir, files);
+
+  // Apply include/exclude filters using Bun.Glob
+  const hasInclude = include && include.length > 0;
+  const hasExclude = exclude && exclude.length > 0;
+
+  if (hasInclude || hasExclude) {
+    const includeGlobs = hasInclude ? include.map((p) => new Bun.Glob(p)) : null;
+    const excludeGlobs = hasExclude ? exclude.map((p) => new Bun.Glob(p)) : null;
+
+    files = files.filter((absPath) => {
+      const rel = relative(absRepoDir, absPath);
+
+      // If include patterns exist, file must match at least one
+      if (includeGlobs && !includeGlobs.some((g) => g.match(rel))) {
+        return false;
+      }
+
+      // If exclude patterns exist, file must not match any
+      if (excludeGlobs && excludeGlobs.some((g) => g.match(rel))) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
   return files;
 }
 

package/src/analysis/review-context.ts

@@ -1,141 +0,0 @@
-import type { ContextOutput, GraphData } from '../graph/types';
-import { computeBlastRadius } from './blast-radius';
-import { computeRiskScore } from './risk-score';
-import { findTestGaps } from './test-gaps';
-
-export function buildReviewContext(graph: GraphData, changedFiles: string[]): ContextOutput {
-  const changedSet = new Set(changedFiles);
-  const lines: string[] = [];
-
-  // Build caller/callee index from CALLS edges
-  const callersOf = new Map<string, Array<{ name: string; file: string; line: number; confidence: number }>>();
-  const calleesOf = new Map<
-    string,
-    Array<{ name: string; target: string; file: string; line: number; confidence: number }>
-  >();
-
-  // Index nodes by qualified name
-  const nodeIndex = new Map(graph.nodes.map((n) => [n.qualified_name, n]));
-
-  for (const edge of graph.edges) {
-    if (edge.kind !== 'CALLS' || (edge.confidence ?? 0) < 0.5) continue;
-
-    // callers: who calls edge.target
-    if (!callersOf.has(edge.target_qualified)) callersOf.set(edge.target_qualified, []);
-    const sourceNode = nodeIndex.get(edge.source_qualified);
-    callersOf.get(edge.target_qualified)!.push({
-      name: sourceNode?.name || edge.source_qualified.split('::').pop() || 'unknown',
-      file: sourceNode?.file_path || edge.file_path,
-      line: edge.line,
-      confidence: edge.confidence || 0,
-    });
-
-    // callees: what does source call
-    if (!calleesOf.has(edge.source_qualified)) calleesOf.set(edge.source_qualified, []);
-    const targetNode = nodeIndex.get(edge.target_qualified);
-    calleesOf.get(edge.source_qualified)!.push({
-      name: targetNode?.name || edge.target_qualified.split('::').pop() || 'unknown',
-      target: edge.target_qualified,
-      file: targetNode?.file_path || '',
-      line: edge.line,
-      confidence: edge.confidence || 0,
-    });
-  }
-
-  // TESTED_BY index
-  const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
-
-  lines.push('Changed functions (AST analysis):\n');
-
-  // Functions in changed files
-  const changedFunctions = graph.nodes
-    .filter(
-      (n) =>
-        changedSet.has(n.file_path) && !n.is_test && n.kind !== 'Class' && n.kind !== 'Interface' && n.kind !== 'Enum',
-    )
-    .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start);
-
-  let callerCount = 0;
-  let calleeCount = 0;
-
-  for (const func of changedFunctions) {
-    if (func.kind === 'Constructor') continue;
-
-    const shortName = func.name.includes('.') ? func.name.split('.').pop()! : func.name;
-    const sig = func.params && func.params !== '()' ? `${shortName}${func.params}` : shortName;
-    const ret = func.return_type ? ` -> ${func.return_type}` : '';
-    lines.push(`${sig}${ret}  (${func.file_path}:${func.line_start})`);
-
-    // Callers
-    const callers = callersOf.get(func.qualified_name) || [];
-    callerCount += callers.length;
-    for (const caller of callers.slice(0, 5)) {
-      const conf = caller.confidence >= 0.85 ? '' : ` [${Math.round(caller.confidence * 100)}%]`;
-      lines.push(`  ← called by ${caller.name} (${caller.file}:${caller.line})${conf}`);
-    }
-    if (callers.length > 5) lines.push(`  ← ... and ${callers.length - 5} more callers`);
-
-    // Callees
-    const callees = calleesOf.get(func.qualified_name) || [];
-    calleeCount += callees.length;
-    const seenCallees = new Set<string>();
-    for (const callee of callees.slice(0, 5)) {
-      if (seenCallees.has(callee.target)) continue;
-      seenCallees.add(callee.target);
-      const calleeNode = nodeIndex.get(callee.target);
-      if (calleeNode) {
-        const calleeSig =
-          calleeNode.params && calleeNode.params !== '()' ? `${callee.name}${calleeNode.params}` : callee.name;
-        const calleeRet = calleeNode.return_type ? ` -> ${calleeNode.return_type}` : '';
-        lines.push(`  → calls ${calleeSig}${calleeRet}  (${calleeNode.file_path}:${calleeNode.line_start})`);
-      } else {
-        lines.push(`  → calls ${callee.name}  (${callee.file || 'external'})`);
-      }
-    }
-
-    // Test coverage
-    if (testedFiles.has(func.file_path)) {
-      lines.push(`  ✅ has test coverage`);
-    } else {
-      lines.push(`  ⚠ NO TEST COVERAGE`);
-    }
-
-    lines.push('');
-  }
-
-  // Blast radius
-  const blastRadius = computeBlastRadius(graph, changedFiles);
-  if (blastRadius.total_files > changedFiles.length) {
-    lines.push(
-      `Blast radius: ${changedFunctions.filter((f) => f.kind !== 'Constructor').length} changed functions impact ${blastRadius.total_files - changedFiles.length} other files`,
-    );
-  }
-
-  // Risk score
-  const riskScore = computeRiskScore(graph, changedFiles, blastRadius);
-  lines.push(`\nRisk: ${riskScore.level} (${riskScore.score})`);
-
-  // Test gaps
-  const testGaps = findTestGaps(graph, changedFiles);
-  const untestedCount = testGaps.length;
-  if (untestedCount > 0) {
-    lines.push(`\n⚠ ${untestedCount} changed function(s) without test coverage:`);
-    for (const gap of testGaps.slice(0, 10)) {
-      const shortName = gap.function.split('::').pop() || gap.function;
-      lines.push(`  ${shortName} (${gap.file_path}:${gap.line_start})`);
-    }
-  }
-
-  return {
-    text: lines.join('\n'),
-    metadata: {
-      changed_functions: changedFunctions.filter((f) => f.kind !== 'Constructor').length,
-      caller_count: callerCount,
-      callee_count: calleeCount,
-      untested_count: untestedCount,
-      blast_radius: { functions: blastRadius.total_functions, files: blastRadius.total_files },
-      risk_level: riskScore.level,
-      risk_score: riskScore.score,
-    },
-  };
-}