@optave/codegraph 3.3.0 → 3.4.0

package/dist/features/complexity.d.ts

@@ -1,127 +1,74 @@
-/**
- * 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: object, language: string): {
-    n1: number;
-    n2: number;
-    bigN1: number;
-    bigN2: number;
-    vocabulary: number;
-    length: number;
-    volume: number;
-    difficulty: number;
-    effort: number;
-    bugs: number;
-} | null;
-/**
- * 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: object, language: string): {
+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 } from '../ast-analysis/shared.js';
+import type { BetterSqlite3Database, CodegraphConfig, HalsteadDerivedMetrics, LOCMetrics, TreeSitterNode } from '../types.js';
+export { COMPLEXITY_RULES, HALSTEAD_RULES };
+export declare function computeHalsteadMetrics(functionNode: TreeSitterNode, language: string): HalsteadDerivedMetrics | null;
+export declare const computeLOCMetrics: typeof _computeLOCMetrics;
+export declare const computeMaintainabilityIndex: typeof _computeMaintainabilityIndex;
+export declare function computeFunctionComplexity(functionNode: TreeSitterNode, language: string): {
     cognitive: number;
     cyclomatic: number;
     maxNesting: number;
 } | null;
-/**
- * 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: object, langId: string): {
+interface AllMetricsResult {
     cognitive: number;
     cyclomatic: number;
     maxNesting: number;
-    halstead: object | null;
-    loc: object;
+    halstead: HalsteadDerivedMetrics | null;
+    loc: LOCMetrics;
     mi: number;
-} | null;
-/**
- * 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 function buildComplexityMetrics(db: object, fileSymbols: Map<string, object>, rootDir: string, _engineOpts: any): Promise<void>;
-/**
- * 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?: string, opts?: {
-    target?: string | undefined;
-    limit?: number | undefined;
-    sort?: string | undefined;
-    aboveThreshold?: boolean | undefined;
-    file?: string | undefined;
-    kind?: string | undefined;
-    noTests?: boolean | undefined;
-}): {
-    functions: object[];
-    summary: object;
-    thresholds: object;
-};
-/**
- * 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?: string, opts?: {
-    noTests?: boolean | undefined;
-    file?: string | undefined;
-    target?: string | undefined;
-    kind?: string | undefined;
-    sort?: string | undefined;
+}
+export declare function computeAllMetrics(functionNode: TreeSitterNode, langId: string): AllMetricsResult | null;
+export { _findFunctionNode as findFunctionNode };
+interface FileSymbols {
+    _tree?: {
+        rootNode: TreeSitterNode;
+    } | null;
+    _langId?: string | null;
+    definitions: Array<{
+        name: string;
+        kind: string;
+        line: number;
+        endLine?: number;
+        complexity?: {
+            cognitive: number;
+            cyclomatic: number;
+            maxNesting?: number;
+            maintainabilityIndex?: number;
+            halstead?: HalsteadDerivedMetrics | null;
+            loc?: LOCMetrics | null;
+        };
+    }>;
+}
+export declare function buildComplexityMetrics(db: BetterSqlite3Database, fileSymbols: Map<string, FileSymbols>, rootDir: string, _engineOpts?: unknown): Promise<void>;
+export declare function complexityData(customDbPath?: string, opts?: {
+    target?: string;
+    limit?: number;
+    sort?: string;
+    aboveThreshold?: boolean;
+    file?: string;
+    kind?: string;
+    noTests?: boolean;
+    config?: CodegraphConfig;
+    offset?: number;
+}): Record<string, unknown>;
+export declare function iterComplexity(customDbPath?: string, opts?: {
+    noTests?: boolean;
+    file?: string;
+    target?: string;
+    kind?: string;
+    sort?: string;
 }): Generator<{
-    name: any;
-    kind: any;
-    file: any;
-    line: any;
-    endLine: any;
-    cognitive: any;
-    cyclomatic: any;
-    maxNesting: any;
-    loc: any;
-    sloc: any;
-}, void, unknown>;
-export const computeLOCMetrics: typeof _computeLOCMetrics;
-export const computeMaintainabilityIndex: typeof _computeMaintainabilityIndex;
-import { COMPLEXITY_RULES } from '../ast-analysis/rules/index.js';
-import { HALSTEAD_RULES } from '../ast-analysis/rules/index.js';
-import { computeLOCMetrics as _computeLOCMetrics } from '../ast-analysis/metrics.js';
-import { computeMaintainabilityIndex as _computeMaintainabilityIndex } from '../ast-analysis/metrics.js';
-import { findFunctionNode as _findFunctionNode } from '../ast-analysis/shared.js';
-export { COMPLEXITY_RULES, HALSTEAD_RULES, _findFunctionNode as findFunctionNode };
+    name: string;
+    kind: string;
+    file: string;
+    line: number;
+    endLine: number | null;
+    cognitive: number;
+    cyclomatic: number;
+    maxNesting: number;
+    loc: number;
+    sloc: number;
+}>;
 //# sourceMappingURL=complexity.d.ts.map

package/dist/features/complexity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/features/complexity.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,qDAJW,MAAM,YACN,MAAM,GACJ;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiEjL;AAYD;;;;;;;GAOG;AACH,wDAJW,MAAM,YACN,MAAM,GACJ;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA8JhF;AAID;;;;;;;;;;;GAWG;AACH,gDAJW,MAAM,UACN,MAAM,GACJ;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAmChI;AAkID;;;;;;;;GAQG;AACH,2CALW,MAAM,eACN,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,WACnB,MAAM,mCA6ChB;AAID;;;;;;;;;;;;;GAaG;AACH,8CAXW,MAAM,SAEd;IAAsB,MAAM;IACN,KAAK;IACL,IAAI;IACH,cAAc;IACf,IAAI;IACJ,IAAI;IACH,OAAO;CAC9B,GAAU;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAmNxE;AAED;;;;;;;;;;GAUG;AACH,8CATW,MAAM,SAEd;IAAuB,OAAO;IACR,IAAI;IACJ,MAAM;IACN,IAAI;IACJ,IAAI;CAC1B;;;;;;;;;;;kBAsEF;AAtsBD,0DAAoD;AAIpD,8EAAwE;iCArGvB,gCAAgC;+BAAhC,gCAAgC;wDAD1E,4BAA4B;4EAA5B,4BAA4B;sDAM5B,2BAA2B"}
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/features/complexity.ts"],"names":[],"mappings":"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"}

package/dist/features/complexity.js

@@ -16,13 +16,6 @@ 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)
@@ -33,18 +26,18 @@ export function computeHalsteadMetrics(functionNode, language) {
         if (!node)
             return;
         // Skip type annotation subtrees
-        if (rules.skipTypes.has(node.type))
+        if (rules?.skipTypes.has(node.type))
             return;
         // Compound operators (non-leaf): count the node type as an operator
-        if (rules.compoundOperators.has(node.type)) {
+        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)) {
+            if (rules?.operatorLeafTypes.has(node.type)) {
                 operators.set(node.type, (operators.get(node.type) || 0) + 1);
             }
-            else if (rules.operandLeafTypes.has(node.type)) {
+            else if (rules?.operandLeafTypes.has(node.type)) {
                 const text = node.text;
                 operands.set(text, (operands.get(text) || 0) + 1);
             }
@@ -89,14 +82,6 @@ export const computeLOCMetrics = _computeLOCMetrics;
 // 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)
@@ -112,16 +97,16 @@ export function computeFunctionComplexity(functionNode, language) {
         if (nestingLevel > maxNesting)
             maxNesting = nestingLevel;
         // Handle logical operators in binary expressions
-        if (type === rules.logicalNodeType) {
+        if (type === rules?.logicalNodeType) {
             const op = node.child(1)?.type;
-            if (op && rules.logicalOperators.has(op)) {
+            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) {
+                if (parent && parent.type === rules?.logicalNodeType) {
                     const parentOp = parent.child(1)?.type;
                     if (parentOp === op) {
                         sameSequence = true;
@@ -138,15 +123,15 @@ export function computeFunctionComplexity(functionNode, language) {
             }
         }
         // Handle optional chaining (cyclomatic only)
-        if (type === rules.optionalChainType) {
+        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) {
+        if (rules?.branchNodes.has(type) && node.childCount > 0) {
             // Pattern A: else clause wraps if (JS/C#/Rust)
-            if (rules.elseNodeType && type === rules.elseNodeType) {
+            if (rules?.elseNodeType && type === rules?.elseNodeType) {
                 const firstChild = node.namedChild(0);
-                if (firstChild && firstChild.type === rules.ifNodeType) {
+                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);
@@ -161,7 +146,7 @@ export function computeFunctionComplexity(functionNode, language) {
                 return;
             }
             // Pattern B: explicit elif node (Python/Ruby/PHP)
-            if (rules.elifNodeType && type === rules.elifNodeType) {
+            if (rules?.elifNodeType && type === rules?.elifNodeType) {
                 cognitive++;
                 cyclomatic++;
                 for (let i = 0; i < node.childCount; i++) {
@@ -171,16 +156,16 @@ export function computeFunctionComplexity(functionNode, language) {
             }
             // Detect else-if via Pattern A or C
             let isElseIf = false;
-            if (type === rules.ifNodeType) {
-                if (rules.elseViaAlternative) {
+            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?.type === rules?.ifNodeType &&
                             node.parent.childForFieldName('alternative')?.id === node.id;
                 }
-                else if (rules.elseNodeType) {
+                else if (rules?.elseNodeType) {
                     // Pattern A (JS/C#/Rust): if_statement inside else_clause
-                    isElseIf = node.parent?.type === rules.elseNodeType;
+                    isElseIf = node.parent?.type === rules?.elseNodeType;
                 }
             }
             if (isElseIf) {
@@ -195,10 +180,10 @@ export function computeFunctionComplexity(functionNode, language) {
             cognitive += 1 + nestingLevel; // structural + nesting
             cyclomatic++;
             // Switch-like nodes don't add cyclomatic themselves (cases do)
-            if (rules.switchLikeNodes?.has(type)) {
+            if (rules?.switchLikeNodes?.has(type)) {
                 cyclomatic--; // Undo the ++ above; cases handle cyclomatic
             }
-            if (rules.nestingNodes.has(type)) {
+            if (rules?.nestingNodes.has(type)) {
                 for (let i = 0; i < node.childCount; i++) {
                     walk(node.child(i), nestingLevel + 1, false);
                 }
@@ -206,9 +191,9 @@ export function computeFunctionComplexity(functionNode, language) {
             }
         }
         // 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 &&
+        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++) {
@@ -217,11 +202,11 @@ export function computeFunctionComplexity(functionNode, language) {
             return;
         }
         // Handle case nodes (cyclomatic only, skip keyword leaves)
-        if (rules.caseNodes.has(type) && node.childCount > 0) {
+        if (rules?.caseNodes.has(type) && node.childCount > 0) {
             cyclomatic++;
         }
         // Handle nested function definitions (increase nesting)
-        if (!isTopFunction && rules.functionNodes.has(type)) {
+        if (!isTopFunction && rules?.functionNodes.has(type)) {
             for (let i = 0; i < node.childCount; i++) {
                 walk(node.child(i), nestingLevel + 1, false);
             }
@@ -235,19 +220,6 @@ export function computeFunctionComplexity(functionNode, language) {
     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)
@@ -261,7 +233,8 @@ export function computeAllMetrics(functionNode, langId) {
     const results = walkWithVisitors(functionNode, [visitor], langId, {
         nestingNodeTypes: nestingNodes,
     });
-    const rawResult = results.complexity;
+    // biome-ignore lint/complexity/useLiteralKeys: noPropertyAccessFromIndexSignature requires bracket notation
+    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);
@@ -278,9 +251,6 @@ export function computeAllMetrics(functionNode, langId) {
     };
 }
 // ─── 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) {
@@ -288,7 +258,14 @@ async function initWasmParsersIfNeeded(fileSymbols) {
             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);
+            // Only consider definitions with real function bodies (non-dotted names,
+            // multi-line span). Interface/type property signatures are extracted as
+            // methods but correctly lack complexity data from the native engine.
+            const hasPrecomputed = symbols.definitions.every((d) => (d.kind !== 'function' && d.kind !== 'method') ||
+                d.complexity ||
+                d.name.includes('.') ||
+                !d.endLine ||
+                d.endLine <= d.line);
             if (!hasPrecomputed) {
                 const { createParsers } = await import('../domain/parser.js');
                 const parsers = await createParsers();
@@ -299,7 +276,9 @@ async function initWasmParsersIfNeeded(fileSymbols) {
     }
     return { parsers: null, extToLang: null };
 }
-function getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser) {
+function getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, 
+// biome-ignore lint/suspicious/noExplicitAny: dynamic import from parser.js
+getParser) {
     let tree = symbols._tree;
     let langId = symbols._langId;
     const allPrecomputed = symbols.definitions.every((d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity);
@@ -332,21 +311,21 @@ function getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser
             return null;
         }
     }
-    return { tree, langId };
+    return tree && langId ? { tree: tree, langId } : null;
 }
 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);
+    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)
+    if (!tree || !rules || !langId)
         return 0;
-    const funcNode = _findFunctionNode(tree.rootNode, def.line, def.endLine, rules);
+    const funcNode = _findFunctionNode(tree.rootNode, def.line, def.endLine ?? def.line, rules);
     if (!funcNode)
         return 0;
     const metrics = computeAllMetrics(funcNode, langId);
@@ -359,15 +338,6 @@ function upsertAstComplexity(db, upsert, def, relPath, tree, langId, rules) {
     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');
@@ -385,7 +355,9 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
             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;
+            const rules = langId
+                ? COMPLEXITY_RULES.get(langId)
+                : undefined;
             for (const def of symbols.definitions) {
                 if (def.kind !== 'function' && def.kind !== 'method')
                     continue;
@@ -405,21 +377,6 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
         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 {
@@ -431,6 +388,7 @@ export function complexityData(customDbPath, opts = {}) {
         const kindFilter = opts.kind || null;
         // Load thresholds from config
         const config = opts.config || loadConfig(process.cwd());
+        // biome-ignore lint/suspicious/noExplicitAny: thresholds come from config with dynamic keys
         const thresholds = config.manifesto?.rules || {
             cognitive: { warn: 15, fail: null },
             cyclomatic: { warn: 10, fail: null },
@@ -509,7 +467,7 @@ export function complexityData(customDbPath, opts = {}) {
             // 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;
+                hasGraph = (db.prepare('SELECT COUNT(*) as c FROM nodes').get()?.c ?? 0) > 0;
             }
             catch (e2) {
                 debug(`nodes table check failed: ${e2.message}`);
@@ -520,17 +478,18 @@ export function complexityData(customDbPath, opts = {}) {
         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)
+            if (isValidThreshold(thresholds.cognitive?.warn) &&
+                r.cognitive >= (thresholds.cognitive?.warn ?? 0))
                 exceeds.push('cognitive');
             if (isValidThreshold(thresholds.cyclomatic?.warn) &&
-                r.cyclomatic >= thresholds.cyclomatic.warn)
+                r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0))
                 exceeds.push('cyclomatic');
             if (isValidThreshold(thresholds.maxNesting?.warn) &&
-                r.max_nesting >= thresholds.maxNesting.warn)
+                r.max_nesting >= (thresholds.maxNesting?.warn ?? 0))
                 exceeds.push('maxNesting');
             if (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
                 r.maintainability_index > 0 &&
-                r.maintainability_index <= thresholds.maintainabilityIndex.warn)
+                r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0))
                 exceeds.push('maintainabilityIndex');
             return {
                 name: r.name,
@@ -573,14 +532,14 @@ export function complexityData(customDbPath, opts = {}) {
                     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) ||
+                        r.cognitive >= (thresholds.cognitive?.warn ?? 0)) ||
                         (isValidThreshold(thresholds.cyclomatic?.warn) &&
-                            r.cyclomatic >= thresholds.cyclomatic.warn) ||
+                            r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0)) ||
                         (isValidThreshold(thresholds.maxNesting?.warn) &&
-                            r.max_nesting >= thresholds.maxNesting.warn) ||
+                            r.max_nesting >= (thresholds.maxNesting?.warn ?? 0)) ||
                         (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
                             r.maintainability_index > 0 &&
-                            r.maintainability_index <= thresholds.maintainabilityIndex.warn)).length,
+                            r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0))).length,
                 };
             }
         }
@@ -591,7 +550,7 @@ export function complexityData(customDbPath, opts = {}) {
         let hasGraph = false;
         if (summary === null) {
             try {
-                hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+                hasGraph = (db.prepare('SELECT COUNT(*) as c FROM nodes').get()?.c ?? 0) > 0;
             }
             catch (e) {
                 debug(`nodes table check failed: ${e.message}`);
@@ -604,17 +563,6 @@ export function complexityData(customDbPath, opts = {}) {
         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 {