@kodus/kodus-graph 0.2.8 → 0.2.10

package/src/commands/context.ts

@@ -1,182 +0,0 @@
-import { readFileSync, rmSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
-import { buildContextV2 } from '../analysis/context-builder';
-import { formatPrompt } from '../analysis/prompt-formatter';
-import { mergeGraphs } from '../graph/merger';
-import type { 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;
-  minConfidence: number;
-  maxDepth: number;
-  format: 'json' | 'prompt';
-}
-
-export async function executeContext(opts: ContextOptions): Promise<void> {
-  const repoDir = resolve(opts.repoDir);
-
-  log.info('context: starting', {
-    files: opts.files,
-    repoDir,
-    graph: opts.graph ?? null,
-    format: opts.format,
-    minConfidence: opts.minConfidence,
-    maxDepth: opts.maxDepth,
-  });
-
-  // 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'));
-
-    log.info('context: parse done', {
-      nodes: parseResult.nodes?.length ?? 0,
-      edges: parseResult.edges?.length ?? 0,
-    });
-
-    // Load and merge with main graph if provided
-    let mergedGraph: GraphData;
-    let oldGraph: GraphData | 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);
-      }
-      const changedSet = new Set(opts.files);
-      const sameBranch = detectSameBranch(validated.data.nodes, parseResult.nodes, changedSet);
-
-      log.info('context: baseline graph loaded', {
-        graphNodes: validated.data.nodes.length,
-        graphEdges: validated.data.edges.length,
-        sameBranch,
-      });
-
-      if (sameBranch) {
-        // --graph was built from the same commit (e.g. kodus-ai's parse --all on PR branch).
-        // Exclude changed files from oldGraph so diff detects their functions as "added"
-        // instead of falsely marking everything "unchanged".
-        oldGraph = {
-          nodes: validated.data.nodes.filter((n: { file_path: string }) => !changedSet.has(n.file_path)),
-          edges: validated.data.edges.filter((e: { file_path: string }) => !changedSet.has(e.file_path)),
-        };
-        log.debug('Same-branch detected: excluding changed files from baseline', {
-          changedFiles: opts.files.length,
-        });
-      } else {
-        oldGraph = { nodes: validated.data.nodes, edges: validated.data.edges };
-      }
-
-      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 V2 context
-    const output = buildContextV2({
-      mergedGraph,
-      oldGraph,
-      changedFiles: opts.files,
-      minConfidence: opts.minConfidence,
-      maxDepth: opts.maxDepth,
-    });
-
-    log.info('context: analysis done', {
-      changedFunctions: output.analysis.changed_functions.length,
-      diff: output.analysis.structural_diff.summary,
-      blastRadius: output.analysis.blast_radius.total_functions,
-      risk: `${output.analysis.risk.level} (${output.analysis.risk.score})`,
-      testGaps: output.analysis.test_gaps.length,
-      affectedFlows: output.analysis.affected_flows.length,
-      duration_ms: output.analysis.metadata.duration_ms,
-    });
-
-    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 });
-    } catch (err) {
-      log.debug('Failed to clean up temp dir', { dir: tmp.dir, error: String(err) });
-    }
-  }
-}
-
-/**
- * Detect if --graph was built from the same commit as the current repo.
- * Compares file_hash values for changed files between the graph and the fresh parse.
- * When hashes match, the graph can't serve as a baseline for diff — it IS the new state.
- */
-function detectSameBranch(
-  graphNodes: Array<{ file_path: string; file_hash: string }>,
-  parseNodes: Array<{ file_path: string; file_hash: string }>,
-  changedFiles: Set<string>,
-): boolean {
-  const graphHashes = new Map<string, string>();
-  for (const n of graphNodes) {
-    if (changedFiles.has(n.file_path) && n.file_hash && !graphHashes.has(n.file_path)) {
-      graphHashes.set(n.file_path, n.file_hash);
-    }
-  }
-
-  // No overlap means graph has no nodes for changed files — not same-branch scenario
-  if (graphHashes.size === 0) {
-    log.debug('detectSameBranch: no graph hashes for changed files');
-    return false;
-  }
-
-  const parseHashes = new Map<string, string>();
-  for (const n of parseNodes) {
-    if (n.file_hash && !parseHashes.has(n.file_path)) {
-      parseHashes.set(n.file_path, n.file_hash);
-    }
-  }
-
-  // If any overlapping file has different hash → different branch
-  for (const [file, hash] of graphHashes) {
-    const parseHash = parseHashes.get(file);
-    if (parseHash && parseHash !== hash) {
-      log.debug('detectSameBranch: hash mismatch → different branch', {
-        file,
-        graphHash: hash.substring(0, 8),
-        parseHash: parseHash.substring(0, 8),
-      });
-      return false;
-    }
-  }
-
-  log.debug('detectSameBranch: all hashes match → same branch', {
-    filesCompared: graphHashes.size,
-  });
-  return true;
-}

package/src/commands/diff.ts

@@ -1,96 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,124 +0,0 @@
-import { resolve, relative } from 'path';
-import { performance } from 'perf_hooks';
-import { buildGraphData } from '../graph/builder';
-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';
-import { createImportMap } from '../resolver/import-map';
-import { loadTsconfigAliases, resolveImport } from '../resolver/import-resolver';
-import { buildReExportMap } from '../resolver/re-export-resolver';
-import { createSymbolTable } from '../resolver/symbol-table';
-import { computeFileHash } from '../shared/file-hash';
-import { log } from '../shared/logger';
-
-export interface ParseOptions {
-  repoDir: string;
-  files?: string[];
-  all: boolean;
-  out: string;
-  include?: string[];
-  exclude?: 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, opts.include, opts.exclude);
-  process.stderr.write(`[1/5] Discovered ${files.length} files\n`);
-
-  // Phase 2: Parse + extract
-  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);
-  let symbolTable = createSymbolTable();
-  let importMap = createImportMap();
-  let 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);
-
-  // Pre-resolve re-exports so barrel imports follow through to actual definitions
-  const barrelMap = buildReExportMap(rawGraph.reExports, repoDir, tsconfigAliases);
-
-  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) {
-      // If target is a barrel file, follow re-exports to find the actual definition
-      let finalTarget = target;
-      if (resolvedRel) {
-        const reExportedFiles = barrelMap.get(resolvedRel);
-        if (reExportedFiles) {
-          for (const reFile of reExportedFiles) {
-            if (symbolTable.lookupExact(reFile, name)) {
-              finalTarget = reFile;
-              break;
-            }
-          }
-        }
-      }
-      importMap.add(imp.file, name, finalTarget);
-    }
-  }
-
-  process.stderr.write(
-    `[3/5] Resolved ${importEdges.filter((e) => e.resolved).length}/${importEdges.length} imports\n`,
-  );
-
-  // Phase 4: Resolve calls
-  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`,
-  );
-
-  // 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 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`);
-
-  // 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,
-  };
-
-  writeGraphJSON(opts.out, metadata, graphData.nodes, graphData.edges);
-}

package/src/commands/search.ts

@@ -1,41 +0,0 @@
-import { writeFileSync } from 'fs';
-import { findCallees, findCallers, searchNodes } from '../analysis/search';
-import { loadGraph } from '../graph/loader';
-import type { GraphNode } from '../graph/types';
-
-interface SearchCommandOptions {
-  graph: string;
-  query?: string;
-  kind?: string;
-  file?: string;
-  callersOf?: string;
-  calleesOf?: string;
-  limit: number;
-  out?: string;
-}
-
-export function executeSearch(opts: SearchCommandOptions): void {
-  const graph = loadGraph(opts.graph);
-
-  let results: GraphNode[];
-  let queryInfo: Record<string, string | null>;
-
-  if (opts.callersOf) {
-    results = findCallers(graph, opts.callersOf);
-    queryInfo = { callers_of: opts.callersOf, kind: null, file: null };
-  } else if (opts.calleesOf) {
-    results = findCallees(graph, opts.calleesOf);
-    queryInfo = { callees_of: opts.calleesOf, kind: null, file: null };
-  } else {
-    results = searchNodes(graph, { query: opts.query, kind: opts.kind, file: opts.file, limit: opts.limit });
-    queryInfo = { pattern: opts.query || null, kind: opts.kind || null, file: opts.file || null };
-  }
-
-  const output = JSON.stringify({ results, total: results.length, query: queryInfo }, null, 2);
-
-  if (opts.out) {
-    writeFileSync(opts.out, output);
-  } else {
-    process.stdout.write(`${output}\n`);
-  }
-}

package/src/commands/update.ts

@@ -1,166 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { dirname, relative, resolve } from 'path';
-import { performance } from 'perf_hooks';
-import { buildGraphData } from '../graph/builder';
-import { loadGraph } from '../graph/loader';
-import type { GraphEdge, GraphNode, 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';
-
-const DEFAULT_GRAPH_PATH = '.kodus-graph/graph.json';
-
-interface UpdateCommandOptions {
-  repoDir: string;
-  graph?: string;
-  out?: string;
-}
-
-export async function executeUpdate(opts: UpdateCommandOptions): Promise<void> {
-  const t0 = performance.now();
-  const repoDir = resolve(opts.repoDir);
-  const graphPath = resolve(repoDir, opts.graph || DEFAULT_GRAPH_PATH);
-  const outPath = resolve(repoDir, opts.out || opts.graph || DEFAULT_GRAPH_PATH);
-
-  if (!existsSync(graphPath)) {
-    process.stderr.write(`Error: graph file not found: ${graphPath}. Run "kodus-graph parse" first.\n`);
-    process.exit(1);
-  }
-
-  const oldGraph = loadGraph(graphPath);
-  process.stderr.write(`[1/5] Loaded previous graph (${oldGraph.nodes.length} nodes)\n`);
-
-  // Build file hash index from old graph
-  const oldHashes = new Map<string, string>();
-  for (const node of oldGraph.nodes) {
-    if (node.file_hash && !oldHashes.has(node.file_path)) {
-      oldHashes.set(node.file_path, node.file_hash);
-    }
-  }
-
-  // Discover current files
-  const allFiles = discoverFiles(repoDir);
-  const allRel = allFiles.map((f) => relative(repoDir, f));
-  const currentFiles = new Set(allRel);
-  const oldFiles = new Set(oldHashes.keys());
-
-  // Classify files
-  const added: string[] = [];
-  const modified: string[] = [];
-  const deleted: string[] = [];
-  const unchanged: string[] = [];
-
-  for (const file of currentFiles) {
-    const absPath = resolve(repoDir, file);
-    if (!oldHashes.has(file)) {
-      added.push(file);
-    } else {
-      const currentHash = computeFileHash(absPath);
-      if (currentHash !== oldHashes.get(file)) {
-        modified.push(file);
-      } else {
-        unchanged.push(file);
-      }
-    }
-  }
-
-  for (const file of oldFiles) {
-    if (!currentFiles.has(file)) deleted.push(file);
-  }
-
-  const toReparse = [...added, ...modified];
-  process.stderr.write(
-    `[2/5] Files: ${added.length} added, ${modified.length} modified, ${deleted.length} deleted, ${unchanged.length} unchanged\n`,
-  );
-
-  if (toReparse.length === 0 && deleted.length === 0) {
-    process.stderr.write('[3/5] No changes detected, graph is up to date\n');
-    const output: ParseOutput = {
-      metadata: {
-        ...oldGraph.metadata,
-        duration_ms: Math.round(performance.now() - t0),
-        files_unchanged: unchanged.length,
-        incremental: true,
-      },
-      nodes: oldGraph.nodes,
-      edges: oldGraph.edges,
-    };
-    ensureDir(outPath);
-    writeFileSync(outPath, JSON.stringify(output, null, 2));
-    return;
-  }
-
-  // Re-parse changed files
-  const absToReparse = toReparse.map((f) => resolve(repoDir, f));
-  const rawGraph = await parseBatch(absToReparse, repoDir);
-  process.stderr.write(`[3/5] Re-parsed ${toReparse.length} files\n`);
-
-  // Resolve imports and calls for new files
-  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 absToReparse) {
-    try {
-      fileHashes.set(relative(repoDir, f), computeFileHash(f));
-    } catch {}
-  }
-
-  const newGraphData = buildGraphData(rawGraph, callEdges, importEdges, repoDir, fileHashes);
-  process.stderr.write(`[4/5] Built new graph fragment (${newGraphData.nodes.length} nodes)\n`);
-
-  // Merge: keep old nodes/edges NOT in changed/deleted files, add new ones
-  const changedOrDeleted = new Set([...toReparse, ...deleted]);
-  const mergedNodes: GraphNode[] = oldGraph.nodes.filter((n) => !changedOrDeleted.has(n.file_path));
-  const mergedEdges: GraphEdge[] = oldGraph.edges.filter((e) => !changedOrDeleted.has(e.file_path));
-
-  mergedNodes.push(...newGraphData.nodes);
-  mergedEdges.push(...newGraphData.edges);
-
-  process.stderr.write(`[5/5] Merged: ${mergedNodes.length} nodes, ${mergedEdges.length} edges\n`);
-
-  const output: ParseOutput = {
-    metadata: {
-      repo_dir: repoDir,
-      files_parsed: toReparse.length,
-      files_unchanged: unchanged.length,
-      total_nodes: mergedNodes.length,
-      total_edges: mergedEdges.length,
-      duration_ms: Math.round(performance.now() - t0),
-      parse_errors: rawGraph.parseErrors,
-      extract_errors: rawGraph.extractErrors,
-      incremental: true,
-    },
-    nodes: mergedNodes,
-    edges: mergedEdges,
-  };
-
-  ensureDir(outPath);
-  writeFileSync(outPath, JSON.stringify(output, null, 2));
-}
-
-function ensureDir(filePath: string): void {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-}