@kodus/kodus-graph 0.1.0

package/src/analysis/search.ts

@@ -0,0 +1,76 @@
+import type { IndexedGraph } from '../graph/loader';
+import type { GraphNode } from '../graph/types';
+
+export interface SearchOptions {
+  query?: string;
+  kind?: string;
+  file?: string;
+  limit?: number;
+}
+
+export function searchNodes(graph: IndexedGraph, opts: SearchOptions): GraphNode[] {
+  const { query, kind, file, limit = 50 } = opts;
+  let results = graph.nodes;
+
+  if (query) {
+    const matcher = buildMatcher(query);
+    results = results.filter((n) => matcher(n.name) || matcher(n.qualified_name));
+  }
+
+  if (kind) {
+    results = results.filter((n) => n.kind === kind);
+  }
+
+  if (file) {
+    const fileMatcher = buildMatcher(file);
+    results = results.filter((n) => fileMatcher(n.file_path));
+  }
+
+  results.sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start);
+
+  return results.slice(0, limit);
+}
+
+export function findCallers(graph: IndexedGraph, qualifiedName: string): GraphNode[] {
+  const edges = graph.reverseAdjacency.get(qualifiedName) || [];
+  const callers: GraphNode[] = [];
+  for (const e of edges) {
+    if (e.kind !== 'CALLS') continue;
+    const node = graph.byQualified.get(e.source_qualified);
+    if (node) callers.push(node);
+  }
+  return callers;
+}
+
+export function findCallees(graph: IndexedGraph, qualifiedName: string): GraphNode[] {
+  const edges = graph.adjacency.get(qualifiedName) || [];
+  const callees: GraphNode[] = [];
+  for (const e of edges) {
+    if (e.kind !== 'CALLS') continue;
+    const node = graph.byQualified.get(e.target_qualified);
+    if (node) callees.push(node);
+  }
+  return callees;
+}
+
+function buildMatcher(pattern: string): (text: string) => boolean {
+  // Regex: /pattern/flags
+  if (pattern.startsWith('/')) {
+    const lastSlash = pattern.lastIndexOf('/');
+    if (lastSlash > 0) {
+      const regex = new RegExp(pattern.slice(1, lastSlash), pattern.slice(lastSlash + 1));
+      return (text) => regex.test(text);
+    }
+  }
+
+  // Glob: contains *
+  if (pattern.includes('*')) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    const regex = new RegExp(`^${escaped}$`, 'i');
+    return (text) => regex.test(text);
+  }
+
+  // Substring (case-insensitive)
+  const lower = pattern.toLowerCase();
+  return (text) => text.toLowerCase().includes(lower);
+}

package/src/analysis/test-gaps.ts

@@ -0,0 +1,21 @@
+import type { GraphData, TestGap } from '../graph/types';
+
+export function findTestGaps(graph: GraphData, changedFiles: string[]): TestGap[] {
+  const changedSet = new Set(changedFiles);
+
+  const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
+
+  return graph.nodes
+    .filter(
+      (n) =>
+        changedSet.has(n.file_path) &&
+        (n.kind === 'Function' || n.kind === 'Method') &&
+        !n.is_test &&
+        !testedFiles.has(n.file_path),
+    )
+    .map((n) => ({
+      function: n.qualified_name,
+      file_path: n.file_path,
+      line_start: n.line_start,
+    }));
+}

package/src/cli.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { executeAnalyze } from './commands/analyze';
+import { executeCommunities } from './commands/communities';
+import { executeContext } from './commands/context';
+import { executeDiff } from './commands/diff';
+import { executeFlows } from './commands/flows';
+import { executeParse } from './commands/parse';
+import { executeSearch } from './commands/search';
+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
+  .command('parse')
+  .description('Parse source files and generate nodes + edges')
+  .option('--all', 'Parse all files in repo')
+  .option('--files <paths...>', 'Parse specific files')
+  .option('--repo-dir <path>', 'Repository root directory', '.')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .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);
+    }
+    await executeParse({
+      repoDir: opts.repoDir,
+      files: opts.files,
+      all: opts.all ?? false,
+      out: opts.out,
+    });
+  });
+
+program
+  .command('analyze')
+  .description('Compute blast radius, risk score, and test gaps')
+  .requiredOption('--files <paths...>', 'Changed files to analyze')
+  .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--graph <path>', 'Path to main graph JSON')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .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);
+    }
+    await executeAnalyze({
+      repoDir: opts.repoDir,
+      files: opts.files,
+      graph: opts.graph,
+      out: opts.out,
+    });
+  });
+
+program
+  .command('context')
+  .description('Generate enriched review context for agents')
+  .requiredOption('--files <paths...>', 'Changed files')
+  .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--graph <path>', 'Path to main graph JSON')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .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);
+    }
+    await executeContext({
+      repoDir: opts.repoDir,
+      files: opts.files,
+      graph: opts.graph,
+      out: opts.out,
+    });
+  });
+
+program
+  .command('diff')
+  .description('Compare changed files against an existing graph')
+  .option('--base <ref>', 'Git ref to diff against')
+  .option('--files <paths...>', 'Explicit list of changed files')
+  .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--graph <path>', 'Previous graph JSON', '.kodus-graph/graph.json')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .action(async (opts) => {
+    if (!opts.base && !opts.files) {
+      process.stderr.write('Error: one of --base or --files is required\n');
+      process.exit(1);
+    }
+    const repoDir = resolve(opts.repoDir);
+    if (!existsSync(repoDir)) {
+      process.stderr.write(`Error: --repo-dir does not exist: ${repoDir}\n`);
+      process.exit(1);
+    }
+    await executeDiff({
+      repoDir: opts.repoDir,
+      base: opts.base,
+      files: opts.files,
+      graph: opts.graph,
+      out: opts.out,
+    });
+  });
+
+program
+  .command('update')
+  .description('Incrementally update graph (only re-parse changed files)')
+  .option('--repo-dir <path>', 'Repository root directory', '.')
+  .option('--graph <path>', 'Previous graph JSON (default: .kodus-graph/graph.json)')
+  .option('--out <path>', 'Output path (default: same as --graph)')
+  .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);
+    }
+    await executeUpdate({
+      repoDir: opts.repoDir,
+      graph: opts.graph,
+      out: opts.out,
+    });
+  });
+
+program
+  .command('communities')
+  .description('Detect module clusters and coupling between them')
+  .requiredOption('--graph <path>', 'Path to graph JSON')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .option('--min-size <n>', 'Minimum nodes per community', '2')
+  .option('--depth <n>', 'Directory grouping depth', '2')
+  .action((opts) => {
+    executeCommunities({
+      graph: opts.graph,
+      out: opts.out,
+      minSize: parseInt(opts.minSize, 10),
+      depth: parseInt(opts.depth, 10),
+    });
+  });
+
+program
+  .command('flows')
+  .description('Detect entry points and trace execution paths')
+  .requiredOption('--graph <path>', 'Path to graph JSON')
+  .requiredOption('--out <path>', 'Output JSON file path')
+  .option('--max-depth <n>', 'Max BFS trace depth', '10')
+  .option('--type <kind>', 'Filter: test, http, all', 'all')
+  .action((opts) => {
+    executeFlows({
+      graph: opts.graph,
+      out: opts.out,
+      maxDepth: parseInt(opts.maxDepth, 10),
+      type: opts.type as 'test' | 'http' | 'all',
+    });
+  });
+
+program
+  .command('search')
+  .description('Search the graph by name, kind, file, or relations')
+  .requiredOption('--graph <path>', 'Path to graph JSON')
+  .option('--query <pattern>', 'Search by name/qualified_name (glob or /regex/)')
+  .option('--kind <type>', 'Filter by kind: Function, Method, Class, Interface, Enum, Test')
+  .option('--file <pattern>', 'Filter by file path (glob)')
+  .option('--callers-of <qualified>', 'Find callers of this node')
+  .option('--callees-of <qualified>', 'Find callees of this node')
+  .option('--limit <n>', 'Max results', '50')
+  .option('--out <path>', 'Output file (default: stdout)')
+  .action((opts) => {
+    const modes = [opts.query, opts.callersOf, opts.calleesOf].filter(Boolean).length;
+    if (modes === 0) {
+      process.stderr.write('Error: one of --query, --callers-of, or --callees-of is required\n');
+      process.exit(1);
+    }
+    if (modes > 1) {
+      process.stderr.write('Error: --query, --callers-of, and --callees-of are mutually exclusive\n');
+      process.exit(1);
+    }
+    executeSearch({
+      graph: opts.graph,
+      query: opts.query,
+      kind: opts.kind,
+      file: opts.file,
+      callersOf: opts.callersOf,
+      calleesOf: opts.calleesOf,
+      limit: parseInt(opts.limit, 10),
+      out: opts.out,
+    });
+  });
+
+program.parse();

package/src/commands/analyze.ts

@@ -0,0 +1,66 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { computeBlastRadius } from '../analysis/blast-radius';
+import { computeRiskScore } from '../analysis/risk-score';
+import { findTestGaps } from '../analysis/test-gaps';
+import { buildGraphData } from '../graph/builder';
+import { mergeGraphs } from '../graph/merger';
+import type { AnalysisOutput, MainGraphInput } from '../graph/types';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { GraphInputSchema } from '../shared/schemas';
+
+interface AnalyzeOptions {
+  repoDir: string;
+  files: string[];
+  graph?: string;
+  out: string;
+}
+
+export async function executeAnalyze(opts: AnalyzeOptions): Promise<void> {
+  const repoDir = resolve(opts.repoDir);
+
+  // Load main graph if provided
+  let mainGraph: MainGraphInput | null = null;
+  if (opts.graph) {
+    let raw: unknown;
+    try {
+      raw = JSON.parse(readFileSync(opts.graph, 'utf-8'));
+    } catch (_err) {
+      process.stderr.write(`Error: Failed to read --graph file: ${opts.graph}\n`);
+      process.exit(1);
+    }
+    const validated = GraphInputSchema.safeParse(raw);
+    if (!validated.success) {
+      process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
+      process.exit(1);
+    }
+    mainGraph = {
+      repo_id: '',
+      sha: '',
+      nodes: validated.data.nodes,
+      edges: validated.data.edges,
+    };
+  }
+
+  // Parse changed files locally
+  const localFiles = discoverFiles(repoDir, opts.files);
+  const rawGraph = await parseBatch(localFiles, repoDir);
+  const localGraphData = buildGraphData(rawGraph, [], [], repoDir, new Map());
+
+  // Merge with main graph (or use local only)
+  const mergedGraph = mainGraph ? mergeGraphs(mainGraph, localGraphData, opts.files) : localGraphData;
+
+  // Analyze
+  const blastRadius = computeBlastRadius(mergedGraph, opts.files);
+  const riskScore = computeRiskScore(mergedGraph, opts.files, blastRadius);
+  const testGaps = findTestGaps(mergedGraph, opts.files);
+
+  const output: AnalysisOutput = {
+    blast_radius: blastRadius,
+    risk_score: riskScore,
+    test_gaps: testGaps,
+  };
+
+  writeFileSync(opts.out, JSON.stringify(output, null, 2));
+}

package/src/commands/communities.ts

@@ -0,0 +1,19 @@
+import { writeFileSync } from 'fs';
+import { detectCommunities } from '../analysis/communities';
+import { loadGraph } from '../graph/loader';
+
+interface CommunitiesCommandOptions {
+  graph: string;
+  out: string;
+  minSize: number;
+  depth: number;
+}
+
+export function executeCommunities(opts: CommunitiesCommandOptions): void {
+  const graph = loadGraph(opts.graph);
+  const result = detectCommunities(graph, { depth: opts.depth, minSize: opts.minSize });
+  writeFileSync(opts.out, JSON.stringify(result, null, 2));
+  process.stderr.write(
+    `Communities: ${result.summary.total_communities} detected, avg cohesion ${result.summary.avg_cohesion}, ${result.summary.high_coupling_pairs} high-coupling pairs\n`,
+  );
+}

package/src/commands/context.ts

@@ -0,0 +1,69 @@
+import { readFileSync, rmSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { buildReviewContext } from '../analysis/review-context';
+import { mergeGraphs } from '../graph/merger';
+import type { ContextOutput, GraphData, MainGraphInput } from '../graph/types';
+import { log } from '../shared/logger';
+import { GraphInputSchema } from '../shared/schemas';
+import { createSecureTempFile } from '../shared/temp';
+import { executeParse } from './parse';
+
+interface ContextOptions {
+  repoDir: string;
+  files: string[];
+  graph?: string;
+  out: string;
+}
+
+export async function executeContext(opts: ContextOptions): Promise<void> {
+  const repoDir = resolve(opts.repoDir);
+
+  // Parse changed files using secure temp
+  const tmp = createSecureTempFile('ctx');
+  try {
+    await executeParse({
+      repoDir,
+      files: opts.files,
+      all: false,
+      out: tmp.filePath,
+    });
+    const parseResult = JSON.parse(readFileSync(tmp.filePath, 'utf-8'));
+
+    // Load and merge with main graph if provided
+    let mergedGraph: GraphData;
+    if (opts.graph) {
+      let raw: unknown;
+      try {
+        raw = JSON.parse(readFileSync(opts.graph, 'utf-8'));
+      } catch (_err) {
+        process.stderr.write(`Error: Failed to read --graph file: ${opts.graph}\n`);
+        process.exit(1);
+      }
+      const validated = GraphInputSchema.safeParse(raw);
+      if (!validated.success) {
+        process.stderr.write(`Error: Invalid graph JSON: ${validated.error.message}\n`);
+        process.exit(1);
+      }
+      const mainGraph: MainGraphInput = {
+        repo_id: '',
+        sha: '',
+        nodes: validated.data.nodes,
+        edges: validated.data.edges,
+      };
+      mergedGraph = mergeGraphs(mainGraph, parseResult, opts.files);
+    } else {
+      mergedGraph = { nodes: parseResult.nodes, edges: parseResult.edges };
+    }
+
+    // Build review context
+    const contextOutput: ContextOutput = buildReviewContext(mergedGraph, opts.files);
+
+    writeFileSync(opts.out, JSON.stringify(contextOutput, null, 2));
+  } finally {
+    try {
+      rmSync(tmp.dir, { recursive: true, force: true });
+    } catch (err) {
+      log.debug('Failed to clean up temp dir', { dir: tmp.dir, error: String(err) });
+    }
+  }
+}

package/src/commands/diff.ts

@@ -0,0 +1,96 @@
+import { execSync } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { relative, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { computeStructuralDiff } from '../analysis/diff';
+import { buildGraphData } from '../graph/builder';
+import { loadGraph } from '../graph/loader';
+import type { ImportEdge } from '../graph/types';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { resolveAllCalls } from '../resolver/call-resolver';
+import { createImportMap } from '../resolver/import-map';
+import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
+import { createSymbolTable } from '../resolver/symbol-table';
+import { computeFileHash } from '../shared/file-hash';
+
+interface DiffCommandOptions {
+  repoDir: string;
+  base?: string;
+  files?: string[];
+  graph: string;
+  out: string;
+}
+
+export async function executeDiff(opts: DiffCommandOptions): Promise<void> {
+  const t0 = performance.now();
+  const repoDir = resolve(opts.repoDir);
+
+  // Resolve changed files
+  let changedFiles: string[];
+  if (opts.base) {
+    try {
+      const output = execSync(`git diff --name-only ${opts.base}`, { cwd: repoDir, encoding: 'utf-8' });
+      changedFiles = output.trim().split('\n').filter(Boolean);
+    } catch (err) {
+      process.stderr.write(`Error: failed to run git diff with base "${opts.base}": ${String(err)}\n`);
+      process.exit(1);
+    }
+  } else {
+    changedFiles = opts.files!;
+  }
+
+  process.stderr.write(`[1/4] ${changedFiles.length} changed files\n`);
+
+  // Load old graph
+  const graphPath = resolve(opts.graph);
+  if (!existsSync(graphPath)) {
+    process.stderr.write(`Error: graph file not found: ${graphPath}\n`);
+    process.exit(1);
+  }
+  const oldGraph = loadGraph(graphPath);
+  process.stderr.write(`[2/4] Loaded previous graph (${oldGraph.nodes.length} nodes)\n`);
+
+  // Re-parse changed files
+  const absFiles = discoverFiles(repoDir, changedFiles);
+  const rawGraph = await parseBatch(absFiles, repoDir);
+
+  const tsconfigAliases = loadTsconfigAliases(repoDir);
+  const symbolTable = createSymbolTable();
+  const importMap = createImportMap();
+  const importEdges: ImportEdge[] = [];
+
+  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);
+
+  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);
+    const resolvedRel = resolved ? relative(repoDir, resolved) : null;
+    importEdges.push({ source: imp.file, target: resolvedRel || imp.module, resolved: !!resolvedRel, line: imp.line });
+    const target = resolvedRel || imp.module;
+    for (const name of imp.names) importMap.add(imp.file, name, target);
+  }
+
+  const { callEdges } = resolveAllCalls(rawGraph.rawCalls, rawGraph.diMaps, symbolTable, importMap);
+
+  const fileHashes = new Map<string, string>();
+  for (const f of absFiles) {
+    try {
+      fileHashes.set(relative(repoDir, f), computeFileHash(f));
+    } catch {}
+  }
+
+  const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
+  process.stderr.write(`[3/4] Re-parsed ${absFiles.length} files (${newGraphData.nodes.length} nodes)\n`);
+
+  // Compute diff
+  const relChangedFiles = changedFiles.map((f) => (f.startsWith('/') ? relative(repoDir, f) : f));
+  const result = computeStructuralDiff(oldGraph, newGraphData.nodes, newGraphData.edges, relChangedFiles);
+  process.stderr.write(
+    `[4/4] Diff: +${result.summary.added} -${result.summary.removed} ~${result.summary.modified} nodes (${Math.round(performance.now() - t0)}ms)\n`,
+  );
+
+  writeFileSync(opts.out, JSON.stringify(result, null, 2));
+}

package/src/commands/flows.ts

@@ -0,0 +1,19 @@
+import { writeFileSync } from 'fs';
+import { detectFlows } from '../analysis/flows';
+import { loadGraph } from '../graph/loader';
+
+interface FlowsCommandOptions {
+  graph: string;
+  out: string;
+  maxDepth: number;
+  type: 'test' | 'http' | 'all';
+}
+
+export function executeFlows(opts: FlowsCommandOptions): void {
+  const graph = loadGraph(opts.graph);
+  const result = detectFlows(graph, { maxDepth: opts.maxDepth, type: opts.type });
+  writeFileSync(opts.out, JSON.stringify(result, null, 2));
+  process.stderr.write(
+    `Flows: ${result.summary.total_flows} detected (test:${result.summary.by_type.test} http:${result.summary.by_type.http}), avg depth ${result.summary.avg_depth}\n`,
+  );
+}

package/src/commands/parse.ts

@@ -0,0 +1,100 @@
+import { writeFileSync } from 'fs';
+import { relative, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { buildGraphData } from '../graph/builder';
+import type { ImportEdge, ParseOutput } from '../graph/types';
+import { parseBatch } from '../parser/batch';
+import { discoverFiles } from '../parser/discovery';
+import { resolveAllCalls } from '../resolver/call-resolver';
+import { createImportMap } from '../resolver/import-map';
+import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
+import { createSymbolTable } from '../resolver/symbol-table';
+import { computeFileHash } from '../shared/file-hash';
+import { log } from '../shared/logger';
+
+interface ParseOptions {
+  repoDir: string;
+  files?: string[];
+  all: boolean;
+  out: string;
+}
+
+export async function executeParse(opts: ParseOptions): Promise<void> {
+  const t0 = performance.now();
+  const repoDir = resolve(opts.repoDir);
+
+  // Phase 1: Discover files
+  const files = discoverFiles(repoDir, opts.all ? undefined : opts.files);
+  process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
+
+  // Phase 2: Parse + extract
+  const 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[] = [];
+
+  // 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);
+    const resolvedRel = resolved ? relative(repoDir, resolved) : null;
+    importEdges.push({
+      source: imp.file,
+      target: resolvedRel || imp.module,
+      resolved: !!resolvedRel,
+      line: imp.line,
+    });
+    const target = resolvedRel || imp.module;
+    for (const name of imp.names) importMap.add(imp.file, name, target);
+  }
+
+  process.stderr.write(
+    `[3/5] Resolved ${importEdges.filter((e) => e.resolved).length}/${importEdges.length} imports\n`,
+  );
+
+  // Phase 4: Resolve calls
+  const { 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`,
+  );
+
+  // Phase 5: Build output
+  const fileHashes = new Map<string, string>();
+  for (const f of files) {
+    try {
+      fileHashes.set(relative(repoDir, f), computeFileHash(f));
+    } catch (err) {
+      log.warn('Failed to compute file hash', { file: f, error: String(err) });
+    }
+  }
+
+  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,
+  };
+
+  writeFileSync(opts.out, JSON.stringify(output, null, 2));
+}