@optave/codegraph 3.8.0 → 3.9.0

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;

package/src/features/complexity.ts

@@ -109,6 +109,163 @@ export const computeMaintainabilityIndex = _computeMaintainabilityIndex;
 
 // ─── Algorithm: Single-Traversal DFS ──────────────────────────────────────
 
+interface ComplexityAccumulator {
+  cognitive: number;
+  cyclomatic: number;
+  maxNesting: number;
+}
+
+type WalkFn = (n: TreeSitterNode | null, level: number, isTop: boolean) => void;
+
+/** Walk all children at the given nesting level. */
+function walkChildren(node: TreeSitterNode, nestingLevel: number, walkFn: WalkFn): void {
+  for (let i = 0; i < node.childCount; i++) {
+    walkFn(node.child(i), nestingLevel, false);
+  }
+}
+
+/** Handle logical operators in binary expressions. Returns true if handled. */
+function handleLogicalOperator(
+  node: TreeSitterNode,
+  type: string,
+  rules: ComplexityRules,
+  acc: ComplexityAccumulator,
+  nestingLevel: number,
+  walkFn: WalkFn,
+): boolean {
+  if (type !== rules.logicalNodeType) return false;
+
+  const op = node.child(1)?.type;
+  if (!op || !rules.logicalOperators.has(op)) return false;
+
+  acc.cyclomatic++;
+
+  // Cognitive: +1 only when operator changes from the previous sibling sequence
+  const parent = node.parent;
+  const sameSequence = parent?.type === rules.logicalNodeType && parent.child(1)?.type === op;
+  if (!sameSequence) acc.cognitive++;
+
+  walkChildren(node, nestingLevel, walkFn);
+  return true;
+}
+
+/** Handle else clause wrapping an if (Pattern A: JS/C#/Rust). Returns true if handled. */
+function handleElseClause(
+  node: TreeSitterNode,
+  type: string,
+  rules: ComplexityRules,
+  acc: ComplexityAccumulator,
+  nestingLevel: number,
+  walkFn: WalkFn,
+): boolean {
+  if (!rules.elseNodeType || type !== rules.elseNodeType) return false;
+
+  const firstChild = node.namedChild(0);
+  if (firstChild && firstChild.type === rules.ifNodeType) {
+    // else-if: the if_statement child handles its own increment
+    walkChildren(node, nestingLevel, walkFn);
+    return true;
+  }
+  // Plain else
+  acc.cognitive++;
+  walkChildren(node, nestingLevel, walkFn);
+  return true;
+}
+
+/** Detect and handle else-if patterns (Patterns A, B, C). Returns true if handled. */
+function handleElseIf(
+  node: TreeSitterNode,
+  type: string,
+  rules: ComplexityRules,
+  acc: ComplexityAccumulator,
+  nestingLevel: number,
+  walkFn: WalkFn,
+): boolean {
+  // Pattern B: explicit elif node (Python/Ruby/PHP)
+  if (rules.elifNodeType && type === rules.elifNodeType) {
+    acc.cognitive++;
+    acc.cyclomatic++;
+    walkChildren(node, nestingLevel, walkFn);
+    return true;
+  }
+
+  // Detect else-if via Pattern A or C
+  if (type === rules.ifNodeType) {
+    let isElseIf = false;
+    if (rules.elseViaAlternative) {
+      // Pattern C (Go/Java): if_statement is the alternative of parent if_statement
+      isElseIf =
+        node.parent?.type === rules.ifNodeType &&
+        node.parent.childForFieldName('alternative')?.id === node.id;
+    } else if (rules.elseNodeType) {
+      // Pattern A (JS/C#/Rust): if_statement inside else_clause
+      isElseIf = node.parent?.type === rules.elseNodeType;
+    }
+    if (isElseIf) {
+      acc.cognitive++;
+      acc.cyclomatic++;
+      walkChildren(node, nestingLevel, walkFn);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/** Handle branch/control flow nodes. Returns true if handled. */
+function handleBranchNode(
+  node: TreeSitterNode,
+  type: string,
+  rules: ComplexityRules,
+  acc: ComplexityAccumulator,
+  nestingLevel: number,
+  walkFn: WalkFn,
+): boolean {
+  if (!rules.branchNodes.has(type) || node.childCount === 0) return false;
+
+  if (handleElseClause(node, type, rules, acc, nestingLevel, walkFn)) return true;
+  if (handleElseIf(node, type, rules, acc, nestingLevel, walkFn)) return true;
+
+  // Regular branch node
+  acc.cognitive += 1 + nestingLevel; // structural + nesting
+  acc.cyclomatic++;
+
+  // Switch-like nodes don't add cyclomatic themselves (cases do)
+  if (rules.switchLikeNodes?.has(type)) {
+    acc.cyclomatic--;
+  }
+
+  if (rules.nestingNodes.has(type)) {
+    walkChildren(node, nestingLevel + 1, walkFn);
+    return true;
+  }
+
+  return false;
+}
+
+/** Handle Pattern C plain else: block is the alternative of an if_statement (Go/Java). */
+function handlePatternCElse(
+  node: TreeSitterNode,
+  type: string,
+  rules: ComplexityRules,
+  acc: ComplexityAccumulator,
+  nestingLevel: number,
+  walkFn: WalkFn,
+): boolean {
+  if (
+    !rules.elseViaAlternative ||
+    type === rules.ifNodeType ||
+    node.parent?.type !== rules.ifNodeType ||
+    node.parent.childForFieldName('alternative')?.id !== node.id
+  ) {
+    return false;
+  }
+
+  acc.cognitive++;
+  walkChildren(node, nestingLevel, walkFn);
+  return true;
+}
+
 export function computeFunctionComplexity(
   functionNode: TreeSitterNode,
   language: string,
@@ -116,158 +273,38 @@ export function computeFunctionComplexity(
   const rules = COMPLEXITY_RULES.get(language) as ComplexityRules | undefined;
   if (!rules) return null;
 
-  let cognitive = 0;
-  let cyclomatic = 1; // McCabe starts at 1
-  let maxNesting = 0;
+  const acc: ComplexityAccumulator = { cognitive: 0, cyclomatic: 1, maxNesting: 0 };
 
   function walk(node: TreeSitterNode | null, nestingLevel: number, isTopFunction: boolean): void {
     if (!node) return;
 
     const type = node.type;
 
-    // Track nesting depth
-    if (nestingLevel > maxNesting) maxNesting = nestingLevel;
-
-    // Handle logical operators in binary expressions
-    if (type === rules?.logicalNodeType) {
-      const op = node.child(1)?.type;
-      if (op && rules?.logicalOperators.has(op)) {
-        // Cyclomatic: +1 for every logical operator
-        cyclomatic++;
-
-        // Cognitive: +1 only when operator changes from the previous sibling sequence
-        // Walk up to check if parent is same type with same operator
-        const parent = node.parent;
-        let sameSequence = false;
-        if (parent && parent.type === rules?.logicalNodeType) {
-          const parentOp = parent.child(1)?.type;
-          if (parentOp === op) {
-            sameSequence = true;
-          }
-        }
-        if (!sameSequence) {
-          cognitive++;
-        }
-
-        // Walk children manually to avoid double-counting
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false);
-        }
-        return;
-      }
-    }
+    if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
 
-    // Handle optional chaining (cyclomatic only)
-    if (type === rules?.optionalChainType) {
-      cyclomatic++;
-    }
-
-    // Handle branch/control flow nodes (skip keyword leaf tokens like Ruby's `if`)
-    if (rules?.branchNodes.has(type) && node.childCount > 0) {
-      // Pattern A: else clause wraps if (JS/C#/Rust)
-      if (rules?.elseNodeType && type === rules?.elseNodeType) {
-        const firstChild = node.namedChild(0);
-        if (firstChild && firstChild.type === rules?.ifNodeType) {
-          // else-if: the if_statement child handles its own increment
-          for (let i = 0; i < node.childCount; i++) {
-            walk(node.child(i), nestingLevel, false);
-          }
-          return;
-        }
-        // Plain else
-        cognitive++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false);
-        }
-        return;
-      }
+    if (handleLogicalOperator(node, type, rules!, acc, nestingLevel, walk)) return;
 
-      // Pattern B: explicit elif node (Python/Ruby/PHP)
-      if (rules?.elifNodeType && type === rules?.elifNodeType) {
-        cognitive++;
-        cyclomatic++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false);
-        }
-        return;
-      }
+    // Optional chaining (cyclomatic only)
+    if (type === rules!.optionalChainType) acc.cyclomatic++;
 
-      // Detect else-if via Pattern A or C
-      let isElseIf = false;
-      if (type === rules?.ifNodeType) {
-        if (rules?.elseViaAlternative) {
-          // Pattern C (Go/Java): if_statement is the alternative of parent if_statement
-          isElseIf =
-            node.parent?.type === rules?.ifNodeType &&
-            node.parent.childForFieldName('alternative')?.id === node.id;
-        } else if (rules?.elseNodeType) {
-          // Pattern A (JS/C#/Rust): if_statement inside else_clause
-          isElseIf = node.parent?.type === rules?.elseNodeType;
-        }
-      }
+    if (handleBranchNode(node, type, rules!, acc, nestingLevel, walk)) return;
+    if (handlePatternCElse(node, type, rules!, acc, nestingLevel, walk)) return;
 
-      if (isElseIf) {
-        cognitive++;
-        cyclomatic++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false);
-        }
-        return;
-      }
+    // Case nodes (cyclomatic only, skip keyword leaves)
+    if (rules!.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
 
-      // Regular branch node
-      cognitive += 1 + nestingLevel; // structural + nesting
-      cyclomatic++;
-
-      // Switch-like nodes don't add cyclomatic themselves (cases do)
-      if (rules?.switchLikeNodes?.has(type)) {
-        cyclomatic--; // Undo the ++ above; cases handle cyclomatic
-      }
-
-      if (rules?.nestingNodes.has(type)) {
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel + 1, false);
-        }
-        return;
-      }
-    }
-
-    // Pattern C plain else: block that is the alternative of an if_statement (Go/Java)
-    if (
-      rules?.elseViaAlternative &&
-      type !== rules?.ifNodeType &&
-      node.parent?.type === rules?.ifNodeType &&
-      node.parent.childForFieldName('alternative')?.id === node.id
-    ) {
-      cognitive++;
-      for (let i = 0; i < node.childCount; i++) {
-        walk(node.child(i), nestingLevel, false);
-      }
+    // Nested function definitions (increase nesting)
+    if (!isTopFunction && rules!.functionNodes.has(type)) {
+      walkChildren(node, nestingLevel + 1, walk);
       return;
     }
 
-    // Handle case nodes (cyclomatic only, skip keyword leaves)
-    if (rules?.caseNodes.has(type) && node.childCount > 0) {
-      cyclomatic++;
-    }
-
-    // Handle nested function definitions (increase nesting)
-    if (!isTopFunction && rules?.functionNodes.has(type)) {
-      for (let i = 0; i < node.childCount; i++) {
-        walk(node.child(i), nestingLevel + 1, false);
-      }
-      return;
-    }
-
-    // Walk children
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i), nestingLevel, false);
-    }
+    walkChildren(node, nestingLevel, walk);
   }
 
   walk(functionNode, 0, true);
 
-  return { cognitive, cyclomatic, maxNesting };
+  return { cognitive: acc.cognitive, cyclomatic: acc.cyclomatic, maxNesting: acc.maxNesting };
 }
 
 // ─── Merged Single-Pass Computation ───────────────────────────────────────