@optave/codegraph 3.8.0 → 3.8.1

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');

package/src/presentation/queries-cli/exports.ts

@@ -71,28 +71,36 @@ function printExportSymbols(results: ExportSymbol[]): void {
   }
 }
 
-function printReexportedSymbols(reexportedSymbols: ReexportedSymbol[]): void {
-  // Group by origin file
+function groupByOriginFile(reexportedSymbols: ReexportedSymbol[]): Map<string, ReexportedSymbol[]> {
   const byOrigin = new Map<string, ReexportedSymbol[]>();
   for (const sym of reexportedSymbols) {
     if (!byOrigin.has(sym.originFile)) byOrigin.set(sym.originFile, []);
     byOrigin.get(sym.originFile)!.push(sym);
   }
+  return byOrigin;
+}
+
+function printReexportSymbol(sym: ExportSymbol, indent: string): void {
+  const icon = kindIcon(sym.kind);
+  const sig = sym.signature?.params ? `(${sym.signature.params})` : '';
+  const role = sym.role ? ` [${sym.role}]` : '';
+  console.log(`${indent}${icon} ${sym.name}${sig}${role} :${sym.line}`);
+  if (sym.consumers.length === 0) {
+    console.log(`${indent}  (no consumers)`);
+  } else {
+    for (const c of sym.consumers) {
+      console.log(`${indent}  <- ${c.name} (${c.file}:${c.line})`);
+    }
+  }
+}
+
+function printReexportedSymbols(reexportedSymbols: ReexportedSymbol[]): void {
+  const byOrigin = groupByOriginFile(reexportedSymbols);
 
   for (const [originFile, syms] of byOrigin) {
     console.log(`\n  from ${originFile}:`);
     for (const sym of syms) {
-      const icon = kindIcon(sym.kind);
-      const sig = sym.signature?.params ? `(${sym.signature.params})` : '';
-      const role = sym.role ? ` [${sym.role}]` : '';
-      console.log(`    ${icon} ${sym.name}${sig}${role} :${sym.line}`);
-      if (sym.consumers.length === 0) {
-        console.log('      (no consumers)');
-      } else {
-        for (const c of sym.consumers) {
-          console.log(`      <- ${c.name} (${c.file}:${c.line})`);
-        }
-      }
+      printReexportSymbol(sym, '    ');
     }
   }
 }

package/src/presentation/queries-cli/impact.ts

@@ -228,6 +228,20 @@ export function impactAnalysis(file: string, customDbPath: string, opts: OutputO
   console.log(`\n  Total: ${data.totalDependents} files transitively depend on "${file}"\n`);
 }
 
+function printFnImpactLevels(levels: Record<string, SymbolRef[]>): void {
+  if (Object.keys(levels).length === 0) {
+    console.log(`  No callers found.`);
+    return;
+  }
+  for (const [level, fns] of Object.entries(levels).sort((a, b) => Number(a[0]) - Number(b[0]))) {
+    const l = parseInt(level, 10);
+    console.log(`  ${'--'.repeat(l)} Level ${level} (${fns.length} functions):`);
+    for (const f of fns.slice(0, 20))
+      console.log(`    ${'  '.repeat(l)}^ ${kindIcon(f.kind)} ${f.name}  ${f.file}:${f.line}`);
+    if (fns.length > 20) console.log(`    ... and ${fns.length - 20} more`);
+  }
+}
+
 export function fnImpact(name: string, customDbPath: string, opts: OutputOpts = {}): void {
   const data = fnImpactData(name, customDbPath, opts) as unknown as FnImpactData;
   if (outputResult(data as unknown as Record<string, unknown>, 'results', opts)) return;
@@ -239,19 +253,7 @@ export function fnImpact(name: string, customDbPath: string, opts: OutputOpts =
 
   for (const r of data.results) {
     console.log(`\nFunction impact: ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}\n`);
-    if (Object.keys(r.levels).length === 0) {
-      console.log(`  No callers found.`);
-    } else {
-      for (const [level, fns] of Object.entries(r.levels).sort(
-        (a, b) => Number(a[0]) - Number(b[0]),
-      )) {
-        const l = parseInt(level, 10);
-        console.log(`  ${'--'.repeat(l)} Level ${level} (${fns.length} functions):`);
-        for (const f of fns.slice(0, 20))
-          console.log(`    ${'  '.repeat(l)}^ ${kindIcon(f.kind)} ${f.name}  ${f.file}:${f.line}`);
-        if (fns.length > 20) console.log(`    ... and ${fns.length - 20} more`);
-      }
-    }
+    printFnImpactLevels(r.levels);
     console.log(`\n  Total: ${r.totalDependents} functions transitively depend on ${r.name}\n`);
   }
 }