@optave/codegraph 3.1.0 → 3.1.2

package/src/complexity.js

@@ -1,1035 +1,28 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import {
+  computeLOCMetrics as _computeLOCMetrics,
+  computeMaintainabilityIndex as _computeMaintainabilityIndex,
+} from './ast-analysis/metrics.js';
+import { COMPLEXITY_RULES, HALSTEAD_RULES } from './ast-analysis/rules/index.js';
+import {
+  findFunctionNode as _findFunctionNode,
+  buildExtensionSet,
+  buildExtToLangMap,
+} from './ast-analysis/shared.js';
+import { walkWithVisitors } from './ast-analysis/visitor.js';
+import { createComplexityVisitor } from './ast-analysis/visitors/complexity-visitor.js';
 import { loadConfig } from './config.js';
-import { openReadonlyOrFail } from './db.js';
+import { getFunctionNodeId, openReadonlyOrFail } from './db.js';
+import { isTestFile } from './infrastructure/test-filter.js';
 import { info } from './logger.js';
-import { paginateResult, printNdjson } from './paginate.js';
-import { LANGUAGE_REGISTRY } from './parser.js';
-import { isTestFile } from './queries.js';
-
-// ─── Language-Specific Node Type Registry ─────────────────────────────────
-
-const JS_TS_RULES = {
-  // Structural increments (cognitive +1, cyclomatic varies)
-  branchNodes: new Set([
-    'if_statement',
-    'else_clause',
-    'switch_statement',
-    'for_statement',
-    'for_in_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'ternary_expression',
-  ]),
-  // Cyclomatic-only: each case adds a path
-  caseNodes: new Set(['switch_case']),
-  // Logical operators: cognitive +1 per sequence change, cyclomatic +1 each
-  logicalOperators: new Set(['&&', '||', '??']),
-  logicalNodeType: 'binary_expression',
-  // Optional chaining: cyclomatic only
-  optionalChainType: 'optional_chain_expression',
-  // Nesting-sensitive: these increment nesting depth
-  nestingNodes: new Set([
-    'if_statement',
-    'switch_statement',
-    'for_statement',
-    'for_in_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'ternary_expression',
-  ]),
-  // Function-like nodes (increase nesting when nested)
-  functionNodes: new Set([
-    'function_declaration',
-    'function_expression',
-    'arrow_function',
-    'method_definition',
-    'generator_function',
-    'generator_function_declaration',
-  ]),
-  // If/else pattern detection
-  ifNodeType: 'if_statement',
-  elseNodeType: 'else_clause',
-  elifNodeType: null,
-  elseViaAlternative: false,
-  switchLikeNodes: new Set(['switch_statement']),
-};
-
-const PYTHON_RULES = {
-  branchNodes: new Set([
-    'if_statement',
-    'elif_clause',
-    'else_clause',
-    'for_statement',
-    'while_statement',
-    'except_clause',
-    'conditional_expression',
-    'match_statement',
-  ]),
-  caseNodes: new Set(['case_clause']),
-  logicalOperators: new Set(['and', 'or']),
-  logicalNodeType: 'boolean_operator',
-  optionalChainType: null,
-  nestingNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'while_statement',
-    'except_clause',
-    'conditional_expression',
-  ]),
-  functionNodes: new Set(['function_definition', 'lambda']),
-  ifNodeType: 'if_statement',
-  elseNodeType: 'else_clause',
-  elifNodeType: 'elif_clause',
-  elseViaAlternative: false,
-  switchLikeNodes: new Set(['match_statement']),
-};
-
-const GO_RULES = {
-  branchNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'expression_switch_statement',
-    'type_switch_statement',
-    'select_statement',
-  ]),
-  caseNodes: new Set(['expression_case', 'type_case', 'default_case', 'communication_case']),
-  logicalOperators: new Set(['&&', '||']),
-  logicalNodeType: 'binary_expression',
-  optionalChainType: null,
-  nestingNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'expression_switch_statement',
-    'type_switch_statement',
-    'select_statement',
-  ]),
-  functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
-  ifNodeType: 'if_statement',
-  elseNodeType: null,
-  elifNodeType: null,
-  elseViaAlternative: true,
-  switchLikeNodes: new Set(['expression_switch_statement', 'type_switch_statement']),
-};
-
-const RUST_RULES = {
-  branchNodes: new Set([
-    'if_expression',
-    'else_clause',
-    'for_expression',
-    'while_expression',
-    'loop_expression',
-    'if_let_expression',
-    'while_let_expression',
-    'match_expression',
-  ]),
-  caseNodes: new Set(['match_arm']),
-  logicalOperators: new Set(['&&', '||']),
-  logicalNodeType: 'binary_expression',
-  optionalChainType: null,
-  nestingNodes: new Set([
-    'if_expression',
-    'for_expression',
-    'while_expression',
-    'loop_expression',
-    'if_let_expression',
-    'while_let_expression',
-    'match_expression',
-  ]),
-  functionNodes: new Set(['function_item', 'closure_expression']),
-  ifNodeType: 'if_expression',
-  elseNodeType: 'else_clause',
-  elifNodeType: null,
-  elseViaAlternative: false,
-  switchLikeNodes: new Set(['match_expression']),
-};
-
-const JAVA_RULES = {
-  branchNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'enhanced_for_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'ternary_expression',
-    'switch_expression',
-  ]),
-  caseNodes: new Set(['switch_label']),
-  logicalOperators: new Set(['&&', '||']),
-  logicalNodeType: 'binary_expression',
-  optionalChainType: null,
-  nestingNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'enhanced_for_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'ternary_expression',
-  ]),
-  functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
-  ifNodeType: 'if_statement',
-  elseNodeType: null,
-  elifNodeType: null,
-  elseViaAlternative: true,
-  switchLikeNodes: new Set(['switch_expression']),
-};
-
-const CSHARP_RULES = {
-  branchNodes: new Set([
-    'if_statement',
-    'else_clause',
-    'for_statement',
-    'foreach_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'conditional_expression',
-    'switch_statement',
-  ]),
-  caseNodes: new Set(['switch_section']),
-  logicalOperators: new Set(['&&', '||', '??']),
-  logicalNodeType: 'binary_expression',
-  optionalChainType: 'conditional_access_expression',
-  nestingNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'foreach_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'conditional_expression',
-    'switch_statement',
-  ]),
-  functionNodes: new Set([
-    'method_declaration',
-    'constructor_declaration',
-    'lambda_expression',
-    'local_function_statement',
-  ]),
-  ifNodeType: 'if_statement',
-  elseNodeType: null,
-  elifNodeType: null,
-  elseViaAlternative: true,
-  switchLikeNodes: new Set(['switch_statement']),
-};
-
-const RUBY_RULES = {
-  branchNodes: new Set([
-    'if',
-    'elsif',
-    'else',
-    'unless',
-    'case',
-    'for',
-    'while',
-    'until',
-    'rescue',
-    'conditional',
-  ]),
-  caseNodes: new Set(['when']),
-  logicalOperators: new Set(['and', 'or', '&&', '||']),
-  logicalNodeType: 'binary',
-  optionalChainType: null,
-  nestingNodes: new Set(['if', 'unless', 'case', 'for', 'while', 'until', 'rescue', 'conditional']),
-  functionNodes: new Set(['method', 'singleton_method', 'lambda', 'do_block']),
-  ifNodeType: 'if',
-  elseNodeType: 'else',
-  elifNodeType: 'elsif',
-  elseViaAlternative: false,
-  switchLikeNodes: new Set(['case']),
-};
-
-const PHP_RULES = {
-  branchNodes: new Set([
-    'if_statement',
-    'else_if_clause',
-    'else_clause',
-    'for_statement',
-    'foreach_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'conditional_expression',
-    'switch_statement',
-  ]),
-  caseNodes: new Set(['case_statement', 'default_statement']),
-  logicalOperators: new Set(['&&', '||', 'and', 'or', '??']),
-  logicalNodeType: 'binary_expression',
-  optionalChainType: 'nullsafe_member_access_expression',
-  nestingNodes: new Set([
-    'if_statement',
-    'for_statement',
-    'foreach_statement',
-    'while_statement',
-    'do_statement',
-    'catch_clause',
-    'conditional_expression',
-    'switch_statement',
-  ]),
-  functionNodes: new Set([
-    'function_definition',
-    'method_declaration',
-    'anonymous_function_creation_expression',
-    'arrow_function',
-  ]),
-  ifNodeType: 'if_statement',
-  elseNodeType: 'else_clause',
-  elifNodeType: 'else_if_clause',
-  elseViaAlternative: false,
-  switchLikeNodes: new Set(['switch_statement']),
-};
-
-export const COMPLEXITY_RULES = new Map([
-  ['javascript', JS_TS_RULES],
-  ['typescript', JS_TS_RULES],
-  ['tsx', JS_TS_RULES],
-  ['python', PYTHON_RULES],
-  ['go', GO_RULES],
-  ['rust', RUST_RULES],
-  ['java', JAVA_RULES],
-  ['csharp', CSHARP_RULES],
-  ['ruby', RUBY_RULES],
-  ['php', PHP_RULES],
-]);
+import { paginateResult } from './paginate.js';
 
-// Extensions whose language has complexity rules — used to skip needless WASM init
-const COMPLEXITY_EXTENSIONS = new Set();
-for (const entry of LANGUAGE_REGISTRY) {
-  if (COMPLEXITY_RULES.has(entry.id)) {
-    for (const ext of entry.extensions) COMPLEXITY_EXTENSIONS.add(ext);
-  }
-}
+// Re-export rules for backward compatibility
+export { COMPLEXITY_RULES, HALSTEAD_RULES };
 
-// ─── Halstead Operator/Operand Classification ────────────────────────────
-
-const JS_TS_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    // Arithmetic
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '**',
-    // Assignment
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '**=',
-    '<<=',
-    '>>=',
-    '>>>=',
-    '&=',
-    '|=',
-    '^=',
-    '&&=',
-    '||=',
-    '??=',
-    // Comparison
-    '==',
-    '===',
-    '!=',
-    '!==',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    // Logical
-    '&&',
-    '||',
-    '!',
-    '??',
-    // Bitwise
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    '>>>',
-    // Unary
-    '++',
-    '--',
-    // Keywords as operators
-    'typeof',
-    'instanceof',
-    'new',
-    'return',
-    'throw',
-    'yield',
-    'await',
-    'if',
-    'else',
-    'for',
-    'while',
-    'do',
-    'switch',
-    'case',
-    'break',
-    'continue',
-    'try',
-    'catch',
-    'finally',
-    // Arrow, spread, ternary, access
-    '=>',
-    '...',
-    '?',
-    ':',
-    '.',
-    '?.',
-    // Delimiters counted as operators
-    ',',
-    ';',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'property_identifier',
-    'shorthand_property_identifier',
-    'shorthand_property_identifier_pattern',
-    'number',
-    'string_fragment',
-    'regex_pattern',
-    'true',
-    'false',
-    'null',
-    'undefined',
-    'this',
-    'super',
-    'private_property_identifier',
-  ]),
-  compoundOperators: new Set([
-    'call_expression',
-    'subscript_expression',
-    'new_expression',
-    'template_substitution',
-  ]),
-  skipTypes: new Set(['type_annotation', 'type_parameters', 'return_type', 'implements_clause']),
-};
-
-const PYTHON_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '**',
-    '//',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '**=',
-    '//=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    'and',
-    'or',
-    'not',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    'if',
-    'else',
-    'elif',
-    'for',
-    'while',
-    'with',
-    'try',
-    'except',
-    'finally',
-    'raise',
-    'return',
-    'yield',
-    'await',
-    'pass',
-    'break',
-    'continue',
-    'import',
-    'from',
-    'as',
-    'in',
-    'is',
-    'lambda',
-    'del',
-    '.',
-    ',',
-    ':',
-    '@',
-    '->',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'integer',
-    'float',
-    'string_content',
-    'true',
-    'false',
-    'none',
-  ]),
-  compoundOperators: new Set(['call', 'subscript', 'attribute']),
-  skipTypes: new Set([]),
-};
-
-const GO_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '=',
-    ':=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '&&',
-    '||',
-    '!',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    '&^',
-    '++',
-    '--',
-    'if',
-    'else',
-    'for',
-    'switch',
-    'select',
-    'case',
-    'default',
-    'return',
-    'break',
-    'continue',
-    'goto',
-    'fallthrough',
-    'go',
-    'defer',
-    'range',
-    'chan',
-    'func',
-    'var',
-    'const',
-    'type',
-    'struct',
-    'interface',
-    '.',
-    ',',
-    ';',
-    ':',
-    '<-',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'field_identifier',
-    'package_identifier',
-    'type_identifier',
-    'int_literal',
-    'float_literal',
-    'imaginary_literal',
-    'rune_literal',
-    'interpreted_string_literal',
-    'raw_string_literal',
-    'true',
-    'false',
-    'nil',
-    'iota',
-  ]),
-  compoundOperators: new Set(['call_expression', 'index_expression', 'selector_expression']),
-  skipTypes: new Set([]),
-};
-
-const RUST_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '&&',
-    '||',
-    '!',
-    '&',
-    '|',
-    '^',
-    '<<',
-    '>>',
-    'if',
-    'else',
-    'for',
-    'while',
-    'loop',
-    'match',
-    'return',
-    'break',
-    'continue',
-    'let',
-    'mut',
-    'ref',
-    'as',
-    'in',
-    'move',
-    'fn',
-    'struct',
-    'enum',
-    'trait',
-    'impl',
-    'pub',
-    'mod',
-    'use',
-    '.',
-    ',',
-    ';',
-    ':',
-    '::',
-    '=>',
-    '->',
-    '?',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'field_identifier',
-    'type_identifier',
-    'integer_literal',
-    'float_literal',
-    'string_content',
-    'char_literal',
-    'true',
-    'false',
-    'self',
-    'Self',
-  ]),
-  compoundOperators: new Set(['call_expression', 'index_expression', 'field_expression']),
-  skipTypes: new Set([]),
-};
-
-const JAVA_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '>>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '&&',
-    '||',
-    '!',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    '>>>',
-    '++',
-    '--',
-    'instanceof',
-    'new',
-    'if',
-    'else',
-    'for',
-    'while',
-    'do',
-    'switch',
-    'case',
-    'return',
-    'throw',
-    'break',
-    'continue',
-    'try',
-    'catch',
-    'finally',
-    '.',
-    ',',
-    ';',
-    ':',
-    '?',
-    '->',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'type_identifier',
-    'decimal_integer_literal',
-    'hex_integer_literal',
-    'octal_integer_literal',
-    'binary_integer_literal',
-    'decimal_floating_point_literal',
-    'hex_floating_point_literal',
-    'string_literal',
-    'character_literal',
-    'true',
-    'false',
-    'null',
-    'this',
-    'super',
-  ]),
-  compoundOperators: new Set(['method_invocation', 'array_access', 'object_creation_expression']),
-  skipTypes: new Set(['type_arguments', 'type_parameters']),
-};
-
-const CSHARP_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '&&',
-    '||',
-    '!',
-    '??',
-    '??=',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    '++',
-    '--',
-    'is',
-    'as',
-    'new',
-    'typeof',
-    'sizeof',
-    'nameof',
-    'if',
-    'else',
-    'for',
-    'foreach',
-    'while',
-    'do',
-    'switch',
-    'case',
-    'return',
-    'throw',
-    'break',
-    'continue',
-    'try',
-    'catch',
-    'finally',
-    'await',
-    'yield',
-    '.',
-    '?.',
-    ',',
-    ';',
-    ':',
-    '=>',
-    '->',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'integer_literal',
-    'real_literal',
-    'string_literal',
-    'character_literal',
-    'verbatim_string_literal',
-    'interpolated_string_text',
-    'true',
-    'false',
-    'null',
-    'this',
-    'base',
-  ]),
-  compoundOperators: new Set([
-    'invocation_expression',
-    'element_access_expression',
-    'object_creation_expression',
-  ]),
-  skipTypes: new Set(['type_argument_list', 'type_parameter_list']),
-};
-
-const RUBY_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '**',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '**=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '!=',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '<=>',
-    '===',
-    '=~',
-    '!~',
-    '&&',
-    '||',
-    '!',
-    'and',
-    'or',
-    'not',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    'if',
-    'else',
-    'elsif',
-    'unless',
-    'case',
-    'when',
-    'for',
-    'while',
-    'until',
-    'do',
-    'begin',
-    'end',
-    'return',
-    'raise',
-    'break',
-    'next',
-    'redo',
-    'retry',
-    'rescue',
-    'ensure',
-    'yield',
-    'def',
-    'class',
-    'module',
-    '.',
-    ',',
-    ':',
-    '::',
-    '=>',
-    '->',
-  ]),
-  operandLeafTypes: new Set([
-    'identifier',
-    'constant',
-    'instance_variable',
-    'class_variable',
-    'global_variable',
-    'integer',
-    'float',
-    'string_content',
-    'symbol',
-    'true',
-    'false',
-    'nil',
-    'self',
-  ]),
-  compoundOperators: new Set(['call', 'element_reference']),
-  skipTypes: new Set([]),
-};
-
-const PHP_HALSTEAD = {
-  operatorLeafTypes: new Set([
-    '+',
-    '-',
-    '*',
-    '/',
-    '%',
-    '**',
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '**=',
-    '.=',
-    '&=',
-    '|=',
-    '^=',
-    '<<=',
-    '>>=',
-    '==',
-    '===',
-    '!=',
-    '!==',
-    '<',
-    '>',
-    '<=',
-    '>=',
-    '<=>',
-    '&&',
-    '||',
-    '!',
-    'and',
-    'or',
-    'xor',
-    '??',
-    '&',
-    '|',
-    '^',
-    '~',
-    '<<',
-    '>>',
-    '++',
-    '--',
-    'instanceof',
-    'new',
-    'clone',
-    'if',
-    'else',
-    'elseif',
-    'for',
-    'foreach',
-    'while',
-    'do',
-    'switch',
-    'case',
-    'return',
-    'throw',
-    'break',
-    'continue',
-    'try',
-    'catch',
-    'finally',
-    'echo',
-    'print',
-    'yield',
-    '.',
-    '->',
-    '?->',
-    '::',
-    ',',
-    ';',
-    ':',
-    '?',
-    '=>',
-  ]),
-  operandLeafTypes: new Set([
-    'name',
-    'variable_name',
-    'integer',
-    'float',
-    'string_content',
-    'true',
-    'false',
-    'null',
-  ]),
-  compoundOperators: new Set([
-    'function_call_expression',
-    'member_call_expression',
-    'scoped_call_expression',
-    'subscript_expression',
-    'object_creation_expression',
-  ]),
-  skipTypes: new Set([]),
-};
-
-export const HALSTEAD_RULES = new Map([
-  ['javascript', JS_TS_HALSTEAD],
-  ['typescript', JS_TS_HALSTEAD],
-  ['tsx', JS_TS_HALSTEAD],
-  ['python', PYTHON_HALSTEAD],
-  ['go', GO_HALSTEAD],
-  ['rust', RUST_HALSTEAD],
-  ['java', JAVA_HALSTEAD],
-  ['csharp', CSHARP_HALSTEAD],
-  ['ruby', RUBY_HALSTEAD],
-  ['php', PHP_HALSTEAD],
-]);
+// Extensions whose language has complexity rules — used to skip needless WASM init
+const COMPLEXITY_EXTENSIONS = buildExtensionSet(COMPLEXITY_RULES);
 
 // ─── Halstead Metrics Computation ─────────────────────────────────────────
 
@@ -1106,80 +99,12 @@ export function computeHalsteadMetrics(functionNode, language) {
 }
 
 // ─── LOC Metrics Computation ──────────────────────────────────────────────
-
-const C_STYLE_PREFIXES = ['//', '/*', '*', '*/'];
-
-const COMMENT_PREFIXES = new Map([
-  ['javascript', C_STYLE_PREFIXES],
-  ['typescript', C_STYLE_PREFIXES],
-  ['tsx', C_STYLE_PREFIXES],
-  ['go', C_STYLE_PREFIXES],
-  ['rust', C_STYLE_PREFIXES],
-  ['java', C_STYLE_PREFIXES],
-  ['csharp', C_STYLE_PREFIXES],
-  ['python', ['#']],
-  ['ruby', ['#']],
-  ['php', ['//', '#', '/*', '*', '*/']],
-]);
-
-/**
- * Compute LOC metrics from a function node's source text.
- *
- * @param {object} functionNode - tree-sitter node
- * @param {string} [language] - Language ID (falls back to C-style prefixes)
- * @returns {{ loc: number, sloc: number, commentLines: number }}
- */
-export function computeLOCMetrics(functionNode, language) {
-  const text = functionNode.text;
-  const lines = text.split('\n');
-  const loc = lines.length;
-  const prefixes = (language && COMMENT_PREFIXES.get(language)) || C_STYLE_PREFIXES;
-
-  let commentLines = 0;
-  let blankLines = 0;
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === '') {
-      blankLines++;
-    } else if (prefixes.some((p) => trimmed.startsWith(p))) {
-      commentLines++;
-    }
-  }
-
-  const sloc = Math.max(1, loc - blankLines - commentLines);
-  return { loc, sloc, commentLines };
-}
+// Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
+export const computeLOCMetrics = _computeLOCMetrics;
 
 // ─── Maintainability Index ────────────────────────────────────────────────
-
-/**
- * Compute normalized Maintainability Index (0-100 scale).
- *
- * Original SEI formula: MI = 171 - 5.2*ln(V) - 0.23*G - 16.2*ln(LOC) + 50*sin(sqrt(2.4*CM))
- * Microsoft normalization: max(0, min(100, MI * 100/171))
- *
- * @param {number} volume - Halstead volume
- * @param {number} cyclomatic - Cyclomatic complexity
- * @param {number} sloc - Source lines of code
- * @param {number} [commentRatio] - Comment ratio (0-1), optional
- * @returns {number} Normalized MI (0-100)
- */
-export function computeMaintainabilityIndex(volume, cyclomatic, sloc, commentRatio) {
-  // Guard against zero/negative values in logarithms
-  const safeVolume = Math.max(volume, 1);
-  const safeSLOC = Math.max(sloc, 1);
-
-  let mi = 171 - 5.2 * Math.log(safeVolume) - 0.23 * cyclomatic - 16.2 * Math.log(safeSLOC);
-
-  if (commentRatio != null && commentRatio > 0) {
-    mi += 50 * Math.sin(Math.sqrt(2.4 * commentRatio));
-  }
-
-  // Microsoft normalization: 0-100 scale
-  const normalized = Math.max(0, Math.min(100, (mi * 100) / 171));
-  return +normalized.toFixed(1);
-}
+// Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
+export const computeMaintainabilityIndex = _computeMaintainabilityIndex;
 
 // ─── Algorithm: Single-Traversal DFS ──────────────────────────────────────
 
@@ -1357,6 +282,8 @@ export function computeFunctionComplexity(functionNode, language) {
  * traversal, avoiding two separate DFS walks per function node at build time.
  * LOC is text-based (not tree-based) and computed separately (very cheap).
  *
+ * Now delegates to the complexity visitor via the unified walker.
+ *
  * @param {object} functionNode - tree-sitter node for the function
  * @param {string} langId - Language ID (e.g. 'javascript', 'python')
  * @returns {{ cognitive: number, cyclomatic: number, maxNesting: number, halstead: object|null, loc: object, mi: number } | null}
@@ -1366,207 +293,34 @@ export function computeAllMetrics(functionNode, langId) {
   if (!cRules) return null;
   const hRules = HALSTEAD_RULES.get(langId);
 
-  // ── Complexity state ──
-  let cognitive = 0;
-  let cyclomatic = 1; // McCabe starts at 1
-  let maxNesting = 0;
-
-  // ── Halstead state ──
-  const operators = hRules ? new Map() : null;
-  const operands = hRules ? new Map() : null;
-
-  function walk(node, nestingLevel, isTopFunction, halsteadSkip) {
-    if (!node) return;
+  const visitor = createComplexityVisitor(cRules, hRules, { langId });
 
-    const type = node.type;
+  const nestingNodes = new Set(cRules.nestingNodes);
+  // NOTE: do NOT add functionNodes here — in function-level mode the walker
+  // walks a single function node, and adding it to nestingNodeTypes would
+  // inflate context.nestingLevel by +1 for the entire body.
 
-    // ── Halstead classification ──
-    // Propagate skip through type-annotation subtrees (e.g. TS generics, Java type params)
-    const skipH = halsteadSkip || (hRules ? hRules.skipTypes.has(type) : false);
-    if (hRules && !skipH) {
-      // Compound operators (non-leaf): count node type as operator
-      if (hRules.compoundOperators.has(type)) {
-        operators.set(type, (operators.get(type) || 0) + 1);
-      }
-      // Leaf nodes: classify as operator or operand
-      if (node.childCount === 0) {
-        if (hRules.operatorLeafTypes.has(type)) {
-          operators.set(type, (operators.get(type) || 0) + 1);
-        } else if (hRules.operandLeafTypes.has(type)) {
-          const text = node.text;
-          operands.set(text, (operands.get(text) || 0) + 1);
-        }
-      }
-    }
-
-    // ── Complexity: track nesting depth ──
-    if (nestingLevel > maxNesting) maxNesting = nestingLevel;
-
-    // Handle logical operators in binary expressions
-    if (type === cRules.logicalNodeType) {
-      const op = node.child(1)?.type;
-      if (op && cRules.logicalOperators.has(op)) {
-        cyclomatic++;
-        const parent = node.parent;
-        let sameSequence = false;
-        if (parent && parent.type === cRules.logicalNodeType) {
-          const parentOp = parent.child(1)?.type;
-          if (parentOp === op) sameSequence = true;
-        }
-        if (!sameSequence) cognitive++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false, skipH);
-        }
-        return;
-      }
-    }
-
-    // Handle optional chaining (cyclomatic only)
-    if (type === cRules.optionalChainType) {
-      cyclomatic++;
-    }
-
-    // Handle branch/control flow nodes (skip keyword leaf tokens like Ruby's `if`)
-    if (cRules.branchNodes.has(type) && node.childCount > 0) {
-      // Pattern A: else clause wraps if (JS/C#/Rust)
-      if (cRules.elseNodeType && type === cRules.elseNodeType) {
-        const firstChild = node.namedChild(0);
-        if (firstChild && firstChild.type === cRules.ifNodeType) {
-          for (let i = 0; i < node.childCount; i++) {
-            walk(node.child(i), nestingLevel, false, skipH);
-          }
-          return;
-        }
-        cognitive++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false, skipH);
-        }
-        return;
-      }
-
-      // Pattern B: explicit elif node (Python/Ruby/PHP)
-      if (cRules.elifNodeType && type === cRules.elifNodeType) {
-        cognitive++;
-        cyclomatic++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false, skipH);
-        }
-        return;
-      }
-
-      // Detect else-if via Pattern A or C
-      let isElseIf = false;
-      if (type === cRules.ifNodeType) {
-        if (cRules.elseViaAlternative) {
-          isElseIf =
-            node.parent?.type === cRules.ifNodeType &&
-            node.parent.childForFieldName('alternative')?.id === node.id;
-        } else if (cRules.elseNodeType) {
-          isElseIf = node.parent?.type === cRules.elseNodeType;
-        }
-      }
-
-      if (isElseIf) {
-        cognitive++;
-        cyclomatic++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false, skipH);
-        }
-        return;
-      }
-
-      // Regular branch node
-      cognitive += 1 + nestingLevel;
-      cyclomatic++;
-
-      // Switch-like nodes don't add cyclomatic themselves (cases do)
-      if (cRules.switchLikeNodes?.has(type)) {
-        cyclomatic--;
-      }
-
-      if (cRules.nestingNodes.has(type)) {
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel + 1, false, skipH);
-        }
-        return;
-      }
-    }
-
-    // Pattern C plain else: block that is the alternative of an if_statement (Go/Java)
-    if (
-      cRules.elseViaAlternative &&
-      type !== cRules.ifNodeType &&
-      node.parent?.type === cRules.ifNodeType &&
-      node.parent.childForFieldName('alternative')?.id === node.id
-    ) {
-      cognitive++;
-      for (let i = 0; i < node.childCount; i++) {
-        walk(node.child(i), nestingLevel, false, skipH);
-      }
-      return;
-    }
-
-    // Handle case nodes (cyclomatic only, skip keyword leaves)
-    if (cRules.caseNodes.has(type) && node.childCount > 0) {
-      cyclomatic++;
-    }
-
-    // Handle nested function definitions (increase nesting)
-    if (!isTopFunction && cRules.functionNodes.has(type)) {
-      for (let i = 0; i < node.childCount; i++) {
-        walk(node.child(i), nestingLevel + 1, false, skipH);
-      }
-      return;
-    }
-
-    // Walk children
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i), nestingLevel, false, skipH);
-    }
-  }
-
-  walk(functionNode, 0, true, false);
-
-  // ── Compute Halstead derived metrics ──
-  let halstead = null;
-  if (hRules && operators && operands) {
-    const n1 = operators.size;
-    const n2 = operands.size;
-    let bigN1 = 0;
-    for (const c of operators.values()) bigN1 += c;
-    let bigN2 = 0;
-    for (const c of operands.values()) bigN2 += c;
-
-    const vocabulary = n1 + n2;
-    const length = bigN1 + bigN2;
-    const volume = vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
-    const difficulty = n2 > 0 ? (n1 / 2) * (bigN2 / n2) : 0;
-    const effort = difficulty * volume;
-    const bugs = volume / 3000;
-
-    halstead = {
-      n1,
-      n2,
-      bigN1,
-      bigN2,
-      vocabulary,
-      length,
-      volume: +volume.toFixed(2),
-      difficulty: +difficulty.toFixed(2),
-      effort: +effort.toFixed(2),
-      bugs: +bugs.toFixed(4),
-    };
-  }
+  const results = walkWithVisitors(functionNode, [visitor], langId, {
+    nestingNodeTypes: nestingNodes,
+  });
 
-  // ── LOC metrics (text-based, cheap) ──
-  const loc = computeLOCMetrics(functionNode, langId);
+  const rawResult = results.complexity;
 
-  // ── Maintainability Index ──
-  const volume = halstead ? halstead.volume : 0;
+  // The visitor's finish() in function-level mode returns the raw metrics
+  // but without LOC (needs the functionNode text). Compute LOC + MI here.
+  const loc = _computeLOCMetrics(functionNode, langId);
+  const volume = rawResult.halstead ? rawResult.halstead.volume : 0;
   const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
-  const mi = computeMaintainabilityIndex(volume, cyclomatic, loc.sloc, commentRatio);
+  const mi = _computeMaintainabilityIndex(volume, rawResult.cyclomatic, loc.sloc, commentRatio);
 
-  return { cognitive, cyclomatic, maxNesting, halstead, loc, mi };
+  return {
+    cognitive: rawResult.cognitive,
+    cyclomatic: rawResult.cyclomatic,
+    maxNesting: rawResult.maxNesting,
+    halstead: rawResult.halstead,
+    loc,
+    mi,
+  };
 }
 
 // ─── Build-Time: Compute Metrics for Changed Files ────────────────────────
@@ -1574,34 +328,7 @@ export function computeAllMetrics(functionNode, langId) {
 /**
  * Find the function body node in a parse tree that matches a given line range.
  */
-export function findFunctionNode(rootNode, startLine, _endLine, rules) {
-  // tree-sitter lines are 0-indexed
-  const targetStart = startLine - 1;
-
-  let best = null;
-
-  function search(node) {
-    const nodeStart = node.startPosition.row;
-    const nodeEnd = node.endPosition.row;
-
-    // Prune branches outside range
-    if (nodeEnd < targetStart || nodeStart > targetStart + 1) return;
-
-    if (rules.functionNodes.has(node.type) && nodeStart === targetStart) {
-      // Found a function node at the right position — pick it
-      if (!best || nodeEnd - nodeStart < best.endPosition.row - best.startPosition.row) {
-        best = node;
-      }
-    }
-
-    for (let i = 0; i < node.childCount; i++) {
-      search(node.child(i));
-    }
-  }
-
-  search(rootNode);
-  return best;
-}
+export { _findFunctionNode as findFunctionNode };
 
 /**
  * Re-parse changed files with WASM tree-sitter, find function AST subtrees,
@@ -1635,12 +362,7 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
   if (needsFallback) {
     const { createParsers } = await import('./parser.js');
     parsers = await createParsers();
-    extToLang = new Map();
-    for (const entry of LANGUAGE_REGISTRY) {
-      for (const ext of entry.extensions) {
-        extToLang.set(ext, entry.id);
-      }
-    }
+    extToLang = buildExtToLangMap();
   }
 
   const { getParser } = await import('./parser.js');
@@ -1655,10 +377,6 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
       maintainability_index)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
-  const getNodeId = db.prepare(
-    "SELECT id FROM nodes WHERE name = ? AND kind IN ('function','method') AND file = ? AND line = ?",
-  );
-
   let analyzed = 0;
 
   const tx = db.transaction(() => {
@@ -1705,12 +423,12 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
 
         // Use pre-computed complexity from native engine if available
         if (def.complexity) {
-          const row = getNodeId.get(def.name, relPath, def.line);
-          if (!row) continue;
+          const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+          if (!nodeId) continue;
           const ch = def.complexity.halstead;
           const cl = def.complexity.loc;
           upsert.run(
-            row.id,
+            nodeId,
             def.complexity.cognitive,
             def.complexity.cyclomatic,
             def.complexity.maxNesting ?? 0,
@@ -1743,12 +461,12 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
         const metrics = computeAllMetrics(funcNode, langId);
         if (!metrics) continue;
 
-        const row = getNodeId.get(def.name, relPath, def.line);
-        if (!row) continue;
+        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+        if (!nodeId) continue;
 
         const h = metrics.halstead;
         upsert.run(
-          row.id,
+          nodeId,
           metrics.cognitive,
           metrics.cyclomatic,
           metrics.maxNesting,
@@ -1797,204 +515,211 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
  */
 export function complexityData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
-  const sort = opts.sort || 'cognitive';
-  const noTests = opts.noTests || false;
-  const aboveThreshold = opts.aboveThreshold || false;
-  const target = opts.target || null;
-  const fileFilter = opts.file || null;
-  const kindFilter = opts.kind || null;
-
-  // Load thresholds from config
-  const config = loadConfig(process.cwd());
-  const thresholds = config.manifesto?.rules || {
-    cognitive: { warn: 15, fail: null },
-    cyclomatic: { warn: 10, fail: null },
-    maxNesting: { warn: 4, fail: null },
-    maintainabilityIndex: { warn: 20, fail: null },
-  };
+  try {
+    const sort = opts.sort || 'cognitive';
+    const noTests = opts.noTests || false;
+    const aboveThreshold = opts.aboveThreshold || false;
+    const target = opts.target || null;
+    const fileFilter = opts.file || null;
+    const kindFilter = opts.kind || null;
+
+    // Load thresholds from config
+    const config = loadConfig(process.cwd());
+    const thresholds = config.manifesto?.rules || {
+      cognitive: { warn: 15, fail: null },
+      cyclomatic: { warn: 10, fail: null },
+      maxNesting: { warn: 4, fail: null },
+      maintainabilityIndex: { warn: 20, fail: null },
+    };
 
-  // Build query
-  let where = "WHERE n.kind IN ('function','method')";
-  const params = [];
+    // Build query
+    let where = "WHERE n.kind IN ('function','method')";
+    const params = [];
 
-  if (noTests) {
-    where += ` AND n.file NOT LIKE '%.test.%'
+    if (noTests) {
+      where += ` AND n.file NOT LIKE '%.test.%'
        AND n.file NOT LIKE '%.spec.%'
        AND n.file NOT LIKE '%__test__%'
        AND n.file NOT LIKE '%__tests__%'
        AND n.file NOT LIKE '%.stories.%'`;
-  }
-  if (target) {
-    where += ' AND n.name LIKE ?';
-    params.push(`%${target}%`);
-  }
-  if (fileFilter) {
-    where += ' AND n.file LIKE ?';
-    params.push(`%${fileFilter}%`);
-  }
-  if (kindFilter) {
-    where += ' AND n.kind = ?';
-    params.push(kindFilter);
-  }
-
-  const isValidThreshold = (v) => typeof v === 'number' && Number.isFinite(v);
-
-  let having = '';
-  if (aboveThreshold) {
-    const conditions = [];
-    if (isValidThreshold(thresholds.cognitive?.warn)) {
-      conditions.push(`fc.cognitive >= ${thresholds.cognitive.warn}`);
     }
-    if (isValidThreshold(thresholds.cyclomatic?.warn)) {
-      conditions.push(`fc.cyclomatic >= ${thresholds.cyclomatic.warn}`);
+    if (target) {
+      where += ' AND n.name LIKE ?';
+      params.push(`%${target}%`);
     }
-    if (isValidThreshold(thresholds.maxNesting?.warn)) {
-      conditions.push(`fc.max_nesting >= ${thresholds.maxNesting.warn}`);
+    if (fileFilter) {
+      where += ' AND n.file LIKE ?';
+      params.push(`%${fileFilter}%`);
     }
-    if (isValidThreshold(thresholds.maintainabilityIndex?.warn)) {
-      conditions.push(
-        `fc.maintainability_index > 0 AND fc.maintainability_index <= ${thresholds.maintainabilityIndex.warn}`,
-      );
+    if (kindFilter) {
+      where += ' AND n.kind = ?';
+      params.push(kindFilter);
     }
-    if (conditions.length > 0) {
-      having = `AND (${conditions.join(' OR ')})`;
+
+    const isValidThreshold = (v) => typeof v === 'number' && Number.isFinite(v);
+
+    let having = '';
+    if (aboveThreshold) {
+      const conditions = [];
+      if (isValidThreshold(thresholds.cognitive?.warn)) {
+        conditions.push(`fc.cognitive >= ${thresholds.cognitive.warn}`);
+      }
+      if (isValidThreshold(thresholds.cyclomatic?.warn)) {
+        conditions.push(`fc.cyclomatic >= ${thresholds.cyclomatic.warn}`);
+      }
+      if (isValidThreshold(thresholds.maxNesting?.warn)) {
+        conditions.push(`fc.max_nesting >= ${thresholds.maxNesting.warn}`);
+      }
+      if (isValidThreshold(thresholds.maintainabilityIndex?.warn)) {
+        conditions.push(
+          `fc.maintainability_index > 0 AND fc.maintainability_index <= ${thresholds.maintainabilityIndex.warn}`,
+        );
+      }
+      if (conditions.length > 0) {
+        having = `AND (${conditions.join(' OR ')})`;
+      }
     }
-  }
 
-  const orderMap = {
-    cognitive: 'fc.cognitive DESC',
-    cyclomatic: 'fc.cyclomatic DESC',
-    nesting: 'fc.max_nesting DESC',
-    mi: 'fc.maintainability_index ASC',
-    volume: 'fc.halstead_volume DESC',
-    effort: 'fc.halstead_effort DESC',
-    bugs: 'fc.halstead_bugs DESC',
-    loc: 'fc.loc DESC',
-  };
-  const orderBy = orderMap[sort] || 'fc.cognitive DESC';
+    const orderMap = {
+      cognitive: 'fc.cognitive DESC',
+      cyclomatic: 'fc.cyclomatic DESC',
+      nesting: 'fc.max_nesting DESC',
+      mi: 'fc.maintainability_index ASC',
+      volume: 'fc.halstead_volume DESC',
+      effort: 'fc.halstead_effort DESC',
+      bugs: 'fc.halstead_bugs DESC',
+      loc: 'fc.loc DESC',
+    };
+    const orderBy = orderMap[sort] || 'fc.cognitive DESC';
 
-  let rows;
-  try {
-    rows = db
-      .prepare(
-        `SELECT n.name, n.kind, n.file, n.line, n.end_line,
-              fc.cognitive, fc.cyclomatic, fc.max_nesting,
-              fc.loc, fc.sloc, fc.maintainability_index,
-              fc.halstead_volume, fc.halstead_difficulty, fc.halstead_effort, fc.halstead_bugs
-       FROM function_complexity fc
-       JOIN nodes n ON fc.node_id = n.id
-       ${where} ${having}
-       ORDER BY ${orderBy}`,
-      )
-      .all(...params);
-  } catch {
-    // Check if graph has nodes even though complexity table is missing/empty
-    let hasGraph = false;
+    let rows;
     try {
-      hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+      rows = db
+        .prepare(
+          `SELECT n.name, n.kind, n.file, n.line, n.end_line,
+                fc.cognitive, fc.cyclomatic, fc.max_nesting,
+                fc.loc, fc.sloc, fc.maintainability_index,
+                fc.halstead_volume, fc.halstead_difficulty, fc.halstead_effort, fc.halstead_bugs
+         FROM function_complexity fc
+         JOIN nodes n ON fc.node_id = n.id
+         ${where} ${having}
+         ORDER BY ${orderBy}`,
+        )
+        .all(...params);
     } catch {
-      /* ignore */
+      // Check if graph has nodes even though complexity table is missing/empty
+      let hasGraph = false;
+      try {
+        hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+      } catch {
+        /* ignore */
+      }
+      return { functions: [], summary: null, thresholds, hasGraph };
     }
-    db.close();
-    return { functions: [], summary: null, thresholds, hasGraph };
-  }
-
-  // Post-filter test files if needed (belt-and-suspenders for isTestFile)
-  const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
 
-  const functions = filtered.map((r) => {
-    const exceeds = [];
-    if (isValidThreshold(thresholds.cognitive?.warn) && r.cognitive >= thresholds.cognitive.warn)
-      exceeds.push('cognitive');
-    if (isValidThreshold(thresholds.cyclomatic?.warn) && r.cyclomatic >= thresholds.cyclomatic.warn)
-      exceeds.push('cyclomatic');
-    if (
-      isValidThreshold(thresholds.maxNesting?.warn) &&
-      r.max_nesting >= thresholds.maxNesting.warn
-    )
-      exceeds.push('maxNesting');
-    if (
-      isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
-      r.maintainability_index > 0 &&
-      r.maintainability_index <= thresholds.maintainabilityIndex.warn
-    )
-      exceeds.push('maintainabilityIndex');
-
-    return {
-      name: r.name,
-      kind: r.kind,
-      file: r.file,
-      line: r.line,
-      endLine: r.end_line || null,
-      cognitive: r.cognitive,
-      cyclomatic: r.cyclomatic,
-      maxNesting: r.max_nesting,
-      loc: r.loc || 0,
-      sloc: r.sloc || 0,
-      maintainabilityIndex: r.maintainability_index || 0,
-      halstead: {
-        volume: r.halstead_volume || 0,
-        difficulty: r.halstead_difficulty || 0,
-        effort: r.halstead_effort || 0,
-        bugs: r.halstead_bugs || 0,
-      },
-      exceeds: exceeds.length > 0 ? exceeds : undefined,
-    };
-  });
+    // Post-filter test files if needed (belt-and-suspenders for isTestFile)
+    const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
 
-  // Summary stats
-  let summary = null;
-  try {
-    const allRows = db
-      .prepare(
-        `SELECT fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.maintainability_index
-       FROM function_complexity fc JOIN nodes n ON fc.node_id = n.id
-       WHERE n.kind IN ('function','method')
-       ${noTests ? `AND n.file NOT LIKE '%.test.%' AND n.file NOT LIKE '%.spec.%' AND n.file NOT LIKE '%__test__%' AND n.file NOT LIKE '%__tests__%' AND n.file NOT LIKE '%.stories.%'` : ''}`,
+    const functions = filtered.map((r) => {
+      const exceeds = [];
+      if (isValidThreshold(thresholds.cognitive?.warn) && r.cognitive >= thresholds.cognitive.warn)
+        exceeds.push('cognitive');
+      if (
+        isValidThreshold(thresholds.cyclomatic?.warn) &&
+        r.cyclomatic >= thresholds.cyclomatic.warn
+      )
+        exceeds.push('cyclomatic');
+      if (
+        isValidThreshold(thresholds.maxNesting?.warn) &&
+        r.max_nesting >= thresholds.maxNesting.warn
       )
-      .all();
-
-    if (allRows.length > 0) {
-      const miValues = allRows.map((r) => r.maintainability_index || 0);
-      summary = {
-        analyzed: allRows.length,
-        avgCognitive: +(allRows.reduce((s, r) => s + r.cognitive, 0) / allRows.length).toFixed(1),
-        avgCyclomatic: +(allRows.reduce((s, r) => s + r.cyclomatic, 0) / allRows.length).toFixed(1),
-        maxCognitive: Math.max(...allRows.map((r) => r.cognitive)),
-        maxCyclomatic: Math.max(...allRows.map((r) => r.cyclomatic)),
-        avgMI: +(miValues.reduce((s, v) => s + v, 0) / miValues.length).toFixed(1),
-        minMI: +Math.min(...miValues).toFixed(1),
-        aboveWarn: allRows.filter(
-          (r) =>
-            (isValidThreshold(thresholds.cognitive?.warn) &&
-              r.cognitive >= thresholds.cognitive.warn) ||
-            (isValidThreshold(thresholds.cyclomatic?.warn) &&
-              r.cyclomatic >= thresholds.cyclomatic.warn) ||
-            (isValidThreshold(thresholds.maxNesting?.warn) &&
-              r.max_nesting >= thresholds.maxNesting.warn) ||
-            (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
-              r.maintainability_index > 0 &&
-              r.maintainability_index <= thresholds.maintainabilityIndex.warn),
-        ).length,
+        exceeds.push('maxNesting');
+      if (
+        isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
+        r.maintainability_index > 0 &&
+        r.maintainability_index <= thresholds.maintainabilityIndex.warn
+      )
+        exceeds.push('maintainabilityIndex');
+
+      return {
+        name: r.name,
+        kind: r.kind,
+        file: r.file,
+        line: r.line,
+        endLine: r.end_line || null,
+        cognitive: r.cognitive,
+        cyclomatic: r.cyclomatic,
+        maxNesting: r.max_nesting,
+        loc: r.loc || 0,
+        sloc: r.sloc || 0,
+        maintainabilityIndex: r.maintainability_index || 0,
+        halstead: {
+          volume: r.halstead_volume || 0,
+          difficulty: r.halstead_difficulty || 0,
+          effort: r.halstead_effort || 0,
+          bugs: r.halstead_bugs || 0,
+        },
+        exceeds: exceeds.length > 0 ? exceeds : undefined,
       };
-    }
-  } catch {
-    /* ignore */
-  }
+    });
 
-  // When summary is null (no complexity rows), check if graph has nodes
-  let hasGraph = false;
-  if (summary === null) {
+    // Summary stats
+    let summary = null;
     try {
-      hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+      const allRows = db
+        .prepare(
+          `SELECT fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.maintainability_index
+         FROM function_complexity fc JOIN nodes n ON fc.node_id = n.id
+         WHERE n.kind IN ('function','method')
+         ${noTests ? `AND n.file NOT LIKE '%.test.%' AND n.file NOT LIKE '%.spec.%' AND n.file NOT LIKE '%__test__%' AND n.file NOT LIKE '%__tests__%' AND n.file NOT LIKE '%.stories.%'` : ''}`,
+        )
+        .all();
+
+      if (allRows.length > 0) {
+        const miValues = allRows.map((r) => r.maintainability_index || 0);
+        summary = {
+          analyzed: allRows.length,
+          avgCognitive: +(allRows.reduce((s, r) => s + r.cognitive, 0) / allRows.length).toFixed(1),
+          avgCyclomatic: +(allRows.reduce((s, r) => s + r.cyclomatic, 0) / allRows.length).toFixed(
+            1,
+          ),
+          maxCognitive: Math.max(...allRows.map((r) => r.cognitive)),
+          maxCyclomatic: Math.max(...allRows.map((r) => r.cyclomatic)),
+          avgMI: +(miValues.reduce((s, v) => s + v, 0) / miValues.length).toFixed(1),
+          minMI: +Math.min(...miValues).toFixed(1),
+          aboveWarn: allRows.filter(
+            (r) =>
+              (isValidThreshold(thresholds.cognitive?.warn) &&
+                r.cognitive >= thresholds.cognitive.warn) ||
+              (isValidThreshold(thresholds.cyclomatic?.warn) &&
+                r.cyclomatic >= thresholds.cyclomatic.warn) ||
+              (isValidThreshold(thresholds.maxNesting?.warn) &&
+                r.max_nesting >= thresholds.maxNesting.warn) ||
+              (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
+                r.maintainability_index > 0 &&
+                r.maintainability_index <= thresholds.maintainabilityIndex.warn),
+          ).length,
+        };
+      }
     } catch {
       /* ignore */
     }
-  }
 
-  db.close();
-  const base = { functions, summary, thresholds, hasGraph };
-  return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
+    // When summary is null (no complexity rows), check if graph has nodes
+    let hasGraph = false;
+    if (summary === null) {
+      try {
+        hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+      } catch {
+        /* ignore */
+      }
+    }
+
+    const base = { functions, summary, thresholds, hasGraph };
+    return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
 }
 
 /**
@@ -2076,85 +801,3 @@ export function* iterComplexity(customDbPath, opts = {}) {
     db.close();
   }
 }
-
-/**
- * Format complexity output for CLI display.
- */
-export function complexity(customDbPath, opts = {}) {
-  const data = complexityData(customDbPath, opts);
-
-  if (opts.ndjson) {
-    printNdjson(data, 'functions');
-    return;
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
-
-  if (data.functions.length === 0) {
-    if (data.summary === null) {
-      if (data.hasGraph) {
-        console.log(
-          '\nNo complexity data found, but a graph exists. Run "codegraph build --no-incremental" to populate complexity metrics.\n',
-        );
-      } else {
-        console.log(
-          '\nNo complexity data found. Run "codegraph build" first to analyze your codebase.\n',
-        );
-      }
-    } else {
-      console.log('\nNo functions match the given filters.\n');
-    }
-    return;
-  }
-
-  const header = opts.aboveThreshold ? 'Functions Above Threshold' : 'Function Complexity';
-  console.log(`\n# ${header}\n`);
-
-  if (opts.health) {
-    // Health-focused view with Halstead + MI columns
-    console.log(
-      `  ${'Function'.padEnd(35)} ${'File'.padEnd(25)} ${'MI'.padStart(5)} ${'Vol'.padStart(7)} ${'Diff'.padStart(6)} ${'Effort'.padStart(9)} ${'Bugs'.padStart(6)} ${'LOC'.padStart(5)} ${'SLOC'.padStart(5)}`,
-    );
-    console.log(
-      `  ${'─'.repeat(35)} ${'─'.repeat(25)} ${'─'.repeat(5)} ${'─'.repeat(7)} ${'─'.repeat(6)} ${'─'.repeat(9)} ${'─'.repeat(6)} ${'─'.repeat(5)} ${'─'.repeat(5)}`,
-    );
-
-    for (const fn of data.functions) {
-      const name = fn.name.length > 33 ? `${fn.name.slice(0, 32)}…` : fn.name;
-      const file = fn.file.length > 23 ? `…${fn.file.slice(-22)}` : fn.file;
-      const miWarn = fn.exceeds?.includes('maintainabilityIndex') ? '!' : ' ';
-      console.log(
-        `  ${name.padEnd(35)} ${file.padEnd(25)} ${String(fn.maintainabilityIndex).padStart(5)}${miWarn}${String(fn.halstead.volume).padStart(7)} ${String(fn.halstead.difficulty).padStart(6)} ${String(fn.halstead.effort).padStart(9)} ${String(fn.halstead.bugs).padStart(6)} ${String(fn.loc).padStart(5)} ${String(fn.sloc).padStart(5)}`,
-      );
-    }
-  } else {
-    // Default view with MI column appended
-    console.log(
-      `  ${'Function'.padEnd(40)} ${'File'.padEnd(30)} ${'Cog'.padStart(4)} ${'Cyc'.padStart(4)} ${'Nest'.padStart(5)} ${'MI'.padStart(5)}`,
-    );
-    console.log(
-      `  ${'─'.repeat(40)} ${'─'.repeat(30)} ${'─'.repeat(4)} ${'─'.repeat(4)} ${'─'.repeat(5)} ${'─'.repeat(5)}`,
-    );
-
-    for (const fn of data.functions) {
-      const name = fn.name.length > 38 ? `${fn.name.slice(0, 37)}…` : fn.name;
-      const file = fn.file.length > 28 ? `…${fn.file.slice(-27)}` : fn.file;
-      const warn = fn.exceeds ? ' !' : '';
-      const mi = fn.maintainabilityIndex > 0 ? String(fn.maintainabilityIndex) : '-';
-      console.log(
-        `  ${name.padEnd(40)} ${file.padEnd(30)} ${String(fn.cognitive).padStart(4)} ${String(fn.cyclomatic).padStart(4)} ${String(fn.maxNesting).padStart(5)} ${mi.padStart(5)}${warn}`,
-      );
-    }
-  }
-
-  if (data.summary) {
-    const s = data.summary;
-    const miPart = s.avgMI != null ? ` | avg MI: ${s.avgMI}` : '';
-    console.log(
-      `\n  ${s.analyzed} functions analyzed | avg cognitive: ${s.avgCognitive} | avg cyclomatic: ${s.avgCyclomatic}${miPart} | ${s.aboveWarn} above threshold`,
-    );
-  }
-  console.log();
-}