@optave/codegraph 3.7.0 → 3.8.1

package/src/features/ast.ts

@@ -12,10 +12,9 @@ import type { ASTNodeKind, BetterSqlite3Database, Definition, TreeSitterNode } f
 
 // ─── Constants ────────────────────────────────────────────────────────
 
-export const AST_NODE_KINDS: ASTNodeKind[] = ['call', 'new', 'string', 'regex', 'throw', 'await'];
+export const AST_NODE_KINDS: ASTNodeKind[] = ['new', 'string', 'regex', 'throw', 'await'];
 
 const KIND_ICONS: Record<string, string> = {
-  call: '\u0192', // ƒ
   new: '\u2295', // ⊕
   string: '"',
   regex: '/',
@@ -59,38 +58,11 @@ function findParentDef(defs: Definition[], line: number): Definition | null {
   return best;
 }
 
-// ─── Build ────────────────────────────────────────────────────────────
+// ─── Build helpers ───────────────────────────────────────────────────
 
-export async function buildAstNodes(
-  db: BetterSqlite3Database,
-  fileSymbols: Map<string, FileSymbols>,
-  _rootDir: string,
-  engineOpts?: {
-    nativeDb?: {
-      bulkInsertAstNodes(
-        batches: Array<{
-          file: string;
-          nodes: Array<{
-            line: number;
-            kind: string;
-            name: string;
-            text?: string | null;
-            receiver?: string | null;
-          }>;
-        }>,
-      ): number;
-    };
-    suspendJsDb?: () => void;
-    resumeJsDb?: () => void;
-  },
-): Promise<void> {
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  // Uses NativeDatabase persistent connection (Phase 6.15+).
-  // Standalone napi functions were removed in 6.17.
-  const nativeDb = engineOpts?.nativeDb;
-  if (nativeDb?.bulkInsertAstNodes) {
-    let needsJsFallback = false;
-    const batches: Array<{
+interface NativeDbHandle {
+  bulkInsertAstNodes(
+    batches: Array<{
       file: string;
       nodes: Array<{
         line: number;
@@ -99,47 +71,127 @@ export async function buildAstNodes(
         text?: string | null;
         receiver?: string | null;
       }>;
-    }> = [];
-
-    for (const [relPath, symbols] of fileSymbols) {
-      if (Array.isArray(symbols.astNodes)) {
-        batches.push({
-          file: relPath,
-          nodes: symbols.astNodes.map((n) => ({
-            line: n.line,
-            kind: n.kind,
-            name: n.name,
-            text: n.text,
-            receiver: n.receiver ?? '',
-          })),
-        });
-      } else if (symbols.calls || symbols._tree) {
-        needsJsFallback = true;
-        break;
-      }
-    }
+    }>,
+  ): number;
+}
 
-    if (!needsJsFallback) {
-      const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
-      let inserted: number;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertAstNodes(batches);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      if (inserted === expectedNodes) {
-        debug(`AST extraction (native bulk): ${inserted} nodes stored`);
-        return;
-      }
-      debug(
-        `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
-      );
-      // fall through to JS path
+interface EngineOpts {
+  nativeDb?: NativeDbHandle;
+  suspendJsDb?: () => void;
+  resumeJsDb?: () => void;
+}
+
+/**
+ * Attempt native bulk-insert of AST nodes.
+ * Returns `true` if all nodes were inserted natively, `false` if JS fallback is needed.
+ */
+function tryNativeBulkInsert(
+  fileSymbols: Map<string, FileSymbols>,
+  engineOpts: EngineOpts | undefined,
+): boolean {
+  const nativeDb = engineOpts?.nativeDb;
+  if (!nativeDb?.bulkInsertAstNodes) return false;
+
+  const batches: Array<{
+    file: string;
+    nodes: Array<{
+      line: number;
+      kind: string;
+      name: string;
+      text?: string | null;
+      receiver?: string | null;
+    }>;
+  }> = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (Array.isArray(symbols.astNodes)) {
+      batches.push({
+        file: relPath,
+        nodes: symbols.astNodes.map((n) => ({
+          line: n.line,
+          kind: n.kind,
+          name: n.name,
+          text: n.text,
+          receiver: n.receiver ?? '',
+        })),
+      });
+    } else if (symbols.calls || symbols._tree) {
+      return false; // needs JS fallback
     }
   }
 
-  // ── JS fallback path ──────────────────────────────────────────────────
+  const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
+  let inserted: number;
+  try {
+    engineOpts?.suspendJsDb?.();
+    inserted = nativeDb.bulkInsertAstNodes(batches);
+  } finally {
+    engineOpts?.resumeJsDb?.();
+  }
+
+  if (inserted === expectedNodes) {
+    debug(`AST extraction (native bulk): ${inserted} nodes stored`);
+    return true;
+  }
+  debug(
+    `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
+  );
+  return false;
+}
+
+/** Collect AST rows for a single file, resolving parent node IDs. */
+function collectFileAstRows(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: FileSymbols,
+): AstRow[] {
+  const defs = symbols.definitions || [];
+  const nodeIdMap = new Map<string, number>();
+  for (const row of bulkNodeIdsByFile(db, relPath)) {
+    nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+  }
+
+  if (Array.isArray(symbols.astNodes)) {
+    return symbols.astNodes.map((n) => {
+      const parentDef = findParentDef(defs, n.line);
+      const parentNodeId = parentDef
+        ? nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null
+        : null;
+      return {
+        file: relPath,
+        line: n.line,
+        kind: n.kind,
+        name: n.name,
+        text: n.text || null,
+        receiver: n.receiver || null,
+        parentNodeId,
+      };
+    });
+  }
+
+  // WASM fallback — walk tree if available
+  const ext = path.extname(relPath).toLowerCase();
+  if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
+    const rows: AstRow[] = [];
+    walkAst(symbols._tree.rootNode, defs, relPath, rows, nodeIdMap);
+    return rows;
+  }
+
+  return [];
+}
+
+// ─── Build ────────────────────────────────────────────────────────────
+
+export async function buildAstNodes(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  _rootDir: string,
+  engineOpts?: EngineOpts,
+): Promise<void> {
+  // Native bulk-insert fast path (Phase 6.15+)
+  if (tryNativeBulkInsert(fileSymbols, engineOpts)) return;
+
+  // JS fallback path
   let insertStmt: ReturnType<BetterSqlite3Database['prepare']>;
   try {
     insertStmt = db.prepare(
@@ -157,43 +209,8 @@ export async function buildAstNodes(
   });
 
   const allRows: AstRow[] = [];
-
   for (const [relPath, symbols] of fileSymbols) {
-    const defs = symbols.definitions || [];
-
-    const nodeIdMap = new Map<string, number>();
-    for (const row of bulkNodeIdsByFile(db, relPath)) {
-      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-    }
-
-    if (Array.isArray(symbols.astNodes)) {
-      // Native engine provided AST nodes (may be empty for files with no AST content)
-      for (const n of symbols.astNodes) {
-        const parentDef = findParentDef(defs, n.line);
-        let parentNodeId: number | null = null;
-        if (parentDef) {
-          parentNodeId =
-            nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
-        }
-        allRows.push({
-          file: relPath,
-          line: n.line,
-          kind: n.kind,
-          name: n.name,
-          text: n.text || null,
-          receiver: n.receiver || null,
-          parentNodeId,
-        });
-      }
-    } else {
-      // WASM fallback — walk tree if available
-      const ext = path.extname(relPath).toLowerCase();
-      if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
-        const astRows: AstRow[] = [];
-        walkAst(symbols._tree.rootNode, defs, relPath, astRows, nodeIdMap);
-        allRows.push(...astRows);
-      }
-    }
+    allRows.push(...collectFileAstRows(db, relPath, symbols));
   }
 
   if (allRows.length > 0) {
@@ -351,23 +368,25 @@ export function astQuery(
   if (outputResult(data, 'results', opts)) return;
 
   if (data.results.length === 0) {
-    console.log(`No AST nodes found${pattern ? ` matching "${pattern}"` : ''}.`);
+    process.stdout.write(`No AST nodes found${pattern ? ` matching "${pattern}"` : ''}.\n`);
     return;
   }
 
   const kindLabel = opts.kind ? ` (kind: ${opts.kind})` : '';
-  console.log(`\n${data.count} AST nodes${pattern ? ` matching "${pattern}"` : ''}${kindLabel}:\n`);
+  process.stdout.write(
+    `\n${data.count} AST nodes${pattern ? ` matching "${pattern}"` : ''}${kindLabel}:\n\n`,
+  );
 
   for (const r of data.results) {
     const icon = KIND_ICONS[r.kind] || '?';
     const parentInfo = r.parent ? `  (in ${r.parent.name})` : '';
-    console.log(`  ${icon} ${r.name}  -- ${r.file}:${r.line}${parentInfo}`);
+    process.stdout.write(`  ${icon} ${r.name}  -- ${r.file}:${r.line}${parentInfo}\n`);
   }
 
   if (data._pagination?.hasMore) {
-    console.log(
-      `\n  ... ${data._pagination.total - data._pagination.offset - data._pagination.returned} more (use --offset ${data._pagination.offset + data._pagination.limit})`,
+    process.stdout.write(
+      `\n  ... ${data._pagination.total - data._pagination.offset - data._pagination.returned} more (use --offset ${data._pagination.offset + data._pagination.limit})\n`,
     );
   }
-  console.log();
+  process.stdout.write('\n');
 }

package/src/features/audit.ts

@@ -4,7 +4,9 @@ import { normalizeFileFilter } from '../db/query-builder.js';
 import { bfsTransitiveCallers } from '../domain/analysis/impact.js';
 import { explainData } from '../domain/queries.js';
 import { loadConfig } from '../infrastructure/config.js';
+import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { toErrorMessage } from '../shared/errors.js';
 import type { BetterSqlite3Database, CodegraphConfig } from '../types.js';
 import { RULE_DEFS } from './manifesto.js';
 
@@ -41,8 +43,8 @@ function resolveThresholds(
       };
     }
     return resolved;
-  } catch {
-    // Fall back to defaults if config loading fails
+  } catch (e) {
+    debug(`resolveThresholds: config loading failed, using defaults: ${toErrorMessage(e)}`);
     const resolved: Record<string, ThresholdEntry> = {};
     for (const def of FUNCTION_RULES) {
       resolved[def.name] = {
@@ -110,8 +112,8 @@ function readPhase44(db: BetterSqlite3Database, nodeId: number): Phase44Fields {
         sideEffects: row.side_effects ?? null,
       };
     }
-  } catch {
-    /* columns don't exist yet */
+  } catch (e) {
+    debug(`readPhase44: columns may not exist yet: ${toErrorMessage(e)}`);
   }
   return { riskScore: null, complexityNotes: null, sideEffects: null };
 }
@@ -413,8 +415,8 @@ function buildHealth(
       commentLines: row.comment_lines || 0,
       thresholdBreaches: checkBreaches(row as unknown as Record<string, unknown>, thresholds),
     };
-  } catch {
-    /* table may not exist */
+  } catch (e) {
+    debug(`readHealth: function_complexity table may not exist: ${toErrorMessage(e)}`);
     return defaultHealth();
   }
 }

package/src/features/branch-compare.ts

@@ -8,6 +8,7 @@ import { kindIcon } from '../domain/queries.js';
 import { debug } from '../infrastructure/logger.js';
 import { getNative, isNativeAvailable } from '../infrastructure/native.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { toErrorMessage } from '../shared/errors.js';
 import type { EngineMode, NativeDatabase } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
@@ -20,7 +21,8 @@ function validateGitRef(repoRoot: string, ref: string): string | null {
       stdio: ['pipe', 'pipe', 'pipe'],
     }).trim();
     return sha;
-  } catch {
+  } catch (e) {
+    debug(`validateGitRef failed for "${ref}": ${toErrorMessage(e)}`);
     return null;
   }
 }
@@ -50,11 +52,12 @@ function removeWorktree(repoRoot: string, dir: string): void {
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-  } catch {
+  } catch (e) {
+    debug(`removeWorktree: git worktree remove failed for ${dir}: ${toErrorMessage(e)}`);
     try {
       fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* best-effort */
+    } catch (rmErr) {
+      debug(`removeWorktree: rmSync fallback failed for ${dir}: ${toErrorMessage(rmErr)}`);
     }
     try {
       execFileSync('git', ['worktree', 'prune'], {
@@ -62,8 +65,8 @@ function removeWorktree(repoRoot: string, dir: string): void {
         encoding: 'utf-8',
         stdio: ['pipe', 'pipe', 'pipe'],
       });
-    } catch {
-      /* best-effort */
+    } catch (pruneErr) {
+      debug(`removeWorktree: git worktree prune failed: ${toErrorMessage(pruneErr)}`);
     }
   }
 }
@@ -117,7 +120,7 @@ function loadSymbolsFromDb(
       const native = getNative();
       nativeDb = native.NativeDatabase.openReadonly(dbPath);
     } catch (e) {
-      debug(`loadSymbolsFromDb: native path failed: ${(e as Error).message}`);
+      debug(`loadSymbolsFromDb: native path failed: ${toErrorMessage(e)}`);
     }
   }
 
@@ -205,8 +208,8 @@ function loadSymbolsFromDb(
     if (nativeDb) {
       try {
         nativeDb.close();
-      } catch {
-        /* already closed */
+      } catch (e) {
+        debug(`loadSymbolsFromDb: nativeDb close failed: ${toErrorMessage(e)}`);
       }
     }
   }
@@ -360,6 +363,38 @@ interface BranchCompareResult {
   summary?: BranchCompareSummary;
 }
 
+function attachImpactToSymbols(
+  symbols: SymbolInfo[],
+  dbPath: string,
+  _baseSymbols: Map<string, SymbolInfo>,
+  maxDepth: number,
+  noTests: boolean,
+): void {
+  for (const sym of symbols) {
+    const symCallers = loadCallersFromDb(dbPath, sym.id ? [sym.id] : [], maxDepth, noTests);
+    (sym as SymbolInfo & { impact?: CallerInfo[] }).impact = symCallers;
+  }
+}
+
+function attachImpactToChanged(
+  changed: ChangedSymbol[],
+  dbPath: string,
+  baseSymbols: Map<string, SymbolInfo>,
+  maxDepth: number,
+  noTests: boolean,
+): void {
+  for (const sym of changed) {
+    const baseSym = baseSymbols.get(makeSymbolKey(sym.kind, sym.file, sym.name));
+    const symCallers = loadCallersFromDb(
+      dbPath,
+      baseSym?.id ? [baseSym.id] : [],
+      maxDepth,
+      noTests,
+    );
+    sym.impact = symCallers;
+  }
+}
+
 export async function branchCompareData(
   baseRef: string,
   targetRef: string,
@@ -376,7 +411,8 @@ export async function branchCompareData(
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-  } catch {
+  } catch (e) {
+    debug(`branchCompareData: git check failed: ${toErrorMessage(e)}`);
     return { error: 'Not a git repository' };
   }
 
@@ -440,20 +476,8 @@ export async function branchCompareData(
     const removedImpact = loadCallersFromDb(baseDbPath, removedIds, maxDepth, noTests);
     const changedImpact = loadCallersFromDb(baseDbPath, changedIds, maxDepth, noTests);
 
-    for (const sym of removed) {
-      const symCallers = loadCallersFromDb(baseDbPath, sym.id ? [sym.id] : [], maxDepth, noTests);
-      (sym as SymbolInfo & { impact?: CallerInfo[] }).impact = symCallers;
-    }
-    for (const sym of changed) {
-      const baseSym = baseSymbols.get(makeSymbolKey(sym.kind, sym.file, sym.name));
-      const symCallers = loadCallersFromDb(
-        baseDbPath,
-        baseSym?.id ? [baseSym.id] : [],
-        maxDepth,
-        noTests,
-      );
-      sym.impact = symCallers;
-    }
+    attachImpactToSymbols(removed, baseDbPath, baseSymbols, maxDepth, noTests);
+    attachImpactToChanged(changed, baseDbPath, baseSymbols, maxDepth, noTests);
 
     const allImpacted = new Set<string>();
     for (const c of removedImpact) allImpacted.add(`${c.file}:${c.name}`);
@@ -489,20 +513,66 @@ export async function branchCompareData(
       },
     };
   } catch (err) {
-    return { error: (err as Error).message };
+    return { error: toErrorMessage(err) };
   } finally {
     removeWorktree(repoRoot, baseDir);
     removeWorktree(repoRoot, targetDir);
     try {
       fs.rmSync(tmpBase, { recursive: true, force: true });
-    } catch {
-      /* best-effort */
+    } catch (cleanupErr) {
+      debug(`branchCompareData: temp cleanup failed: ${toErrorMessage(cleanupErr)}`);
     }
   }
 }
 
 // ─── Mermaid Output ─────────────────────────────────────────────────────
 
+interface MermaidNodeIdState {
+  counter: number;
+  map: Map<string, string>;
+}
+
+function mermaidNodeId(state: MermaidNodeIdState, key: string): string {
+  if (!state.map.has(key)) {
+    state.map.set(key, `n${state.counter++}`);
+  }
+  return state.map.get(key)!;
+}
+
+function addMermaidSubgraph(
+  lines: string[],
+  state: MermaidNodeIdState,
+  prefix: string,
+  label: string,
+  symbols: Array<{ kind: string; file: string; name: string }>,
+  fillColor: string,
+  strokeColor: string,
+): void {
+  if (symbols.length === 0) return;
+  lines.push(`    subgraph sg_${prefix}["${label}"]`);
+  for (const sym of symbols) {
+    const key = `${prefix}::${sym.kind}::${sym.file}::${sym.name}`;
+    const nid = mermaidNodeId(state, key);
+    lines.push(`        ${nid}["[${kindIcon(sym.kind)}] ${sym.name}"]`);
+  }
+  lines.push('    end');
+  lines.push(`    style sg_${prefix} fill:${fillColor},stroke:${strokeColor}`);
+}
+
+function collectImpactedCallers(
+  impactSources: Array<{ impact?: CallerInfo[] }>,
+): Map<string, CallerInfo> {
+  const allImpacted = new Map<string, CallerInfo>();
+  for (const sym of impactSources) {
+    if (!sym.impact) continue;
+    for (const c of sym.impact) {
+      const key = `impact::${c.kind}::${c.file}::${c.name}`;
+      if (!allImpacted.has(key)) allImpacted.set(key, c);
+    }
+  }
+  return allImpacted;
+}
+
 export function branchCompareMermaid(data: BranchCompareResult): string {
   if (data.error) return data.error;
   if (
@@ -514,63 +584,19 @@ export function branchCompareMermaid(data: BranchCompareResult): string {
   }
 
   const lines = ['flowchart TB'];
-  let nodeCounter = 0;
-  const nodeIdMap = new Map<string, string>();
-
-  function nodeId(key: string): string {
-    if (!nodeIdMap.has(key)) {
-      nodeIdMap.set(key, `n${nodeCounter++}`);
-    }
-    return nodeIdMap.get(key)!;
-  }
-
-  if (data.added && data.added.length > 0) {
-    lines.push('    subgraph sg_added["Added"]');
-    for (const sym of data.added) {
-      const key = `added::${sym.kind}::${sym.file}::${sym.name}`;
-      const nid = nodeId(key);
-      lines.push(`        ${nid}["[${kindIcon(sym.kind)}] ${sym.name}"]`);
-    }
-    lines.push('    end');
-    lines.push('    style sg_added fill:#e8f5e9,stroke:#4caf50');
-  }
-
-  if (data.removed && data.removed.length > 0) {
-    lines.push('    subgraph sg_removed["Removed"]');
-    for (const sym of data.removed) {
-      const key = `removed::${sym.kind}::${sym.file}::${sym.name}`;
-      const nid = nodeId(key);
-      lines.push(`        ${nid}["[${kindIcon(sym.kind)}] ${sym.name}"]`);
-    }
-    lines.push('    end');
-    lines.push('    style sg_removed fill:#ffebee,stroke:#f44336');
-  }
+  const state: MermaidNodeIdState = { counter: 0, map: new Map() };
 
-  if (data.changed && data.changed.length > 0) {
-    lines.push('    subgraph sg_changed["Changed"]');
-    for (const sym of data.changed) {
-      const key = `changed::${sym.kind}::${sym.file}::${sym.name}`;
-      const nid = nodeId(key);
-      lines.push(`        ${nid}["[${kindIcon(sym.kind)}] ${sym.name}"]`);
-    }
-    lines.push('    end');
-    lines.push('    style sg_changed fill:#fff3e0,stroke:#ff9800');
-  }
+  addMermaidSubgraph(lines, state, 'added', 'Added', data.added || [], '#e8f5e9', '#4caf50');
+  addMermaidSubgraph(lines, state, 'removed', 'Removed', data.removed || [], '#ffebee', '#f44336');
+  addMermaidSubgraph(lines, state, 'changed', 'Changed', data.changed || [], '#fff3e0', '#ff9800');
 
-  const allImpacted = new Map<string, CallerInfo>();
   const impactSources = [...(data.removed || []), ...(data.changed || [])];
-  for (const sym of impactSources) {
-    if (!sym.impact) continue;
-    for (const c of sym.impact) {
-      const key = `impact::${c.kind}::${c.file}::${c.name}`;
-      if (!allImpacted.has(key)) allImpacted.set(key, c);
-    }
-  }
+  const allImpacted = collectImpactedCallers(impactSources);
 
   if (allImpacted.size > 0) {
     lines.push('    subgraph sg_impact["Impacted Callers"]');
     for (const [key, c] of allImpacted) {
-      const nid = nodeId(key);
+      const nid = mermaidNodeId(state, key);
       lines.push(`        ${nid}["[${kindIcon(c.kind)}] ${c.name}"]`);
     }
     lines.push('    end');
@@ -583,8 +609,8 @@ export function branchCompareMermaid(data: BranchCompareResult): string {
     const symKey = `${prefix}::${sym.kind}::${sym.file}::${sym.name}`;
     for (const c of sym.impact) {
       const callerKey = `impact::${c.kind}::${c.file}::${c.name}`;
-      if (nodeIdMap.has(symKey) && nodeIdMap.has(callerKey)) {
-        lines.push(`    ${nodeIdMap.get(symKey)} -.-> ${nodeIdMap.get(callerKey)}`);
+      if (state.map.has(symKey) && state.map.has(callerKey)) {
+        lines.push(`    ${state.map.get(symKey)} -.-> ${state.map.get(callerKey)}`);
       }
     }
   }

package/src/features/communities.ts

@@ -86,10 +86,7 @@ interface DriftResult {
   driftScore: number;
 }
 
-function analyzeDrift(
-  communities: CommunityObject[],
-  communityDirs: Map<number, Set<string>>,
-): DriftResult {
+function buildDirToCommunities(communityDirs: Map<number, Set<string>>): Map<string, Set<number>> {
   const dirToCommunities = new Map<string, Set<number>>();
   for (const [cid, dirs] of communityDirs) {
     for (const dir of dirs) {
@@ -97,20 +94,28 @@ function analyzeDrift(
       dirToCommunities.get(dir)!.add(cid);
     }
   }
+  return dirToCommunities;
+}
 
-  const splitCandidates: DriftResult['splitCandidates'] = [];
+function findSplitCandidates(
+  dirToCommunities: Map<string, Set<number>>,
+): DriftResult['splitCandidates'] {
+  const candidates: DriftResult['splitCandidates'] = [];
   for (const [dir, cids] of dirToCommunities) {
     if (cids.size >= 2) {
-      splitCandidates.push({ directory: dir, communityCount: cids.size });
+      candidates.push({ directory: dir, communityCount: cids.size });
     }
   }
-  splitCandidates.sort((a, b) => b.communityCount - a.communityCount);
+  candidates.sort((a, b) => b.communityCount - a.communityCount);
+  return candidates;
+}
 
-  const mergeCandidates: DriftResult['mergeCandidates'] = [];
+function findMergeCandidates(communities: CommunityObject[]): DriftResult['mergeCandidates'] {
+  const candidates: DriftResult['mergeCandidates'] = [];
   for (const c of communities) {
     const dirCount = Object.keys(c.directories).length;
     if (dirCount >= 2) {
-      mergeCandidates.push({
+      candidates.push({
         communityId: c.id,
         size: c.size,
         directoryCount: dirCount,
@@ -118,7 +123,17 @@ function analyzeDrift(
       });
     }
   }
-  mergeCandidates.sort((a, b) => b.directoryCount - a.directoryCount);
+  candidates.sort((a, b) => b.directoryCount - a.directoryCount);
+  return candidates;
+}
+
+function analyzeDrift(
+  communities: CommunityObject[],
+  communityDirs: Map<number, Set<string>>,
+): DriftResult {
+  const dirToCommunities = buildDirToCommunities(communityDirs);
+  const splitCandidates = findSplitCandidates(dirToCommunities);
+  const mergeCandidates = findMergeCandidates(communities);
 
   const totalDirs = dirToCommunities.size;
   const splitRatio = totalDirs > 0 ? splitCandidates.length / totalDirs : 0;