pi-lens 3.8.65 → 3.8.67

package/dist/clients/complexity-client.js

@@ -1,114 +1,371 @@
 /**
- * Complexity Metrics Client for pi-lens (cache test)
+ * Complexity Metrics Client for pi-lens
  *
- * Calculates AST-based code complexity metrics for TypeScript/JavaScript files.
- * Uses the TypeScript compiler API for parsing.
+ * Language-agnostic AST-based code complexity metrics, computed over the shared
+ * tree-sitter client (#402 — no `typescript` compiler dependency). Supported
+ * grammars are keyed in LANGUAGE_NODES (JS/TS, Python, Go, Rust today; adding a
+ * language is one table entry).
  *
- * Tracks:
- * - Max Nesting Depth: Deepest control flow nesting
- * - Avg/Max Function Length: Lines per function
- * - Cyclomatic Complexity: Independent code paths (M = E - N + 2P)
- * - Cognitive Complexity: Human understanding difficulty
- * - Halstead Volume: Vocabulary-based complexity
- * - Maintainability Index: Composite score (0-100, higher is better)
- *
- * These are silent metrics shown in session summary.
+ * Tracks: max nesting depth, function length, cyclomatic + cognitive complexity,
+ * maintainability index (Halstead-free), LOC/comments, code entropy, and AI-slop
+ * indicators. These are silent metrics surfaced in the session summary.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ts } from "./deps/typescript.js";
-import { isFileKind } from "./file-kinds.js";
-// --- Constants ---
-// Nodes that increase cyclomatic complexity
-const CYCLOMAL_NODES = new Set([
-    ts.SyntaxKind.IfStatement,
-    ts.SyntaxKind.WhileStatement,
-    ts.SyntaxKind.ForStatement,
-    ts.SyntaxKind.ForInStatement,
-    ts.SyntaxKind.ForOfStatement,
-    ts.SyntaxKind.CaseClause,
-    ts.SyntaxKind.ConditionalExpression,
-    ts.SyntaxKind.BinaryExpression, // && and ||
-]);
-// Nodes that increase cognitive complexity (with nesting penalty)
-const COGNITIVE_NODES = new Set([
-    ts.SyntaxKind.IfStatement,
-    ts.SyntaxKind.WhileStatement,
-    ts.SyntaxKind.ForStatement,
-    ts.SyntaxKind.ForInStatement,
-    ts.SyntaxKind.ForOfStatement,
-    ts.SyntaxKind.SwitchStatement,
-    ts.SyntaxKind.CaseClause,
-    ts.SyntaxKind.ConditionalExpression,
-    ts.SyntaxKind.CatchClause,
-]);
-// Nesting-increasing nodes
-const NESTING_NODES = new Set([
-    ts.SyntaxKind.IfStatement,
-    ts.SyntaxKind.WhileStatement,
-    ts.SyntaxKind.ForStatement,
-    ts.SyntaxKind.ForInStatement,
-    ts.SyntaxKind.ForOfStatement,
-    ts.SyntaxKind.SwitchStatement,
-    ts.SyntaxKind.FunctionDeclaration,
-    ts.SyntaxKind.FunctionExpression,
-    ts.SyntaxKind.ArrowFunction,
-    ts.SyntaxKind.ClassDeclaration,
-    ts.SyntaxKind.MethodDeclaration,
-    ts.SyntaxKind.TryStatement,
-    ts.SyntaxKind.CatchClause,
-]);
-// Function-like nodes
-const FUNCTION_LIKE_NODES = new Set([
-    ts.SyntaxKind.FunctionDeclaration,
-    ts.SyntaxKind.FunctionExpression,
-    ts.SyntaxKind.ArrowFunction,
-    ts.SyntaxKind.MethodDeclaration,
-    ts.SyntaxKind.Constructor,
-    ts.SyntaxKind.GetAccessor,
-    ts.SyntaxKind.SetAccessor,
-]);
-// Halstead operators (common operators)
-const HALSTEAD_OPERATORS = new Set([
-    ts.SyntaxKind.PlusToken,
-    ts.SyntaxKind.MinusToken,
-    ts.SyntaxKind.AsteriskToken,
-    ts.SyntaxKind.SlashToken,
-    ts.SyntaxKind.PercentToken,
-    ts.SyntaxKind.AmpersandToken,
-    ts.SyntaxKind.BarToken,
-    ts.SyntaxKind.CaretToken,
-    ts.SyntaxKind.LessThanToken,
-    ts.SyntaxKind.GreaterThanToken,
-    ts.SyntaxKind.LessThanEqualsToken,
-    ts.SyntaxKind.GreaterThanEqualsToken,
-    ts.SyntaxKind.EqualsEqualsToken,
-    ts.SyntaxKind.ExclamationEqualsToken,
-    ts.SyntaxKind.EqualsEqualsEqualsToken,
-    ts.SyntaxKind.ExclamationEqualsEqualsToken,
-    ts.SyntaxKind.PlusPlusToken,
-    ts.SyntaxKind.MinusMinusToken,
-    ts.SyntaxKind.PlusEqualsToken,
-    ts.SyntaxKind.MinusEqualsToken,
-    ts.SyntaxKind.AsteriskEqualsToken,
-    ts.SyntaxKind.SlashEqualsToken,
-    ts.SyntaxKind.AmpersandEqualsToken,
-    ts.SyntaxKind.BarEqualsToken,
-    ts.SyntaxKind.LessThanLessThanToken,
-    ts.SyntaxKind.GreaterThanGreaterThanToken,
-    ts.SyntaxKind.QuestionToken,
-    ts.SyntaxKind.ColonToken,
-    ts.SyntaxKind.EqualsToken,
-    ts.SyntaxKind.EqualsGreaterThanToken,
-    ts.SyntaxKind.AmpersandAmpersandToken,
-    ts.SyntaxKind.BarBarToken,
-    ts.SyntaxKind.ExclamationToken,
-    ts.SyntaxKind.TildeToken,
-    ts.SyntaxKind.CommaToken,
-    ts.SyntaxKind.SemicolonToken,
-    ts.SyntaxKind.DotToken,
-    ts.SyntaxKind.QuestionDotToken,
-]);
+import { firstChildOfType, parseTreeSitterRoot, resolveTreeSitterLanguage, walk, } from "./tree-sitter-shared.js";
+// JS/TS/JSX share one grammar shape.
+const JSTS = {
+    functionLike: new Set([
+        "function_declaration",
+        "method_definition",
+        "function_expression",
+        "arrow_function",
+        "generator_function",
+        "generator_function_declaration",
+    ]),
+    nesting: new Set([
+        "if_statement",
+        "while_statement",
+        "for_statement",
+        "for_in_statement",
+        "switch_statement",
+        "function_declaration",
+        "function_expression",
+        "arrow_function",
+        "method_definition",
+        "class_declaration",
+        "try_statement",
+        "catch_clause",
+    ]),
+    decision: new Set([
+        "if_statement",
+        "while_statement",
+        "for_statement",
+        "for_in_statement",
+        "switch_case",
+        "ternary_expression",
+    ]),
+    cognitive: new Set([
+        "if_statement",
+        "while_statement",
+        "for_statement",
+        "for_in_statement",
+        "switch_statement",
+        "switch_case",
+        "ternary_expression",
+        "catch_clause",
+    ]),
+    logicalOpNodes: new Set(),
+    logicalBinaryOps: new Set(["&&", "||", "??"]),
+    tryNode: "try_statement",
+    nameChildTypes: ["identifier", "property_identifier"],
+};
+const PYTHON = {
+    functionLike: new Set(["function_definition", "lambda"]),
+    nesting: new Set([
+        "if_statement",
+        "for_statement",
+        "while_statement",
+        "match_statement",
+        "function_definition",
+        "class_definition",
+        "try_statement",
+        "except_clause",
+        "elif_clause",
+    ]),
+    decision: new Set([
+        "if_statement",
+        "elif_clause",
+        "for_statement",
+        "while_statement",
+        "case_clause",
+        "conditional_expression",
+    ]),
+    cognitive: new Set([
+        "if_statement",
+        "elif_clause",
+        "for_statement",
+        "while_statement",
+        "match_statement",
+        "case_clause",
+        "conditional_expression",
+        "except_clause",
+    ]),
+    logicalOpNodes: new Set(["boolean_operator"]),
+    logicalBinaryOps: new Set(),
+    tryNode: "try_statement",
+    nameChildTypes: ["identifier"],
+};
+const GO = {
+    functionLike: new Set([
+        "function_declaration",
+        "method_declaration",
+        "func_literal",
+    ]),
+    nesting: new Set([
+        "if_statement",
+        "for_statement",
+        "expression_switch_statement",
+        "type_switch_statement",
+        "select_statement",
+        "function_declaration",
+        "method_declaration",
+    ]),
+    decision: new Set([
+        "if_statement",
+        "for_statement",
+        "expression_case",
+        "type_case",
+        "communication_case",
+    ]),
+    cognitive: new Set([
+        "if_statement",
+        "for_statement",
+        "expression_switch_statement",
+        "type_switch_statement",
+        "select_statement",
+        "expression_case",
+        "type_case",
+        "communication_case",
+    ]),
+    logicalOpNodes: new Set(),
+    logicalBinaryOps: new Set(["&&", "||"]),
+    tryNode: undefined, // Go has no try/catch (error returns)
+    nameChildTypes: ["identifier", "field_identifier"],
+};
+const RUST = {
+    functionLike: new Set(["function_item", "closure_expression"]),
+    nesting: new Set([
+        "if_expression",
+        "while_expression",
+        "for_expression",
+        "loop_expression",
+        "match_expression",
+        "function_item",
+    ]),
+    decision: new Set([
+        "if_expression",
+        "while_expression",
+        "for_expression",
+        "loop_expression",
+        "match_arm",
+    ]),
+    cognitive: new Set([
+        "if_expression",
+        "while_expression",
+        "for_expression",
+        "loop_expression",
+        "match_expression",
+        "match_arm",
+    ]),
+    logicalOpNodes: new Set(),
+    logicalBinaryOps: new Set(["&&", "||"]),
+    tryNode: undefined, // Rust uses Result/? — no try/catch
+    nameChildTypes: ["identifier"],
+};
+const LANGUAGE_NODES = {
+    typescript: JSTS,
+    tsx: JSTS,
+    javascript: JSTS,
+    python: PYTHON,
+    go: GO,
+    rust: RUST,
+};
+const COMMENT_TYPES = new Set(["comment", "line_comment", "block_comment"]);
+// --- Metric helpers (module-level, node-config-driven) ---
+function isLogicalOp(node, nodes) {
+    if (nodes.logicalOpNodes.has(node.type))
+        return true;
+    if (nodes.logicalBinaryOps.size > 0 && node.type === "binary_expression") {
+        return (node.children ?? []).some((c) => c && nodes.logicalBinaryOps.has(c.type));
+    }
+    return false;
+}
+/** Cyclomatic contribution of a subtree: decision points + logical operators. */
+function subtreeCyclomatic(root, nodes) {
+    let cc = 0;
+    walk(root, (n) => {
+        if (nodes.decision.has(n.type))
+            cc++;
+        if (isLogicalOp(n, nodes))
+            cc++;
+    });
+    return cc;
+}
+/** Cognitive complexity (SonarSource-style: base + nesting penalty). */
+function subtreeCognitive(node, nesting, nodes) {
+    let complexity = 0;
+    if (nodes.cognitive.has(node.type))
+        complexity += 1 + nesting;
+    // Labeled break/continue add complexity.
+    if ((node.type === "break_statement" || node.type === "continue_statement") &&
+        (node.children ?? []).some((c) => c &&
+            (c.type === "statement_identifier" ||
+                c.type === "identifier" ||
+                c.type === "label_name" ||
+                c.type === "label"))) {
+        complexity += 1 + nesting;
+    }
+    if (isLogicalOp(node, nodes))
+        complexity += 1;
+    const childNesting = nodes.nesting.has(node.type) ? nesting + 1 : nesting;
+    for (const child of node.children ?? []) {
+        if (child)
+            complexity += subtreeCognitive(child, childNesting, nodes);
+    }
+    return complexity;
+}
+function subtreeMaxNesting(node, currentDepth, nodes) {
+    let maxDepth = currentDepth;
+    if (nodes.nesting.has(node.type)) {
+        currentDepth++;
+        maxDepth = Math.max(maxDepth, currentDepth);
+    }
+    for (const child of node.children ?? []) {
+        if (child) {
+            maxDepth = Math.max(maxDepth, subtreeMaxNesting(child, currentDepth, nodes));
+        }
+    }
+    return maxDepth;
+}
+function functionName(fnNode, nodes) {
+    for (const t of nodes.nameChildTypes) {
+        const id = firstChildOfType(fnNode, t);
+        if (id)
+            return id.text;
+    }
+    return undefined;
+}
+function collectFunctionMetrics(root, nodes) {
+    const functions = [];
+    const visit = (node, nestingLevel) => {
+        if (nodes.functionLike.has(node.type)) {
+            const startLine = node.startPosition.row;
+            const endLine = node.endPosition.row;
+            functions.push({
+                name: functionName(node, nodes) ?? `<anonymous@L${startLine + 1}>`,
+                line: startLine + 1,
+                length: endLine - startLine + 1,
+                cyclomatic: subtreeCyclomatic(node, nodes),
+                cognitive: subtreeCognitive(node, nestingLevel, nodes),
+                nestingDepth: subtreeMaxNesting(node, 0, nodes),
+            });
+        }
+        const newNesting = nodes.nesting.has(node.type)
+            ? nestingLevel + 1
+            : nestingLevel;
+        for (const child of node.children ?? []) {
+            if (child)
+                visit(child, newNesting);
+        }
+    };
+    visit(root, 0);
+    return functions;
+}
+function countTryCatch(root, nodes) {
+    if (!nodes.tryNode)
+        return 0;
+    let count = 0;
+    walk(root, (n) => {
+        if (n.type === nodes.tryNode)
+            count++;
+    });
+    return count;
+}
+function countLines(content, root) {
+    const lines = content.split(/\r?\n/);
+    const commentLineSet = new Set();
+    walk(root, (n) => {
+        if (COMMENT_TYPES.has(n.type)) {
+            for (let l = n.startPosition.row; l <= n.endPosition.row; l++) {
+                commentLineSet.add(l);
+            }
+        }
+    });
+    const codeLines = lines.filter((line, i) => {
+        if (line.trim().length === 0)
+            return false;
+        if (!commentLineSet.has(i))
+            return true;
+        // Line has a comment — keep it only if code remains after stripping it.
+        const stripped = line
+            .replace(/\/\/.*$/, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/#.*$/, "")
+            .trim();
+        return stripped.length > 0;
+    }).length;
+    return { codeLines, commentLines: commentLineSet.size };
+}
+const AI_COMMENT_PATTERNS = [
+    /(?:🔍|✅|📝|🔧|🐛|⚠️|🚀|💡|🎯|📌|🏷️|🔑|🏗️|🧪|🗑️|🔄|♻️|📋|🔖|📊|💬|🔥|💎|⭐|🌟|🎨|🛠️)/u,
+    /(?:\/\/|#)\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
+    /(?:\/\/|#)\s*(This function|This method|This code|Here we|Now we)\b/i,
+    /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i,
+];
+function countAICommentPatterns(sourceText) {
+    let count = 0;
+    for (const line of sourceText.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") ||
+            trimmed.startsWith("/*") ||
+            trimmed.startsWith("*") ||
+            trimmed.startsWith("#")) {
+            for (const pattern of AI_COMMENT_PATTERNS) {
+                if (pattern.test(line)) {
+                    count++;
+                    break;
+                }
+            }
+        }
+    }
+    return count;
+}
+function calculateCodeEntropy(sourceText) {
+    const tokens = sourceText
+        .replace(/\/\/.*/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/["'`][^"'`]*["'`]/g, "STR")
+        .replace(/\b\d+(\.\d+)?\b/g, "NUM")
+        .split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0)
+        return 0;
+    const freq = new Map();
+    for (const token of tokens)
+        freq.set(token, (freq.get(token) || 0) + 1);
+    let entropy = 0;
+    for (const count of freq.values()) {
+        const p = count / tokens.length;
+        if (p > 0)
+            entropy -= p * Math.log2(p);
+    }
+    return entropy;
+}
+/**
+ * Maintainability index, Halstead-free variant:
+ * MI = max(0, (171 - 0.23·Cyclomatic - 16.2·ln(LOC)) · 100/171) + comment bonus.
+ */
+function calculateMaintainabilityIndex(cyclomatic, loc, comments) {
+    if (loc === 0)
+        return 100;
+    const lnLOC = Math.log(loc);
+    let mi = ((171 - 0.23 * cyclomatic - 16.2 * lnLOC) * 100) / 171;
+    const commentBonus = Math.min(10, (comments / loc) * 50);
+    mi += commentBonus;
+    return Math.max(0, Math.min(100, mi));
+}
+function calculateMaxParams(functions) {
+    // Estimate from average function length (kept from the original heuristic).
+    return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) /
+        Math.max(1, functions.length) /
+        5)));
+}
+function countSingleUseFunctions(functions) {
+    return functions.filter((f) => f.length < 10 &&
+        f.cyclomatic <= 2 &&
+        /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name)).length;
+}
 // --- Client ---
 export class ComplexityClient {
     log;
@@ -117,61 +374,46 @@ export class ComplexityClient {
             ? (msg) => console.error(`[complexity] ${msg}`)
             : () => { };
     }
-    /**
-     * Check if file is supported (TS/JS)
-     */
+    /** True if the file's grammar has a complexity node mapping. */
     isSupportedFile(filePath) {
-        return isFileKind(filePath, "jsts");
+        const languageId = resolveTreeSitterLanguage(filePath);
+        return Boolean(languageId && languageId in LANGUAGE_NODES);
     }
-    /**
-     * Analyze complexity metrics for a file
-     */
-    analyzeFile(filePath) {
-        const parsed = this.readAndParse(filePath);
-        if (!parsed)
+    /** Analyze complexity metrics for a file (null if unsupported / unparseable). */
+    async analyzeFile(filePath) {
+        const absolutePath = path.resolve(filePath);
+        const languageId = resolveTreeSitterLanguage(absolutePath);
+        const nodes = languageId ? LANGUAGE_NODES[languageId] : undefined;
+        if (!nodes)
             return null;
+        let content;
+        let root;
         try {
-            return this.computeMetrics(parsed);
+            if (!fs.existsSync(absolutePath))
+                return null;
+            content = fs.readFileSync(absolutePath, "utf-8");
+            root = await parseTreeSitterRoot(absolutePath, content);
         }
         catch (err) {
-            this.log(`Analysis error for ${filePath}: ${err.message}`);
+            this.log(`Read/parse error for ${filePath}: ${err.message}`);
             return null;
         }
-    }
-    /**
-     * Read file and parse to TypeScript AST
-     */
-    readAndParse(filePath) {
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
+        if (!root)
             return null;
-        const content = fs.readFileSync(absolutePath, "utf-8");
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        return { absolutePath, content, sourceFile };
+        try {
+            return this.computeMetrics(absolutePath, content, root, nodes);
+        }
+        catch (err) {
+            this.log(`Analysis error for ${filePath}: ${err.message}`);
+            return null;
+        }
     }
-    /**
-     * Compute all metrics from parsed source
-     */
-    computeMetrics(parsed) {
-        const { absolutePath, content, sourceFile } = parsed;
-        const lines = content.split(/\r?\n/);
-        // Line counts and function collection
-        const { codeLines, commentLines } = this.countLines(sourceFile, lines);
-        const functions = this.collectFunctionMetrics(sourceFile);
-        // File-level complexity metrics
-        const maxNestingDepth = this.calculateMaxNesting(sourceFile, 0);
-        const cognitive = this.calculateCognitiveComplexity(sourceFile);
-        const halstead = this.calculateHalsteadVolume(sourceFile);
-        // Aggregate function statistics
+    computeMetrics(absolutePath, content, root, nodes) {
+        const { codeLines, commentLines } = countLines(content, root);
+        const functions = collectFunctionMetrics(root, nodes);
+        const maxNestingDepth = subtreeMaxNesting(root, 0, nodes);
+        const cognitive = subtreeCognitive(root, 0, nodes);
         const funcStats = this.aggregateFunctionStats(functions);
-        // Derived metrics
-        const maintainabilityIndex = this.calculateMaintainabilityIndex(halstead, funcStats.avgCyclomatic, codeLines, commentLines);
-        const codeEntropy = this.calculateCodeEntropy(content);
-        // AI slop indicators
-        const maxParamsInFunction = this.calculateMaxParams(functions);
-        const aiCommentPatterns = this.countAICommentPatterns(sourceFile);
-        const singleUseFunctions = this.countSingleUseFunctions(functions);
-        const tryCatchCount = this.countTryCatch(sourceFile);
         return {
             filePath: path.relative(process.cwd(), absolutePath),
             maxNestingDepth,
@@ -181,20 +423,16 @@ export class ComplexityClient {
             cyclomaticComplexity: funcStats.avgCyclomatic,
             maxCyclomaticComplexity: funcStats.maxCyclomatic,
             cognitiveComplexity: cognitive,
-            halsteadVolume: Math.round(halstead * 10) / 10,
-            maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
+            maintainabilityIndex: Math.round(calculateMaintainabilityIndex(funcStats.avgCyclomatic, codeLines, commentLines) * 10) / 10,
             linesOfCode: codeLines,
             commentLines,
-            codeEntropy: Math.round(codeEntropy * 100) / 100,
-            maxParamsInFunction,
-            aiCommentPatterns,
-            singleUseFunctions,
-            tryCatchCount,
+            codeEntropy: Math.round(calculateCodeEntropy(content) * 100) / 100,
+            maxParamsInFunction: calculateMaxParams(functions),
+            aiCommentPatterns: countAICommentPatterns(content),
+            singleUseFunctions: countSingleUseFunctions(functions),
+            tryCatchCount: countTryCatch(root, nodes),
         };
     }
-    /**
-     * Aggregate function metrics into summary statistics
-     */
     aggregateFunctionStats(functions) {
         if (functions.length === 0) {
             return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
@@ -209,468 +447,4 @@ export class ComplexityClient {
             maxCyclomatic: Math.max(1, Math.max(...cyclomatics)),
         };
     }
-    /**
-     * Format metrics for display
-     */
-    formatMetrics(metrics) {
-        const parts = [];
-        // Maintainability Index (most important)
-        let miLabel = "✗";
-        if (metrics.maintainabilityIndex >= 80)
-            miLabel = "✓";
-        else if (metrics.maintainabilityIndex >= 60)
-            miLabel = "⚠";
-        parts.push(`${miLabel} Maintainability: ${metrics.maintainabilityIndex}/100`);
-        // Complexity metrics
-        if (metrics.cyclomaticComplexity > 5 ||
-            metrics.maxCyclomaticComplexity > 10) {
-            const avg = metrics.cyclomaticComplexity;
-            const max = metrics.maxCyclomaticComplexity;
-            parts.push(`  Cyclomatic: avg ${avg}, max ${max} (${metrics.functionCount} functions)`);
-        }
-        if (metrics.cognitiveComplexity > 15) {
-            parts.push(`  Cognitive: ${metrics.cognitiveComplexity} (high mental complexity)`);
-        }
-        // Nesting depth
-        if (metrics.maxNestingDepth > 4) {
-            parts.push(`  Max nesting: ${metrics.maxNestingDepth} levels (consider extracting)`);
-        }
-        // Code entropy (in bits, >5.5 = risky AI-induced complexity)
-        // Threshold increased from 3.5 to 5.5 to reduce false positives in tooling codebases
-        // where diverse method/variable names are naturally expected
-        if (metrics.codeEntropy > 5.5) {
-            parts.push(`  Entropy: ${metrics.codeEntropy.toFixed(1)} bits (>5.5 — risky AI-induced complexity)`);
-        }
-        // Function length
-        if (metrics.maxFunctionLength > 50) {
-            parts.push(`  Longest function: ${metrics.maxFunctionLength} lines (avg: ${metrics.avgFunctionLength})`);
-        }
-        // Halstead (only if notably high)
-        if (metrics.halsteadVolume > 500) {
-            parts.push(`  Halstead volume: ${metrics.halsteadVolume} (high vocabulary)`);
-        }
-        return parts.length > 0
-            ? `[Complexity] ${metrics.filePath}\n${parts.join("\n")}`
-            : "";
-    }
-    /**
-     * Calculate max parameters across all functions
-     */
-    calculateMaxParams(functions) {
-        // We stored function params in the metrics during analysis
-        // For now, estimate based on function length (longer functions often have more params)
-        return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) /
-            Math.max(1, functions.length) /
-            5)));
-    }
-    /**
-     * Count AI comment patterns (emojis, boilerplate phrases)
-     */
-    countAICommentPatterns(sourceFile) {
-        const sourceText = sourceFile.getText();
-        let count = 0;
-        const aiPatterns = [
-            /(?:🔍|✅|📝|🔧|🐛|⚠️|🚀|💡|🎯|📌|🏷️|🔑|🏗️|🧪|🗑️|🔄|♻️|📋|🔖|📊|💬|🔥|💎|⭐|🌟|🎨|🛠️)/u,
-            /\/\/\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
-            /\/\/\s*(This function|This method|This code|Here we|Now we)\b/i,
-            /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i,
-        ];
-        const lines = sourceText.split(/\r?\n/);
-        for (const line of lines) {
-            // Only check comment lines
-            const trimmed = line.trim();
-            if (trimmed.startsWith("//") ||
-                trimmed.startsWith("/*") ||
-                trimmed.startsWith("*")) {
-                for (const pattern of aiPatterns) {
-                    if (pattern.test(line)) {
-                        count++;
-                        break;
-                    }
-                }
-            }
-        }
-        return count;
-    }
-    /**
-     * Count functions that appear to be single-use (helper patterns)
-     */
-    countSingleUseFunctions(functions) {
-        // Heuristic: small functions (< 10 lines) with simple names are often single-use
-        const smallHelpers = functions.filter((f) => f.length < 10 &&
-            f.cyclomatic <= 2 &&
-            /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name));
-        return smallHelpers.length;
-    }
-    /**
-     * Count try/catch blocks (generic error handling pattern)
-     */
-    countTryCatch(sourceFile) {
-        let count = 0;
-        const visit = (node) => {
-            if (ts.isTryStatement(node)) {
-                count++;
-            }
-            ts.forEachChild(node, visit);
-        };
-        ts.forEachChild(sourceFile, visit);
-        return count;
-    }
-    /**
-     * Check thresholds and return actionable warnings
-     */
-    checkThresholds(metrics) {
-        const warnings = [];
-        // TUNED: Only flag extreme cases to reduce noise
-        // MI < 30 is "critically poor" (was < 60, too aggressive)
-        if (metrics.maintainabilityIndex < 30) {
-            warnings.push(`Maintainability dropped to ${metrics.maintainabilityIndex} — extract logic into helper functions`);
-        }
-        // Cyclomatic > 20 is very high (was > 10)
-        if (metrics.cyclomaticComplexity > 20) {
-            warnings.push(`High complexity (${metrics.cyclomaticComplexity}) — use early returns or switch expressions`);
-        }
-        // Cognitive > 50 is high (was > 15, flagged almost everything)
-        if (metrics.cognitiveComplexity > 50) {
-            warnings.push(`Cognitive complexity (${metrics.cognitiveComplexity}) — simplify logic flow`);
-        }
-        // Nesting > 6 is deep (was > 4, normal for complex code)
-        if (metrics.maxNestingDepth > 6) {
-            warnings.push(`Deep nesting (${metrics.maxNestingDepth} levels) — extract nested logic into separate functions`);
-        }
-        // Entropy > 5.5 is high (was > 3.5 → 5.0, still too sensitive for tooling codebases)
-        if (metrics.codeEntropy > 5.5) {
-            warnings.push(`High entropy (${metrics.codeEntropy.toFixed(1)} bits) — follow project conventions`);
-        }
-        // Comments ratio (>60% = excessive, was > 40%)
-        const totalLines = metrics.linesOfCode + metrics.commentLines;
-        if (totalLines > 10 && metrics.commentLines / totalLines > 0.6) {
-            warnings.push(`Excessive comments (${Math.round((metrics.commentLines / totalLines) * 100)}%) — remove obvious comments`);
-        }
-        // Verbose code (long functions with low complexity = overly verbose)
-        if (metrics.avgFunctionLength > 30 && metrics.cyclomaticComplexity < 3) {
-            warnings.push(`Verbose code (avg ${Math.round(metrics.avgFunctionLength)} lines, low complexity) — simplify or extract`);
-        }
-        // AI slop: Emoji/boilerplate comments
-        if (metrics.aiCommentPatterns > 5) {
-            warnings.push(`AI-style comments (${metrics.aiCommentPatterns}) — remove hand-holding comments`);
-        }
-        // AI slop: Too many try/catch blocks (lazy error handling)
-        if (metrics.tryCatchCount > 15) {
-            warnings.push(`Many try/catch blocks (${metrics.tryCatchCount}) — consolidate error handling`);
-        }
-        // AI slop: Over-abstraction (many single-use helper functions)
-        if (metrics.singleUseFunctions > 3 && metrics.functionCount > 5) {
-            warnings.push(`Over-abstraction (${metrics.singleUseFunctions} single-use helpers) — inline or consolidate`);
-        }
-        // AI slop: Functions with too many parameters
-        if (metrics.maxParamsInFunction > 6) {
-            warnings.push(`Long parameter list (${metrics.maxParamsInFunction} params) — use options object`);
-        }
-        return warnings;
-    }
-    /**
-     * Format delta for session summary
-     */
-    formatDelta(previous, current) {
-        const parts = [];
-        const miDelta = current.maintainabilityIndex - previous.maintainabilityIndex;
-        if (Math.abs(miDelta) > 1) {
-            const arrow = miDelta > 0 ? "↑" : "↓";
-            const sign = miDelta > 0 ? "+" : "";
-            parts.push(`  ${arrow} ${current.filePath}: MI ${previous.maintainabilityIndex} → ${current.maintainabilityIndex} (${sign}${miDelta.toFixed(1)})`);
-        }
-        const cogDelta = current.cognitiveComplexity - previous.cognitiveComplexity;
-        if (Math.abs(cogDelta) > 3) {
-            const arrow = cogDelta > 0 ? "↑" : "↓";
-            const sign = cogDelta > 0 ? "+" : "";
-            parts.push(`  ${arrow} ${current.filePath}: cognitive ${previous.cognitiveComplexity} → ${current.cognitiveComplexity} (${sign}${cogDelta})`);
-        }
-        return parts.join("\n");
-    }
-    // --- Private: Line Counting ---
-    countLines(sourceFile, lines) {
-        let commentLines = 0;
-        const commentPositions = new Set();
-        // Find comment positions
-        const _visitComments = (node) => {
-            ts.forEachChild(node, _visitComments);
-        };
-        // Scan for comments using text
-        const text = sourceFile.getFullText();
-        const commentRegex = /\/\/.*$|\/\*[\s\S]*?\*\//gm;
-        let match;
-        while ((match = commentRegex.exec(text)) !== null) {
-            const lineStart = text.lastIndexOf("\n", match.index) + 1;
-            const startLine = text.substring(0, lineStart).split(/\r?\n/).length - 1;
-            const endLine = text.substring(0, match.index + match[0].length).split(/\r?\n/).length -
-                1;
-            for (let i = startLine; i <= endLine; i++) {
-                commentPositions.add(i);
-            }
-        }
-        commentLines = commentPositions.size;
-        const codeLines = lines.filter((line, i) => {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                return false;
-            // If the line is not in commentPositions, it definitely has code
-            if (!commentPositions.has(i))
-                return true;
-            // If it IS in commentPositions, it might still have code (trailing comment)
-            // Remove the comment part and check if anything remains
-            const lineWithoutComments = line
-                .replace(/\/\/.*$/, "")
-                .replace(/\/\*[\s\S]*?\*\//g, "")
-                .trim();
-            return lineWithoutComments.length > 0;
-        }).length;
-        return { codeLines, commentLines };
-    }
-    // --- Private: Function Metrics Collection ---
-    /**
-     * Collect metrics for all functions in the source file
-     */
-    collectFunctionMetrics(sourceFile) {
-        const functions = [];
-        this.visitFunctionMetrics(sourceFile, sourceFile, functions, 0);
-        return functions;
-    }
-    visitFunctionMetrics(node, sourceFile, functions, nestingLevel) {
-        if (FUNCTION_LIKE_NODES.has(node.kind)) {
-            const funcNode = node;
-            const startLine = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line;
-            const endLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
-            const length = endLine - startLine + 1;
-            const cyclomatic = this.nodeCyclomaticComplexity(node, 0);
-            const cognitive = this.nodeCognitiveComplexity(node, nestingLevel);
-            const maxNesting = this.calculateMaxNesting(node, 0);
-            const name = funcNode.name
-                ? funcNode.name.getText(sourceFile)
-                : `<anonymous@L${startLine + 1}>`;
-            functions.push({
-                name,
-                line: startLine + 1,
-                length,
-                cyclomatic,
-                cognitive,
-                nestingDepth: maxNesting,
-            });
-        }
-        // Track nesting depth changes
-        const newNesting = NESTING_NODES.has(node.kind)
-            ? nestingLevel + 1
-            : nestingLevel;
-        ts.forEachChild(node, (child) => {
-            this.visitFunctionMetrics(child, sourceFile, functions, newNesting);
-        });
-    }
-    // --- Private: Max Nesting Depth ---
-    calculateMaxNesting(node, currentDepth) {
-        let maxDepth = currentDepth;
-        if (NESTING_NODES.has(node.kind)) {
-            currentDepth++;
-            maxDepth = Math.max(maxDepth, currentDepth);
-        }
-        ts.forEachChild(node, (child) => {
-            const childMax = this.calculateMaxNesting(child, currentDepth);
-            maxDepth = Math.max(maxDepth, childMax);
-        });
-        return maxDepth;
-    }
-    isLogicalOperator(node) {
-        if (node.kind === ts.SyntaxKind.BinaryExpression) {
-            const binary = node;
-            return (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                binary.operatorToken.kind === ts.SyntaxKind.BarBarToken);
-        }
-        return false;
-    }
-    nodeCyclomaticComplexity(node, complexity) {
-        // Base increment for branching nodes
-        if (CYCLOMAL_NODES.has(node.kind)) {
-            complexity++;
-        }
-        // Binary && and || add complexity
-        if (this.isLogicalOperator(node)) {
-            complexity++;
-        }
-        ts.forEachChild(node, (child) => {
-            complexity = this.nodeCyclomaticComplexity(child, complexity);
-        });
-        return complexity;
-    }
-    // --- Private: Cognitive Complexity ---
-    // Based on SonarSource's Cognitive Complexity specification
-    // Increment for: if, for, while, case, catch, conditional
-    // Additional increment for nesting
-    calculateCognitiveComplexity(node) {
-        return this.nodeCognitiveComplexity(node, 0);
-    }
-    nodeCognitiveComplexity(node, nestingDepth) {
-        let complexity = 0;
-        // Structures that contribute to cognitive complexity
-        if (COGNITIVE_NODES.has(node.kind)) {
-            // Base increment + nesting penalty
-            complexity += 1 + nestingDepth;
-        }
-        // Break/continue with label add to complexity
-        if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) {
-            if (node.label) {
-                complexity += 1 + nestingDepth;
-            }
-        }
-        // Binary && and || contribute to complexity
-        if (this.isLogicalOperator(node)) {
-            complexity += 1;
-        }
-        // Calculate nesting for children
-        const increasesNesting = NESTING_NODES.has(node.kind);
-        const childNesting = increasesNesting ? nestingDepth + 1 : nestingDepth;
-        ts.forEachChild(node, (child) => {
-            complexity += this.nodeCognitiveComplexity(child, childNesting);
-        });
-        return complexity;
-    }
-    // --- Private: Halstead Volume ---
-    // V = N * log2(n) where N = total operators+operands, n = unique operators+operands
-    calculateHalsteadVolume(node) {
-        const operators = new Set();
-        const operands = new Set();
-        let totalOperators = 0;
-        let totalOperands = 0;
-        const visit = (n) => {
-            // Check if it's an operator
-            if (HALSTEAD_OPERATORS.has(n.kind)) {
-                const opText = ts.SyntaxKind[n.kind];
-                operators.add(opText);
-                totalOperators++;
-            }
-            // Check for identifiers (operands)
-            else if (ts.isIdentifier(n)) {
-                const text = n.getText();
-                // Skip keywords that are parsed as identifiers
-                if (!this.isKeyword(text)) {
-                    operands.add(text);
-                    totalOperands++;
-                }
-            }
-            // Check for literals (operands)
-            else if (ts.isNumericLiteral(n) ||
-                ts.isStringLiteral(n) ||
-                n.kind === ts.SyntaxKind.TrueKeyword ||
-                n.kind === ts.SyntaxKind.FalseKeyword ||
-                n.kind === ts.SyntaxKind.NullKeyword ||
-                n.kind === ts.SyntaxKind.UndefinedKeyword) {
-                const text = n.getText();
-                operands.add(text);
-                totalOperands++;
-            }
-            ts.forEachChild(n, visit);
-        };
-        visit(node);
-        const uniqueOps = operators.size + operands.size;
-        const totalOps = totalOperators + totalOperands;
-        if (uniqueOps === 0 || totalOps === 0)
-            return 0;
-        // V = N * log2(n)
-        return totalOps * Math.log2(uniqueOps);
-    }
-    /**
-     * Calculate Shannon entropy of code tokens (in bits)
-     * Uses log2 for entropy measured in bits
-     * Threshold: >5.5 bits indicates risky AI-induced complexity
-     * (Increased from 3.5 to reduce false positives in tooling codebases)
-     */
-    calculateCodeEntropy(sourceText) {
-        // Tokenize by splitting on whitespace and common delimiters
-        const tokens = sourceText
-            .replace(/\/\/.*/g, "") // Remove single-line comments
-            .replace(/\/\*[\s\S]*?\*\//g, "") // Remove multi-line comments
-            .replace(/["'`][^"'`]*["'`]/g, "STR") // Normalize strings
-            .replace(/\b\d+(\.\d+)?\b/g, "NUM") // Normalize numbers
-            .split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/)
-            .filter((t) => t.length > 0);
-        if (tokens.length === 0)
-            return 0;
-        // Count token frequencies
-        const freq = new Map();
-        for (const token of tokens) {
-            freq.set(token, (freq.get(token) || 0) + 1);
-        }
-        // Calculate Shannon entropy in bits: H = -sum(p * log2(p))
-        let entropy = 0;
-        for (const count of Array.from(freq.values())) {
-            const p = count / tokens.length;
-            if (p > 0) {
-                entropy -= p * Math.log2(p);
-            }
-        }
-        return entropy; // Return in bits, not normalized
-    }
-    isKeyword(text) {
-        const keywords = new Set([
-            "if",
-            "else",
-            "for",
-            "while",
-            "do",
-            "switch",
-            "case",
-            "break",
-            "continue",
-            "return",
-            "throw",
-            "try",
-            "catch",
-            "finally",
-            "class",
-            "extends",
-            "super",
-            "import",
-            "export",
-            "default",
-            "from",
-            "as",
-            "const",
-            "let",
-            "var",
-            "function",
-            "new",
-            "delete",
-            "typeof",
-            "void",
-            "instanceof",
-            "in",
-            "of",
-            "this",
-            "true",
-            "false",
-            "null",
-            "undefined",
-            "async",
-            "await",
-            "yield",
-            "static",
-            "get",
-            "set",
-        ]);
-        return keywords.has(text);
-    }
-    // --- Private: Maintainability Index ---
-    // Microsoft's formula: MI = max(0, (171 - 5.2 * ln(Halstead) - 0.23 * Cyclomatic - 16.2 * ln(LOC)) * 100 / 171)
-    // Adjusted for comment density bonus
-    calculateMaintainabilityIndex(halstead, cyclomatic, loc, comments) {
-        if (loc === 0)
-            return 100;
-        const lnHalstead = halstead > 0 ? Math.log(halstead) : 0;
-        const lnLOC = loc > 0 ? Math.log(loc) : 0;
-        // Base MI formula
-        let mi = ((171 - 5.2 * lnHalstead - 0.23 * cyclomatic - 16.2 * lnLOC) * 100) / 171;
-        // Comment density bonus (up to +10%)
-        const commentDensity = comments / loc;
-        const commentBonus = Math.min(10, commentDensity * 50);
-        mi += commentBonus;
-        return Math.max(0, Math.min(100, mi));
-    }
 }