@optave/codegraph 3.2.0 → 3.3.1

package/dist/features/complexity.js

@@ -0,0 +1,683 @@
+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();
+    }
+}
+//# sourceMappingURL=complexity.js.map