@optave/codegraph 3.3.1 → 3.4.1

package/src/features/complexity.js

@@ -1,814 +0,0 @@
-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 { getFunctionNodeId, openReadonlyOrFail } from '../db/index.js';
-import { buildFileConditionSQL } from '../db/query-builder.js';
-import { loadConfig } from '../infrastructure/config.js';
-import { debug, info } from '../infrastructure/logger.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
-import { paginateResult } from '../shared/paginate.js';
-
-// Re-export rules for backward compatibility
-export { COMPLEXITY_RULES, HALSTEAD_RULES };
-
-// Extensions whose language has complexity rules — used to skip needless WASM init
-const COMPLEXITY_EXTENSIONS = buildExtensionSet(COMPLEXITY_RULES);
-
-// ─── Halstead Metrics Computation ─────────────────────────────────────────
-
-/**
- * Compute Halstead metrics for a function's AST subtree.
- *
- * @param {object} functionNode - tree-sitter node for the function
- * @param {string} language - Language ID
- * @returns {{ n1: number, n2: number, bigN1: number, bigN2: number, vocabulary: number, length: number, volume: number, difficulty: number, effort: number, bugs: number } | null}
- */
-export function computeHalsteadMetrics(functionNode, language) {
-  const rules = HALSTEAD_RULES.get(language);
-  if (!rules) return null;
-
-  const operators = new Map(); // type -> count
-  const operands = new Map(); // text -> count
-
-  function walk(node) {
-    if (!node) return;
-
-    // Skip type annotation subtrees
-    if (rules.skipTypes.has(node.type)) return;
-
-    // Compound operators (non-leaf): count the node type as an operator
-    if (rules.compoundOperators.has(node.type)) {
-      operators.set(node.type, (operators.get(node.type) || 0) + 1);
-    }
-
-    // Leaf nodes: classify as operator or operand
-    if (node.childCount === 0) {
-      if (rules.operatorLeafTypes.has(node.type)) {
-        operators.set(node.type, (operators.get(node.type) || 0) + 1);
-      } else if (rules.operandLeafTypes.has(node.type)) {
-        const text = node.text;
-        operands.set(text, (operands.get(text) || 0) + 1);
-      }
-    }
-
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i));
-    }
-  }
-
-  walk(functionNode);
-
-  const n1 = operators.size; // distinct operators
-  const n2 = operands.size; // distinct operands
-  let bigN1 = 0; // total operators
-  for (const c of operators.values()) bigN1 += c;
-  let bigN2 = 0; // total operands
-  for (const c of operands.values()) bigN2 += c;
-
-  const vocabulary = n1 + n2;
-  const length = bigN1 + bigN2;
-
-  // Guard against zero
-  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;
-
-  return {
-    n1,
-    n2,
-    bigN1,
-    bigN2,
-    vocabulary,
-    length,
-    volume: +volume.toFixed(2),
-    difficulty: +difficulty.toFixed(2),
-    effort: +effort.toFixed(2),
-    bugs: +bugs.toFixed(4),
-  };
-}
-
-// ─── LOC Metrics Computation ──────────────────────────────────────────────
-// Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
-export const computeLOCMetrics = _computeLOCMetrics;
-
-// ─── Maintainability Index ────────────────────────────────────────────────
-// Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
-export const computeMaintainabilityIndex = _computeMaintainabilityIndex;
-
-// ─── Algorithm: Single-Traversal DFS ──────────────────────────────────────
-
-/**
- * Compute cognitive complexity, cyclomatic complexity, and max nesting depth
- * for a function's AST subtree in a single DFS walk.
- *
- * @param {object} functionNode - tree-sitter node for the function body
- * @param {string} language - Language ID (e.g. 'javascript', 'typescript')
- * @returns {{ cognitive: number, cyclomatic: number, maxNesting: number } | null}
- */
-export function computeFunctionComplexity(functionNode, language) {
-  const rules = COMPLEXITY_RULES.get(language);
-  if (!rules) return null;
-
-  let cognitive = 0;
-  let cyclomatic = 1; // McCabe starts at 1
-  let maxNesting = 0;
-
-  function walk(node, nestingLevel, isTopFunction) {
-    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;
-      }
-    }
-
-    // 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;
-      }
-
-      // 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;
-      }
-
-      // 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 (isElseIf) {
-        cognitive++;
-        cyclomatic++;
-        for (let i = 0; i < node.childCount; i++) {
-          walk(node.child(i), nestingLevel, false);
-        }
-        return;
-      }
-
-      // 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);
-      }
-      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);
-    }
-  }
-
-  walk(functionNode, 0, true);
-
-  return { cognitive, cyclomatic, maxNesting };
-}
-
-// ─── Merged Single-Pass Computation ───────────────────────────────────────
-
-/**
- * Compute all metrics (complexity + Halstead + LOC + MI) in a single DFS walk.
- * Merges computeFunctionComplexity and computeHalsteadMetrics into one tree
- * 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}
- */
-export function computeAllMetrics(functionNode, langId) {
-  const cRules = COMPLEXITY_RULES.get(langId);
-  if (!cRules) return null;
-  const hRules = HALSTEAD_RULES.get(langId);
-
-  const visitor = createComplexityVisitor(cRules, hRules, { langId });
-
-  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.
-
-  const results = walkWithVisitors(functionNode, [visitor], langId, {
-    nestingNodeTypes: nestingNodes,
-  });
-
-  const rawResult = results.complexity;
-
-  // 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, rawResult.cyclomatic, loc.sloc, commentRatio);
-
-  return {
-    cognitive: rawResult.cognitive,
-    cyclomatic: rawResult.cyclomatic,
-    maxNesting: rawResult.maxNesting,
-    halstead: rawResult.halstead,
-    loc,
-    mi,
-  };
-}
-
-// ─── Build-Time: Compute Metrics for Changed Files ────────────────────────
-
-/**
- * Find the function body node in a parse tree that matches a given line range.
- */
-export { _findFunctionNode as findFunctionNode };
-
-async function initWasmParsersIfNeeded(fileSymbols) {
-  for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) {
-      const ext = path.extname(relPath).toLowerCase();
-      if (!COMPLEXITY_EXTENSIONS.has(ext)) continue;
-      const hasPrecomputed = symbols.definitions.every(
-        (d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity,
-      );
-      if (!hasPrecomputed) {
-        const { createParsers } = await import('../domain/parser.js');
-        const parsers = await createParsers();
-        const extToLang = buildExtToLangMap();
-        return { parsers, extToLang };
-      }
-    }
-  }
-  return { parsers: null, extToLang: null };
-}
-
-function getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser) {
-  let tree = symbols._tree;
-  let langId = symbols._langId;
-
-  const allPrecomputed = symbols.definitions.every(
-    (d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity,
-  );
-
-  if (!allPrecomputed && !tree) {
-    const ext = path.extname(relPath).toLowerCase();
-    if (!COMPLEXITY_EXTENSIONS.has(ext)) return null;
-    if (!extToLang) return null;
-    langId = extToLang.get(ext);
-    if (!langId) return null;
-
-    const absPath = path.join(rootDir, relPath);
-    let code;
-    try {
-      code = fs.readFileSync(absPath, 'utf-8');
-    } catch (e) {
-      debug(`complexity: cannot read ${relPath}: ${e.message}`);
-      return null;
-    }
-
-    const parser = getParser(parsers, absPath);
-    if (!parser) return null;
-
-    try {
-      tree = parser.parse(code);
-    } catch (e) {
-      debug(`complexity: parse failed for ${relPath}: ${e.message}`);
-      return null;
-    }
-  }
-
-  return { tree, langId };
-}
-
-function upsertPrecomputedComplexity(db, upsert, def, relPath) {
-  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-  if (!nodeId) return 0;
-  const ch = def.complexity.halstead;
-  const cl = def.complexity.loc;
-  upsert.run(
-    nodeId,
-    def.complexity.cognitive,
-    def.complexity.cyclomatic,
-    def.complexity.maxNesting ?? 0,
-    cl ? cl.loc : 0,
-    cl ? cl.sloc : 0,
-    cl ? cl.commentLines : 0,
-    ch ? ch.n1 : 0,
-    ch ? ch.n2 : 0,
-    ch ? ch.bigN1 : 0,
-    ch ? ch.bigN2 : 0,
-    ch ? ch.vocabulary : 0,
-    ch ? ch.length : 0,
-    ch ? ch.volume : 0,
-    ch ? ch.difficulty : 0,
-    ch ? ch.effort : 0,
-    ch ? ch.bugs : 0,
-    def.complexity.maintainabilityIndex ?? 0,
-  );
-  return 1;
-}
-
-function upsertAstComplexity(db, upsert, def, relPath, tree, langId, rules) {
-  if (!tree || !rules) return 0;
-
-  const funcNode = _findFunctionNode(tree.rootNode, def.line, def.endLine, rules);
-  if (!funcNode) return 0;
-
-  const metrics = computeAllMetrics(funcNode, langId);
-  if (!metrics) return 0;
-
-  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-  if (!nodeId) return 0;
-
-  const h = metrics.halstead;
-  upsert.run(
-    nodeId,
-    metrics.cognitive,
-    metrics.cyclomatic,
-    metrics.maxNesting,
-    metrics.loc.loc,
-    metrics.loc.sloc,
-    metrics.loc.commentLines,
-    h ? h.n1 : 0,
-    h ? h.n2 : 0,
-    h ? h.bigN1 : 0,
-    h ? h.bigN2 : 0,
-    h ? h.vocabulary : 0,
-    h ? h.length : 0,
-    h ? h.volume : 0,
-    h ? h.difficulty : 0,
-    h ? h.effort : 0,
-    h ? h.bugs : 0,
-    metrics.mi,
-  );
-  return 1;
-}
-
-/**
- * Re-parse changed files with WASM tree-sitter, find function AST subtrees,
- * compute complexity, and upsert into function_complexity table.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, ... }>
- * @param {string} rootDir - absolute project root path
- * @param {object} [engineOpts] - engine options (unused; always uses WASM for AST)
- */
-export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOpts) {
-  const { parsers, extToLang } = await initWasmParsersIfNeeded(fileSymbols);
-  const { getParser } = await import('../domain/parser.js');
-
-  const upsert = db.prepare(
-    `INSERT OR REPLACE INTO function_complexity
-     (node_id, cognitive, cyclomatic, max_nesting,
-      loc, sloc, comment_lines,
-      halstead_n1, halstead_n2, halstead_big_n1, halstead_big_n2,
-      halstead_vocabulary, halstead_length, halstead_volume,
-      halstead_difficulty, halstead_effort, halstead_bugs,
-      maintainability_index)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  );
-  let analyzed = 0;
-
-  const tx = db.transaction(() => {
-    for (const [relPath, symbols] of fileSymbols) {
-      const result = getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser);
-      const tree = result ? result.tree : null;
-      const langId = result ? result.langId : null;
-
-      const rules = langId ? COMPLEXITY_RULES.get(langId) : null;
-
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-
-        if (def.complexity) {
-          analyzed += upsertPrecomputedComplexity(db, upsert, def, relPath);
-        } else {
-          analyzed += upsertAstComplexity(db, upsert, def, relPath, tree, langId, rules);
-        }
-      }
-    }
-  });
-
-  tx();
-
-  if (analyzed > 0) {
-    info(`Complexity: ${analyzed} functions analyzed`);
-  }
-}
-
-// ─── Query-Time Functions ─────────────────────────────────────────────────
-
-/**
- * Return structured complexity data for querying.
- *
- * @param {string} [customDbPath] - Path to graph.db
- * @param {object} [opts] - Options
- * @param {string} [opts.target] - Function name filter (partial match)
- * @param {number} [opts.limit] - Max results (default: 20)
- * @param {string} [opts.sort] - Sort by: cognitive | cyclomatic | nesting (default: cognitive)
- * @param {boolean} [opts.aboveThreshold] - Only functions above warn thresholds
- * @param {string} [opts.file] - Filter by file (partial match)
- * @param {string} [opts.kind] - Filter by symbol kind
- * @param {boolean} [opts.noTests] - Exclude test files
- * @returns {{ functions: object[], summary: object, thresholds: object }}
- */
-export function complexityData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
-  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 = opts.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 = [];
-
-    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}%`);
-    }
-    {
-      const fc = buildFileConditionSQL(fileFilter, 'n.file');
-      where += fc.sql;
-      params.push(...fc.params);
-    }
-    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 (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';
-
-    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 (e) {
-      debug(`complexity query failed (table may not exist): ${e.message}`);
-      // 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 (e2) {
-        debug(`nodes table check failed: ${e2.message}`);
-      }
-      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,
-      };
-    });
-
-    // 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.%'` : ''}`,
-        )
-        .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 (e) {
-      debug(`complexity summary query failed: ${e.message}`);
-    }
-
-    // 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 (e) {
-        debug(`nodes table check failed: ${e.message}`);
-      }
-    }
-
-    const base = { functions, summary, thresholds, hasGraph };
-    return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
-}
-
-/**
- * Generator: stream complexity rows one-by-one using .iterate() for memory efficiency.
- * @param {string} [customDbPath]
- * @param {object} [opts]
- * @param {boolean} [opts.noTests]
- * @param {string} [opts.file]
- * @param {string} [opts.target]
- * @param {string} [opts.kind]
- * @param {string} [opts.sort]
- * @yields {{ name: string, kind: string, file: string, line: number, cognitive: number, cyclomatic: number, maxNesting: number, loc: number, sloc: number }}
- */
-export function* iterComplexity(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
-    const noTests = opts.noTests || false;
-    const sort = opts.sort || 'cognitive';
-
-    let where = "WHERE n.kind IN ('function','method')";
-    const params = [];
-
-    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 (opts.target) {
-      where += ' AND n.name LIKE ?';
-      params.push(`%${opts.target}%`);
-    }
-    {
-      const fc = buildFileConditionSQL(opts.file, 'n.file');
-      where += fc.sql;
-      params.push(...fc.params);
-    }
-    if (opts.kind) {
-      where += ' AND n.kind = ?';
-      params.push(opts.kind);
-    }
-
-    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 stmt = 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
-       FROM function_complexity fc
-       JOIN nodes n ON fc.node_id = n.id
-       ${where}
-       ORDER BY ${orderBy}`,
-    );
-    for (const r of stmt.iterate(...params)) {
-      if (noTests && isTestFile(r.file)) continue;
-      yield {
-        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,
-      };
-    }
-  } finally {
-    db.close();
-  }
-}