@optave/codegraph 3.7.0 → 3.8.1

package/src/graph/algorithms/louvain.ts

@@ -1,11 +1,13 @@
 /**
- * Community detection via vendored Leiden algorithm.
+ * Community detection via native Rust Louvain or vendored Leiden algorithm.
  * Maintains backward-compatible API: { assignments: Map<string, number>, modularity: number }
  *
- * Note: Always runs in undirected mode (`directed: false`) regardless of
- * the input graph's directedness. For direction-aware community detection,
- * use `detectClusters` from `./leiden/index.js` directly.
+ * Native path: classic Louvain (Rust, undirected modularity optimization).
+ * JS fallback: Leiden algorithm via `detectClusters` (always undirected, `directed: false`).
  */
+
+import { warn } from '../../infrastructure/logger.js';
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 import type { DetectClustersResult } from './leiden/index.js';
 import { detectClusters } from './leiden/index.js';
@@ -28,6 +30,31 @@ export function louvainCommunities(graph: CodeGraph, opts: LouvainOptions = {}):
   }
 
   const resolution: number = opts.resolution ?? 1.0;
+
+  const native = loadNative();
+  if (native?.louvainCommunities) {
+    // maxLevels, maxLocalPasses, and refinementTheta are Leiden-specific tuning knobs
+    // not supported by the Rust Louvain implementation. Warn callers who set them.
+    if (opts.maxLevels != null || opts.maxLocalPasses != null || opts.refinementTheta != null) {
+      warn(
+        'louvainCommunities: maxLevels/maxLocalPasses/refinementTheta are ignored by the native Rust path',
+      );
+    }
+    const edges = graph.toEdgeArray();
+    const nodeIds = graph.nodeIds();
+    const result = native.louvainCommunities(edges, nodeIds, resolution, 42);
+    const assignments = new Map<string, number>();
+    for (const entry of result.assignments) {
+      assignments.set(entry.node, entry.community);
+    }
+    return { assignments, modularity: result.modularity };
+  }
+
+  return louvainJS(graph, opts, resolution);
+}
+
+/** JS fallback using the vendored Leiden algorithm. */
+function louvainJS(graph: CodeGraph, opts: LouvainOptions, resolution: number): LouvainResult {
   const result: DetectClustersResult = detectClusters(graph, {
     resolution,
     randomSeed: 42,

package/src/graph/algorithms/shortest-path.ts

@@ -1,8 +1,11 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 /**
  * BFS-based shortest path on a CodeGraph.
  *
+ * Tries the native Rust implementation first, falls back to JS.
+ *
  * @returns Path from fromId to toId (inclusive), or null if unreachable
  */
 export function shortestPath(graph: CodeGraph, fromId: string, toId: string): string[] | null {
@@ -12,6 +15,23 @@ export function shortestPath(graph: CodeGraph, fromId: string, toId: string): st
   if (!graph.hasNode(from) || !graph.hasNode(to)) return null;
   if (from === to) return [from];
 
+  const native = loadNative();
+  if (native?.shortestPath) {
+    let edges = graph.toEdgeArray();
+    if (!graph.directed) {
+      // Undirected: toEdgeArray() deduplicates to one canonical direction;
+      // mirror each edge so the Rust BFS can traverse in both directions.
+      edges = [...edges, ...edges.map((e) => ({ source: e.target, target: e.source }))];
+    }
+    const result = native.shortestPath(edges, from, to);
+    return result.length > 0 ? result : null;
+  }
+
+  return shortestPathJS(graph, from, to);
+}
+
+/** Pure JS fallback for shortest path. */
+function shortestPathJS(graph: CodeGraph, from: string, to: string): string[] | null {
   const parent = new Map<string, string | null>();
   parent.set(from, null);
   const queue = [from];
@@ -23,7 +43,6 @@ export function shortestPath(graph: CodeGraph, fromId: string, toId: string): st
       if (parent.has(neighbor)) continue;
       parent.set(neighbor, current);
       if (neighbor === to) {
-        // Reconstruct path
         const path: string[] = [];
         let node: string | null = to;
         while (node !== null) {

package/src/graph/model.ts

@@ -17,6 +17,11 @@ export interface CodeGraphOpts {
   directed?: boolean;
 }
 
+/** Canonical key for an undirected edge — smallest ID first, null-byte separated. */
+function undirectedEdgeKey(a: string, b: string): string {
+  return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+
 export class CodeGraph {
   private _directed: boolean;
   private _nodes: Map<string, NodeAttrs>;
@@ -121,7 +126,7 @@ export class CodeGraph {
     const seen = new Set<string>();
     for (const [src, targets] of this._successors) {
       for (const [tgt, attrs] of targets) {
-        const key = src < tgt ? `${src}\0${tgt}` : `${tgt}\0${src}`;
+        const key = undirectedEdgeKey(src, tgt);
         if (seen.has(key)) continue;
         seen.add(key);
         yield [src, tgt, attrs];

package/src/infrastructure/config.ts

@@ -178,7 +178,7 @@ export function loadConfig(cwd?: string): CodegraphConfig {
         _configCache.set(cwd, structuredClone(result));
         return result;
       } catch (err: unknown) {
-        debug(`Failed to parse config ${filePath}: ${(err as Error).message}`);
+        debug(`Failed to parse config ${filePath}: ${toErrorMessage(err)}`);
       }
     }
   }
@@ -229,7 +229,7 @@ export function resolveSecrets(config: CodegraphConfig): CodegraphConfig {
       (config.llm as Record<string, unknown>).apiKey = result;
     }
   } catch (err: unknown) {
-    warn(`apiKeyCommand failed: ${(err as Error).message}`);
+    warn(`apiKeyCommand failed: ${toErrorMessage(err)}`);
   }
   return config;
 }
@@ -252,7 +252,8 @@ function expandWorkspaceGlob(pattern: string, rootDir: string): string[] {
       .filter((e) => e.isDirectory())
       .map((e) => path.join(baseDir, e.name))
       .filter((d) => fs.existsSync(path.join(d, 'package.json')));
-  } catch {
+  } catch (e) {
+    debug(`expandGlobDirs: failed to read ${baseDir}: ${toErrorMessage(e)}`);
     return [];
   }
 }
@@ -265,7 +266,8 @@ function readPackageName(pkgDir: string): string | null {
     const raw = fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf-8');
     const pkg = JSON.parse(raw);
     return pkg.name || null;
-  } catch {
+  } catch (e) {
+    debug(`readPackageName: failed for ${pkgDir}: ${toErrorMessage(e)}`);
     return null;
   }
 }

package/src/infrastructure/suppress.ts

@@ -0,0 +1,47 @@
+/**
+ * Catch-suppression helpers for intentional error swallowing.
+ *
+ * Lives in `infrastructure/` (not `shared/`) because it depends on the
+ * structured logger — keeping `shared/errors.ts` dependency-free.
+ */
+
+import { toErrorMessage } from '../shared/errors.js';
+import { debug } from './logger.js';
+
+/**
+ * Run `fn` and return its result. If it throws, log a debug message and
+ * return `fallback` instead. Use this for intentional catch suppression
+ * where the error is expected and non-fatal (e.g. optional file reads,
+ * graceful feature probes, cleanup that may fail).
+ *
+ * @example
+ *   const version = suppressError(() => readPkgVersion(), 'read package version', '');
+ */
+export function suppressError<T>(fn: () => T, context: string, fallback: T): T {
+  try {
+    return fn();
+  } catch (e: unknown) {
+    debug(`${context}: ${toErrorMessage(e)}`);
+    return fallback;
+  }
+}
+
+/**
+ * Async variant of {@link suppressError}. Awaits `fn()` and returns `fallback`
+ * on rejection, logging the error via `debug()`.
+ *
+ * @example
+ *   const data = await suppressErrorAsync(() => fetchOptionalData(), 'fetch data', null);
+ */
+export async function suppressErrorAsync<T>(
+  fn: () => Promise<T>,
+  context: string,
+  fallback: T,
+): Promise<T> {
+  try {
+    return await fn();
+  } catch (e: unknown) {
+    debug(`${context}: ${toErrorMessage(e)}`);
+    return fallback;
+  }
+}

package/src/mcp/server.ts

@@ -13,7 +13,8 @@ const { version: PKG_VERSION } = require('../../package.json') as { version: str
 import { getDatabase } from '../db/better-sqlite3.js';
 import { findDbPath } from '../db/index.js';
 import { loadConfig } from '../infrastructure/config.js';
-import { CodegraphError, ConfigError } from '../shared/errors.js';
+import { debug } from '../infrastructure/logger.js';
+import { CodegraphError, ConfigError, toErrorMessage } from '../shared/errors.js';
 import { MCP_MAX_LIMIT } from '../shared/paginate.js';
 import type { CodegraphConfig, MCPServerOptions } from '../types.js';
 import { initMcpDefaults } from './middleware.js';
@@ -56,7 +57,8 @@ async function loadMCPSdk(): Promise<{
       ListToolsRequestSchema: types.ListToolsRequestSchema,
       CallToolRequestSchema: types.CallToolRequestSchema,
     };
-  } catch {
+  } catch (e) {
+    debug(`MCP SDK import failed: ${toErrorMessage(e)}`);
     throw new ConfigError(
       'MCP server requires @modelcontextprotocol/sdk.\nInstall it with: npm install @modelcontextprotocol/sdk',
     );
@@ -123,8 +125,10 @@ function registerShutdownHandlers(): void {
   const shutdown = async () => {
     try {
       await _activeServer?.close();
-    } catch (_shutdownErr: unknown) {
-      // Ignore close errors during shutdown — the transport may already be gone.
+    } catch (shutdownErr: unknown) {
+      debug(
+        `MCP shutdown close failed (transport may already be gone): ${toErrorMessage(shutdownErr)}`,
+      );
     }
     process.exit(0);
   };
@@ -154,36 +158,13 @@ function registerShutdownHandlers(): void {
   process.on('unhandledRejection', silentReject);
 }
 
-export async function startMCPServer(
-  customDbPath?: string,
-  options: MCPServerOptionsInternal = {},
-): Promise<void> {
-  const { allowedRepos } = options;
-  const multiRepo = options.multiRepo || !!allowedRepos;
-
-  // Apply config-based MCP page-size overrides
-  const config = options.config || loadConfig();
-  initMcpDefaults(config.mcp?.defaults ? { ...config.mcp.defaults } : undefined);
-
-  const { Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema } =
-    await loadMCPSdk();
-
-  // Connect transport FIRST so the server can receive the client's
-  // `initialize` request while heavy modules (queries, better-sqlite3)
-  // are still loading.  These are lazy-loaded on the first tool call
-  // and cached for subsequent calls.
-  const { getQueries } = createLazyLoaders();
-
-  const server = new (Server as any)(
-    { name: 'codegraph', version: PKG_VERSION },
-    { capabilities: { tools: {} } },
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: buildToolList(multiRepo),
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
+function createCallToolHandler(
+  multiRepo: boolean,
+  customDbPath: string | undefined,
+  allowedRepos: string[] | undefined,
+  getQueries: () => Promise<unknown>,
+) {
+  return async (request: any) => {
     const { name, arguments: args } = request.params;
     try {
       validateMultiRepoAccess(multiRepo, name, args);
@@ -212,10 +193,45 @@ export async function startMCPServer(
       const text =
         err instanceof CodegraphError
           ? `[${code}] ${err.message}`
-          : `Error: ${(err as Error).message}`;
+          : `Error: ${toErrorMessage(err)}`;
       return { content: [{ type: 'text', text }], isError: true };
     }
-  });
+  };
+}
+
+export async function startMCPServer(
+  customDbPath?: string,
+  options: MCPServerOptionsInternal = {},
+): Promise<void> {
+  const { allowedRepos } = options;
+  const multiRepo = options.multiRepo || !!allowedRepos;
+
+  // Apply config-based MCP page-size overrides
+  const config = options.config || loadConfig();
+  initMcpDefaults(config.mcp?.defaults ? { ...config.mcp.defaults } : undefined);
+
+  const { Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema } =
+    await loadMCPSdk();
+
+  // Connect transport FIRST so the server can receive the client's
+  // `initialize` request while heavy modules (queries, better-sqlite3)
+  // are still loading.  These are lazy-loaded on the first tool call
+  // and cached for subsequent calls.
+  const { getQueries } = createLazyLoaders();
+
+  const server = new (Server as any)(
+    { name: 'codegraph', version: PKG_VERSION },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: buildToolList(multiRepo),
+  }));
+
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    createCallToolHandler(multiRepo, customDbPath, allowedRepos, getQueries),
+  );
 
   const transport = new (StdioServerTransport as any)();
 
@@ -235,7 +251,7 @@ export async function startMCPServer(
       process.exit(0);
     }
     process.stderr.write(
-      `MCP transport connect failed: ${(err as Error).stack ?? (err as Error).message}\n`,
+      `MCP transport connect failed: ${err instanceof Error ? (err.stack ?? err.message) : toErrorMessage(err)}\n`,
     );
     process.exit(1);
   }

package/src/presentation/dataflow.ts

@@ -58,6 +58,53 @@ interface DataflowImpactEntry {
   levels: Record<string, Array<{ name: string; file: string; line: number }>>;
 }
 
+function printDataflowFlows(r: DataflowResultEntry): void {
+  if (r.flowsTo.length > 0) {
+    console.log('\n  Data flows TO:');
+    for (const f of r.flowsTo) {
+      const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
+      console.log(`    \u2192 ${f.target} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
+    }
+  }
+  if (r.flowsFrom.length > 0) {
+    console.log('\n  Data flows FROM:');
+    for (const f of r.flowsFrom) {
+      const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
+      console.log(`    \u2190 ${f.source} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
+    }
+  }
+}
+
+function printDataflowReturns(r: DataflowResultEntry): void {
+  if (r.returns.length > 0) {
+    console.log('\n  Return value consumed by:');
+    for (const c of r.returns) {
+      console.log(`    \u2192 ${c.consumer} (${c.file}:${c.line})  ${c.expression}`);
+    }
+  }
+  if (r.returnedBy.length > 0) {
+    console.log('\n  Uses return value of:');
+    for (const p of r.returnedBy) {
+      console.log(`    \u2190 ${p.producer} (${p.file}:${p.line})  ${p.expression}`);
+    }
+  }
+}
+
+function printDataflowMutations(r: DataflowResultEntry): void {
+  if (r.mutates.length > 0) {
+    console.log('\n  Mutates:');
+    for (const m of r.mutates) {
+      console.log(`    \u270E ${m.expression}  (line ${m.line})`);
+    }
+  }
+  if (r.mutatedBy.length > 0) {
+    console.log('\n  Mutated by:');
+    for (const m of r.mutatedBy) {
+      console.log(`    \u270E ${m.source} \u2014 ${m.expression}  (line ${m.line})`);
+    }
+  }
+}
+
 export function dataflow(
   name: string,
   customDbPath: string | undefined,
@@ -87,50 +134,9 @@ export function dataflow(
   for (const r of data.results) {
     console.log(`\n${r.kind} ${r.name}  (${r.file}:${r.line})`);
     console.log('\u2500'.repeat(60));
-
-    if (r.flowsTo.length > 0) {
-      console.log('\n  Data flows TO:');
-      for (const f of r.flowsTo) {
-        const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
-        console.log(`    \u2192 ${f.target} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
-      }
-    }
-
-    if (r.flowsFrom.length > 0) {
-      console.log('\n  Data flows FROM:');
-      for (const f of r.flowsFrom) {
-        const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
-        console.log(`    \u2190 ${f.source} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
-      }
-    }
-
-    if (r.returns.length > 0) {
-      console.log('\n  Return value consumed by:');
-      for (const c of r.returns) {
-        console.log(`    \u2192 ${c.consumer} (${c.file}:${c.line})  ${c.expression}`);
-      }
-    }
-
-    if (r.returnedBy.length > 0) {
-      console.log('\n  Uses return value of:');
-      for (const p of r.returnedBy) {
-        console.log(`    \u2190 ${p.producer} (${p.file}:${p.line})  ${p.expression}`);
-      }
-    }
-
-    if (r.mutates.length > 0) {
-      console.log('\n  Mutates:');
-      for (const m of r.mutates) {
-        console.log(`    \u270E ${m.expression}  (line ${m.line})`);
-      }
-    }
-
-    if (r.mutatedBy.length > 0) {
-      console.log('\n  Mutated by:');
-      for (const m of r.mutatedBy) {
-        console.log(`    \u270E ${m.source} \u2014 ${m.expression}  (line ${m.line})`);
-      }
-    }
+    printDataflowFlows(r);
+    printDataflowReturns(r);
+    printDataflowMutations(r);
   }
 }
 

package/src/presentation/diff-impact-mermaid.ts

@@ -1,56 +1,48 @@
 import { diffImpactData } from '../domain/analysis/diff-impact.js';
 
-export function diffImpactMermaid(
-  customDbPath: string,
-  opts: {
-    noTests?: boolean;
-    depth?: number;
-    staged?: boolean;
-    ref?: string;
-    includeImplementors?: boolean;
-    limit?: number;
-    offset?: number;
-    config?: any;
-  } = {},
-): string {
-  const data: any = diffImpactData(customDbPath, opts);
-  if ('error' in data) return data.error as string;
-  if (data.changedFiles === 0 || data.affectedFunctions.length === 0) {
-    return 'flowchart TB\n    none["No impacted functions detected"]';
-  }
+interface MermaidNodeRegistry {
+  nodeIdMap: Map<string, string>;
+  nodeLabels: Map<string, string>;
+  counter: number;
+}
 
-  const newFileSet = new Set(data.newFiles || []);
-  const lines = ['flowchart TB'];
+interface ImpactEdgeSets {
+  allEdges: Set<string>;
+  edgeFromNodes: Set<string>;
+  edgeToNodes: Set<string>;
+  changedKeys: Set<string>;
+}
 
-  // Assign stable Mermaid node IDs
-  let nodeCounter = 0;
-  const nodeIdMap = new Map<string, string>();
-  const nodeLabels = new Map<string, string>();
-  function nodeId(key: string, label?: string): string {
-    if (!nodeIdMap.has(key)) {
-      nodeIdMap.set(key, `n${nodeCounter++}`);
-      if (label) nodeLabels.set(key, label);
-    }
-    return nodeIdMap.get(key)!;
+function createNodeRegistry(): MermaidNodeRegistry {
+  return { nodeIdMap: new Map(), nodeLabels: new Map(), counter: 0 };
+}
+
+function registerNode(reg: MermaidNodeRegistry, key: string, label?: string): string {
+  if (!reg.nodeIdMap.has(key)) {
+    reg.nodeIdMap.set(key, `n${reg.counter++}`);
+    if (label) reg.nodeLabels.set(key, label);
   }
+  return reg.nodeIdMap.get(key)!;
+}
 
-  // Register all nodes (changed functions + their callers)
-  for (const fn of data.affectedFunctions) {
-    nodeId(`${fn.file}::${fn.name}:${fn.line}`, fn.name);
+function registerAllNodes(reg: MermaidNodeRegistry, affectedFunctions: any[]): void {
+  for (const fn of affectedFunctions) {
+    registerNode(reg, `${fn.file}::${fn.name}:${fn.line}`, fn.name);
     for (const callers of Object.values(fn.levels || {})) {
       for (const c of callers as Array<{ name: string; file: string; line: number }>) {
-        nodeId(`${c.file}::${c.name}:${c.line}`, c.name);
+        registerNode(reg, `${c.file}::${c.name}:${c.line}`, c.name);
       }
     }
   }
+}
 
-  // Collect all edges and determine blast radius
+function collectEdges(affectedFunctions: any[]): ImpactEdgeSets {
   const allEdges = new Set<string>();
   const edgeFromNodes = new Set<string>();
   const edgeToNodes = new Set<string>();
   const changedKeys = new Set<string>();
 
-  for (const fn of data.affectedFunctions) {
+  for (const fn of affectedFunctions) {
     changedKeys.add(`${fn.file}::${fn.name}:${fn.line}`);
     for (const edge of fn.edges || []) {
       const edgeKey = `${edge.from}|${edge.to}`;
@@ -62,30 +54,42 @@ export function diffImpactMermaid(
     }
   }
 
-  // Blast radius: caller nodes that are never a source (leaf nodes of the impact tree)
+  return { allEdges, edgeFromNodes, edgeToNodes, changedKeys };
+}
+
+function classifyCallerNodes(edges: ImpactEdgeSets): {
+  blastRadiusKeys: Set<string>;
+  intermediateKeys: Set<string>;
+} {
   const blastRadiusKeys = new Set<string>();
-  for (const key of edgeToNodes) {
-    if (!edgeFromNodes.has(key) && !changedKeys.has(key)) {
+  for (const key of edges.edgeToNodes) {
+    if (!edges.edgeFromNodes.has(key) && !edges.changedKeys.has(key)) {
       blastRadiusKeys.add(key);
     }
   }
 
-  // Intermediate callers: not changed, not blast radius
   const intermediateKeys = new Set<string>();
-  for (const key of edgeToNodes) {
-    if (!changedKeys.has(key) && !blastRadiusKeys.has(key)) {
+  for (const key of edges.edgeToNodes) {
+    if (!edges.changedKeys.has(key) && !blastRadiusKeys.has(key)) {
       intermediateKeys.add(key);
     }
   }
 
-  // Group changed functions by file
-  const fileGroups = new Map<string, typeof data.affectedFunctions>();
-  for (const fn of data.affectedFunctions) {
+  return { blastRadiusKeys, intermediateKeys };
+}
+
+function emitFileSubgraphs(
+  lines: string[],
+  affectedFunctions: any[],
+  newFileSet: Set<string>,
+  reg: MermaidNodeRegistry,
+): number {
+  const fileGroups = new Map<string, any[]>();
+  for (const fn of affectedFunctions) {
     if (!fileGroups.has(fn.file)) fileGroups.set(fn.file, []);
     fileGroups.get(fn.file)!.push(fn);
   }
 
-  // Emit changed-file subgraphs
   let sgCounter = 0;
   for (const [file, fns] of fileGroups) {
     const isNew = newFileSet.has(file);
@@ -94,33 +98,71 @@ export function diffImpactMermaid(
     lines.push(`    subgraph ${sgId}["${file} **(${tag})**"]`);
     for (const fn of fns) {
       const key = `${fn.file}::${fn.name}:${fn.line}`;
-      lines.push(`        ${nodeIdMap.get(key)}["${fn.name}"]`);
+      lines.push(`        ${reg.nodeIdMap.get(key)}["${fn.name}"]`);
     }
     lines.push('    end');
     const style = isNew ? 'fill:#e8f5e9,stroke:#4caf50' : 'fill:#fff3e0,stroke:#ff9800';
     lines.push(`    style ${sgId} ${style}`);
   }
 
-  // Emit intermediate caller nodes (outside subgraphs)
-  for (const key of intermediateKeys) {
-    lines.push(`    ${nodeIdMap.get(key)}["${nodeLabels.get(key)}"]`);
+  return sgCounter;
+}
+
+function emitBlastRadiusSubgraph(
+  lines: string[],
+  blastRadiusKeys: Set<string>,
+  reg: MermaidNodeRegistry,
+  sgCounter: number,
+): void {
+  if (blastRadiusKeys.size === 0) return;
+  const sgId = `sg${sgCounter}`;
+  lines.push(`    subgraph ${sgId}["Callers **(blast radius)**"]`);
+  for (const key of blastRadiusKeys) {
+    lines.push(`        ${reg.nodeIdMap.get(key)}["${reg.nodeLabels.get(key)}"]`);
   }
+  lines.push('    end');
+  lines.push(`    style ${sgId} fill:#f3e5f5,stroke:#9c27b0`);
+}
 
-  // Emit blast radius subgraph
-  if (blastRadiusKeys.size > 0) {
-    const sgId = `sg${sgCounter++}`;
-    lines.push(`    subgraph ${sgId}["Callers **(blast radius)**"]`);
-    for (const key of blastRadiusKeys) {
-      lines.push(`        ${nodeIdMap.get(key)}["${nodeLabels.get(key)}"]`);
-    }
-    lines.push('    end');
-    lines.push(`    style ${sgId} fill:#f3e5f5,stroke:#9c27b0`);
+export function diffImpactMermaid(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    depth?: number;
+    staged?: boolean;
+    ref?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    config?: any;
+  } = {},
+): string {
+  const data: any = diffImpactData(customDbPath, opts);
+  if ('error' in data) return data.error as string;
+  if (data.changedFiles === 0 || data.affectedFunctions.length === 0) {
+    return 'flowchart TB\n    none["No impacted functions detected"]';
   }
 
-  // Emit edges (impact flows from changed fn toward callers)
-  for (const edgeKey of allEdges) {
+  const newFileSet = new Set<string>(data.newFiles || []);
+  const lines = ['flowchart TB'];
+
+  const reg = createNodeRegistry();
+  registerAllNodes(reg, data.affectedFunctions);
+
+  const edges = collectEdges(data.affectedFunctions);
+  const { blastRadiusKeys, intermediateKeys } = classifyCallerNodes(edges);
+
+  const sgCounter = emitFileSubgraphs(lines, data.affectedFunctions, newFileSet, reg);
+
+  for (const key of intermediateKeys) {
+    lines.push(`    ${reg.nodeIdMap.get(key)}["${reg.nodeLabels.get(key)}"]`);
+  }
+
+  emitBlastRadiusSubgraph(lines, blastRadiusKeys, reg, sgCounter);
+
+  for (const edgeKey of edges.allEdges) {
     const [from, to] = edgeKey.split('|') as [string, string];
-    lines.push(`    ${nodeIdMap.get(from)} --> ${nodeIdMap.get(to)}`);
+    lines.push(`    ${reg.nodeIdMap.get(from)} --> ${reg.nodeIdMap.get(to)}`);
   }
 
   return lines.join('\n');