devkit-quality 0.1.0

package/dist/reporters.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTerminal = formatTerminal;
+exports.formatJson = formatJson;
+exports.formatMarkdown = formatMarkdown;
+exports.formatSarif = formatSarif;
+exports.formatMetrics = formatMetrics;
+exports.formatBaselineCompare = formatBaselineCompare;
+const rules_1 = require("./rules");
+const scoring_1 = require("./scoring");
+const terminal_1 = require("./terminal");
+const CATEGORY_LABELS = {
+    deadCode: 'Dead Code',
+    dependencies: 'Dependencies',
+    complexity: 'Complexity',
+    duplication: 'Duplication',
+    redundantLogic: 'Redundant Logic',
+    errorHandling: 'Error Handling',
+    typescript: 'Type Safety',
+    architecture: 'Architecture',
+    hygiene: 'Hygiene',
+    security: 'Security'
+};
+function humanizeCategory(category) {
+    return CATEGORY_LABELS[category] ?? category;
+}
+const SEVERITY_RANK = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1, INFO: 0 };
+function severityRank(severity) {
+    return SEVERITY_RANK[severity] ?? 0;
+}
+const MAX_DETAILED_FINDINGS = 6;
+function formatTerminal(summary) {
+    const lines = [];
+    lines.push(terminal_1.color.bold('DevKit Repository Scan'));
+    lines.push(terminal_1.color.dim(summary.repository));
+    lines.push('');
+    lines.push(`  ${terminal_1.color.bold(summary.score.toFixed(1))}${terminal_1.color.dim('/10')}  ${(0, terminal_1.scoreColor)(summary.score, (0, terminal_1.scoreLabel)(summary.score))}`);
+    lines.push(`  ${(0, terminal_1.renderScoreBar)(summary.score)}`);
+    lines.push('');
+    const categoryEntries = Object.entries(summary.categoryScores);
+    const nameWidth = Math.max(...categoryEntries.map(([category]) => humanizeCategory(category).length)) + 2;
+    for (const [category, score] of categoryEntries) {
+        const label = (0, terminal_1.pad)(humanizeCategory(category), nameWidth);
+        const scoreText = (0, terminal_1.padStart)(score.toFixed(1), 4);
+        lines.push(`  ${terminal_1.color.dim(label)}${(0, terminal_1.scoreColor)(score, scoreText)}`);
+    }
+    const securityLabel = (0, terminal_1.pad)('Security', nameWidth);
+    const securityScoreText = (0, terminal_1.padStart)(summary.securityScore.toFixed(1), 4);
+    lines.push(`  ${terminal_1.color.dim(securityLabel)}${(0, terminal_1.scoreColor)(summary.securityScore, securityScoreText)} ${terminal_1.color.dim('(reported separately)')}`);
+    lines.push('');
+    lines.push(terminal_1.color.dim('─'.repeat(50)));
+    if (summary.findings.length === 0) {
+        lines.push('');
+        lines.push(terminal_1.color.green('No findings. The repository looks clean.'));
+        lines.push('');
+        return lines.join('\n');
+    }
+    const bySeverityCount = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0, INFO: 0 };
+    for (const finding of summary.findings) {
+        bySeverityCount[finding.severity] += 1;
+    }
+    const severitySummary = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'INFO']
+        .filter((severity) => bySeverityCount[severity] > 0)
+        .map((severity) => (0, terminal_1.severityColor)(severity, `${bySeverityCount[severity]} ${severity.toLowerCase()}`))
+        .join(terminal_1.color.dim(' · '));
+    lines.push('');
+    lines.push(`  ${terminal_1.color.bold(String(summary.findings.length))} findings  ${terminal_1.color.dim('(')}${severitySummary}${terminal_1.color.dim(')')}`);
+    const findingsByCategory = new Map();
+    for (const finding of summary.findings) {
+        if (!findingsByCategory.has(finding.category))
+            findingsByCategory.set(finding.category, []);
+        findingsByCategory.get(finding.category).push(finding);
+    }
+    lines.push('');
+    const categoryCountWidth = Math.max(...[...findingsByCategory.keys()].map((category) => humanizeCategory(category).length)) + 2;
+    for (const [category, categoryFindings] of [...findingsByCategory.entries()].sort((a, b) => b[1].length - a[1].length)) {
+        const worst = categoryFindings.reduce((max, finding) => (severityRank(finding.severity) > severityRank(max.severity) ? finding : max));
+        lines.push(`  ${(0, terminal_1.pad)(humanizeCategory(category), categoryCountWidth)} ${terminal_1.color.dim('›')} ${(0, terminal_1.severityColor)(worst.severity, `${categoryFindings.length} finding${categoryFindings.length === 1 ? '' : 's'}`)}`);
+    }
+    const severityRankedFindings = [...summary.findings].sort((a, b) => severityRank(b.severity) - severityRank(a.severity));
+    // One representative per category (its worst finding) so the detail section reads as a
+    // scannable cross-section of the repository rather than six variations of the same rule.
+    const representativeByCategory = new Map();
+    for (const finding of severityRankedFindings) {
+        if (!representativeByCategory.has(finding.category)) {
+            representativeByCategory.set(finding.category, finding);
+        }
+    }
+    const topFindings = [...representativeByCategory.values()].slice(0, MAX_DETAILED_FINDINGS);
+    if (topFindings.length > 0) {
+        lines.push('');
+        lines.push(terminal_1.color.dim('─'.repeat(50)));
+        lines.push('');
+        lines.push(terminal_1.color.bold('Top issues'));
+    }
+    for (const finding of topFindings) {
+        lines.push('');
+        lines.push(`  ${terminal_1.color.dim(`${humanizeCategory(finding.category)}:`)} ${(0, terminal_1.severityColor)(finding.severity, finding.message)} ${terminal_1.color.dim(`[${finding.ruleId}]`)}`);
+        lines.push(`  ${finding.description}`);
+        lines.push(`  ${terminal_1.color.dim('→')} ${finding.suggestion}`);
+        lines.push(`  ${terminal_1.color.cyan(`${finding.file}:${finding.line}`)}`);
+        lines.push('');
+        for (const frameLine of (0, terminal_1.renderCodeFrame)(summary.repository, finding.file, finding.line, finding.column, finding.severity)) {
+            lines.push(frameLine);
+        }
+    }
+    const remaining = summary.findings.length - topFindings.length;
+    lines.push('');
+    lines.push(terminal_1.color.dim('─'.repeat(50)));
+    lines.push('');
+    if (remaining > 0) {
+        lines.push(terminal_1.color.dim(`  + ${remaining} more finding${remaining === 1 ? '' : 's'} not shown above.`));
+    }
+    lines.push(`  ${terminal_1.color.dim('devkit scan --format json')}      full machine-readable output`);
+    lines.push(`  ${terminal_1.color.dim('devkit scan --category <name>')}  focus on one category`);
+    lines.push(`  ${terminal_1.color.dim('devkit explain <RULE_ID>')}       why a rule exists and how to fix it`);
+    lines.push(`  ${terminal_1.color.dim('devkit fix')}                    preview findings marked safe to fix`);
+    lines.push('');
+    return lines.join('\n');
+}
+function formatJson(summary) {
+    return JSON.stringify(summary, null, 2);
+}
+function formatMarkdown(summary) {
+    const lines = [];
+    lines.push('# DevKit Scan Report');
+    lines.push('');
+    lines.push(`- Repository: ${summary.repository}`);
+    lines.push(`- Overall score: ${summary.score.toFixed(1)} / 10`);
+    lines.push(`- Security score (reported separately): ${summary.securityScore.toFixed(1)} / 10`);
+    lines.push('');
+    lines.push('## Category scores');
+    lines.push('');
+    lines.push('| Category | Score |');
+    lines.push('| --- | ---: |');
+    for (const [category, score] of Object.entries(summary.categoryScores)) {
+        lines.push(`| ${humanizeCategory(category)} | ${score.toFixed(1)} |`);
+    }
+    lines.push('');
+    lines.push('## Main deductions');
+    lines.push('');
+    const deductions = (0, scoring_1.summarizeTopDeductions)(summary.findings);
+    if (deductions.length === 0) {
+        lines.push('No deductions.');
+    }
+    else {
+        for (const deduction of deductions) {
+            lines.push(`- ${deduction.count} ${deduction.ruleId} finding(s) (${humanizeCategory(deduction.category)})`);
+        }
+    }
+    lines.push('');
+    lines.push('## Findings');
+    lines.push('');
+    if (summary.findings.length === 0) {
+        lines.push('No findings.');
+    }
+    else {
+        for (const finding of summary.findings) {
+            lines.push(`- ${finding.ruleId}: ${finding.message} (${finding.severity}) in ${finding.file}:${finding.line}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatSarif(summary) {
+    const results = summary.findings.map((finding) => ({
+        ruleId: finding.ruleId,
+        level: finding.severity === 'CRITICAL' || finding.severity === 'HIGH' ? 'error' : finding.severity === 'MEDIUM' ? 'warning' : 'note',
+        message: {
+            text: finding.message
+        },
+        locations: [
+            {
+                physicalLocation: {
+                    artifactLocation: {
+                        uri: finding.file
+                    },
+                    region: {
+                        startLine: finding.line,
+                        startColumn: finding.column
+                    }
+                }
+            }
+        ]
+    }));
+    const sarifRules = (0, rules_1.listRules)().map((rule) => ({
+        id: rule.id,
+        name: rule.title,
+        shortDescription: { text: rule.title },
+        fullDescription: { text: rule.description },
+        helpUri: '',
+        properties: {
+            category: rule.category,
+            severity: rule.severity,
+            confidence: rule.confidence
+        }
+    }));
+    return JSON.stringify({
+        version: '2.1.0',
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: 'DevKit',
+                        rules: sarifRules
+                    }
+                },
+                results
+            }
+        ]
+    }, null, 2);
+}
+function formatMetrics(summary) {
+    const metrics = summary.metrics;
+    const lines = [];
+    lines.push(terminal_1.color.bold('Repository metrics'));
+    lines.push(terminal_1.color.dim(summary.repository));
+    lines.push('');
+    lines.push(`  totalFiles            ${terminal_1.color.bold(String(metrics.totalFiles))}`);
+    lines.push(`  sourceFiles           ${metrics.sourceFiles}`);
+    lines.push(`  testFiles             ${metrics.testFiles}`);
+    lines.push(`  totalLOC              ${metrics.totalLOC}`);
+    lines.push(`  sourceLOC             ${metrics.sourceLOC}`);
+    lines.push(`  testLOC               ${metrics.testLOC}`);
+    lines.push(`  commentLOC            ${metrics.commentLOC}`);
+    lines.push(`  functionCount         ${metrics.functionCount}`);
+    lines.push(`  classCount            ${metrics.classCount}`);
+    lines.push(`  dependencyCount       ${metrics.dependencyCount}`);
+    lines.push(`  averageFunctionSize   ${metrics.averageFunctionSize.toFixed(1)}`);
+    lines.push(`  duplicationPercentage ${metrics.duplicationPercentage.toFixed(1)}%`);
+    lines.push(`  deadCodePercentage    ${metrics.deadCodePercentage.toFixed(1)}%`);
+    lines.push(`  testToSourceRatio     ${metrics.testToSourceRatio.toFixed(2)}`);
+    if (metrics.largestFunctions.length > 0) {
+        lines.push('');
+        lines.push(terminal_1.color.bold('Largest functions'));
+        for (const fn of metrics.largestFunctions) {
+            lines.push(`  ${terminal_1.color.cyan(fn.name)} ${terminal_1.color.dim(`(${fn.file})`)} - ${fn.size} lines`);
+        }
+    }
+    if (metrics.largestFiles.length > 0) {
+        lines.push('');
+        lines.push(terminal_1.color.bold('Largest files'));
+        for (const file of metrics.largestFiles) {
+            lines.push(`  ${terminal_1.color.cyan(file.file)} - ${file.loc} lines`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatBaselineCompare(previousScore, currentScore) {
+    const delta = Number((currentScore - previousScore).toFixed(1));
+    const lines = [];
+    lines.push(terminal_1.color.bold('Baseline compare'));
+    lines.push(`  Previous score: ${previousScore.toFixed(1)}`);
+    lines.push(`  Current score:  ${currentScore.toFixed(1)}`);
+    const deltaText = `${delta >= 0 ? '+' : ''}${delta.toFixed(1)}`;
+    lines.push(`  Regression:     ${delta < 0 ? terminal_1.color.red(deltaText) : terminal_1.color.green(deltaText)}`);
+    return lines.join('\n');
+}

package/dist/rules/architecture.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runArchitectureRules = runArchitectureRules;
+const node_path_1 = __importDefault(require("node:path"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const glob_1 = require("../glob");
+function layerForFile(relativePath, layers) {
+    for (const [layerName, layer] of Object.entries(layers)) {
+        if ((0, glob_1.matchesAnyGlob)(relativePath, layer.match)) {
+            return layerName;
+        }
+    }
+    return null;
+}
+function runArchitectureRules(context) {
+    if (!(0, config_1.isRuleEnabled)(context.config, 'ARCH001'))
+        return [];
+    const layers = context.config.architecture?.layers;
+    if (!layers || Object.keys(layers).length === 0)
+        return [];
+    const findings = [];
+    const { moduleGraph, projectRoot } = context;
+    for (const [file, targets] of moduleGraph.edges) {
+        const sourceRelative = node_path_1.default.relative(projectRoot, file).replace(/\\/g, '/');
+        const sourceLayer = layerForFile(sourceRelative, layers);
+        if (!sourceLayer)
+            continue;
+        const forbidden = layers[sourceLayer].cannotImport ?? [];
+        if (forbidden.length === 0)
+            continue;
+        for (const target of targets) {
+            const targetRelative = node_path_1.default.relative(projectRoot, target).replace(/\\/g, '/');
+            const targetLayer = layerForFile(targetRelative, layers);
+            if (!targetLayer || !forbidden.includes(targetLayer))
+                continue;
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'ARCH001',
+                category: 'architecture',
+                severity: 'HIGH',
+                confidence: 'CERTAIN',
+                file: sourceRelative,
+                line: 1,
+                column: 1,
+                message: 'Forbidden layer import',
+                description: `Layer "${sourceLayer}" is configured to never import from layer "${targetLayer}".`,
+                evidence: `${sourceRelative} -> ${targetRelative}`,
+                suggestion: 'Remove the import or restructure the dependency to respect the architecture boundary.',
+                fixAvailable: false
+            }));
+        }
+    }
+    return findings;
+}

package/dist/rules/complexity.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectFunctionMetrics = collectFunctionMetrics;
+exports.runComplexityRules = runComplexityRules;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const finding_1 = require("../finding");
+const config_1 = require("../config");
+const walk_1 = require("../ast/walk");
+const DEFAULT_THRESHOLDS = {
+    COMPLEX001: 10,
+    COMPLEX002: 15,
+    COMPLEX003: 100,
+    COMPLEX004: 5,
+    COMPLEX005: 4
+};
+function severityForOverage(value, max) {
+    return value >= max * 2 ? 'HIGH' : 'MEDIUM';
+}
+function computeFunctionMetrics(node, sourceFile) {
+    let cyclomatic = 1;
+    let cognitive = 0;
+    let statementCount = 0;
+    let returnCount = 0;
+    let maxNesting = 0;
+    const visit = (current, nestingLevel, isElseIfChain) => {
+        if (current !== node && (0, walk_1.isFunctionLike)(current)) {
+            return;
+        }
+        if (typescript_1.default.isStatement(current)) {
+            statementCount += 1;
+        }
+        if (typescript_1.default.isReturnStatement(current)) {
+            returnCount += 1;
+        }
+        if (typescript_1.default.isIfStatement(current)) {
+            maxNesting = Math.max(maxNesting, nestingLevel + 1);
+            cyclomatic += 1;
+            cognitive += isElseIfChain ? 1 : 1 + nestingLevel;
+            visit(current.thenStatement, nestingLevel + 1, false);
+            if (current.elseStatement) {
+                const elseIsIf = typescript_1.default.isIfStatement(current.elseStatement);
+                visit(current.elseStatement, nestingLevel + (elseIsIf ? 0 : 1), elseIsIf);
+            }
+            return;
+        }
+        if (typescript_1.default.isForStatement(current) ||
+            typescript_1.default.isForInStatement(current) ||
+            typescript_1.default.isForOfStatement(current) ||
+            typescript_1.default.isWhileStatement(current) ||
+            typescript_1.default.isDoStatement(current)) {
+            maxNesting = Math.max(maxNesting, nestingLevel + 1);
+            cyclomatic += 1;
+            cognitive += 1 + nestingLevel;
+            typescript_1.default.forEachChild(current, (child) => visit(child, nestingLevel + 1, false));
+            return;
+        }
+        if (typescript_1.default.isSwitchStatement(current)) {
+            maxNesting = Math.max(maxNesting, nestingLevel + 1);
+            cognitive += 1 + nestingLevel;
+            for (const clause of current.caseBlock.clauses) {
+                if (typescript_1.default.isCaseClause(clause)) {
+                    cyclomatic += 1;
+                }
+                for (const statement of clause.statements) {
+                    visit(statement, nestingLevel + 1, false);
+                }
+            }
+            return;
+        }
+        if (typescript_1.default.isCatchClause(current)) {
+            maxNesting = Math.max(maxNesting, nestingLevel + 1);
+            cyclomatic += 1;
+            cognitive += 1 + nestingLevel;
+            typescript_1.default.forEachChild(current, (child) => visit(child, nestingLevel + 1, false));
+            return;
+        }
+        if (typescript_1.default.isConditionalExpression(current)) {
+            cyclomatic += 1;
+            cognitive += 1 + nestingLevel;
+            visit(current.condition, nestingLevel, false);
+            visit(current.whenTrue, nestingLevel + 1, false);
+            visit(current.whenFalse, nestingLevel + 1, false);
+            return;
+        }
+        if (typescript_1.default.isBinaryExpression(current)) {
+            const operator = current.operatorToken.kind;
+            const isLogical = operator === typescript_1.default.SyntaxKind.AmpersandAmpersandToken ||
+                operator === typescript_1.default.SyntaxKind.BarBarToken ||
+                operator === typescript_1.default.SyntaxKind.QuestionQuestionToken;
+            if (isLogical) {
+                cyclomatic += 1;
+                const parent = current.parent;
+                const sameChainAsParent = typescript_1.default.isBinaryExpression(parent) && parent.operatorToken.kind === operator;
+                if (!sameChainAsParent) {
+                    cognitive += 1;
+                }
+            }
+        }
+        typescript_1.default.forEachChild(current, (child) => visit(child, nestingLevel, false));
+    };
+    const body = node.body;
+    if (body) {
+        visit(body, 0, false);
+    }
+    const start = (0, walk_1.lineAndColumn)(sourceFile, node.getStart()).line;
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+    return {
+        line: start,
+        lines: end - start + 1,
+        cyclomatic,
+        cognitive,
+        parameters: node.parameters.length,
+        nestingDepth: maxNesting,
+        statementCount,
+        returnCount
+    };
+}
+function collectFunctionMetrics(context) {
+    const metrics = [];
+    for (const file of context.files) {
+        const sourceFile = context.program.getSourceFile(file);
+        if (!sourceFile)
+            continue;
+        const relativePath = node_path_1.default.relative(context.projectRoot, file).replace(/\\/g, '/');
+        const visit = (node) => {
+            if ((0, walk_1.isFunctionLike)(node) && node.body) {
+                const computed = computeFunctionMetrics(node, sourceFile);
+                metrics.push({ name: (0, walk_1.getFunctionName)(node), file: relativePath, ...computed });
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return metrics;
+}
+function runComplexityRules(context, functionMetrics) {
+    const findings = [];
+    const cyclomaticMax = (0, config_1.getRuleThreshold)(context.config, 'COMPLEX001', DEFAULT_THRESHOLDS.COMPLEX001);
+    const cognitiveMax = (0, config_1.getRuleThreshold)(context.config, 'COMPLEX002', DEFAULT_THRESHOLDS.COMPLEX002);
+    const linesMax = (0, config_1.getRuleThreshold)(context.config, 'COMPLEX003', DEFAULT_THRESHOLDS.COMPLEX003);
+    const paramsMax = (0, config_1.getRuleThreshold)(context.config, 'COMPLEX004', DEFAULT_THRESHOLDS.COMPLEX004);
+    const nestingMax = (0, config_1.getRuleThreshold)(context.config, 'COMPLEX005', DEFAULT_THRESHOLDS.COMPLEX005);
+    for (const metric of functionMetrics) {
+        if ((0, config_1.isRuleEnabled)(context.config, 'COMPLEX001') && metric.cyclomatic > cyclomaticMax) {
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'COMPLEX001',
+                category: 'complexity',
+                severity: severityForOverage(metric.cyclomatic, cyclomaticMax),
+                confidence: 'HIGH',
+                file: metric.file,
+                line: metric.line,
+                column: 1,
+                message: 'High cyclomatic complexity function',
+                description: `Function "${metric.name}" has cyclomatic complexity ${metric.cyclomatic} (max ${cyclomaticMax}).`,
+                evidence: `cyclomatic=${metric.cyclomatic}`,
+                suggestion: 'Split the function into smaller units or reduce branching.',
+                fixAvailable: false
+            }));
+        }
+        if ((0, config_1.isRuleEnabled)(context.config, 'COMPLEX002') && metric.cognitive > cognitiveMax) {
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'COMPLEX002',
+                category: 'complexity',
+                severity: severityForOverage(metric.cognitive, cognitiveMax),
+                confidence: 'HIGH',
+                file: metric.file,
+                line: metric.line,
+                column: 1,
+                message: 'High cognitive complexity function',
+                description: `Function "${metric.name}" has cognitive complexity ${metric.cognitive} (max ${cognitiveMax}).`,
+                evidence: `cognitive=${metric.cognitive}`,
+                suggestion: 'Reduce nesting and simplify control flow.',
+                fixAvailable: false
+            }));
+        }
+        if ((0, config_1.isRuleEnabled)(context.config, 'COMPLEX003') && metric.lines > linesMax) {
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'COMPLEX003',
+                category: 'complexity',
+                severity: severityForOverage(metric.lines, linesMax),
+                confidence: 'HIGH',
+                file: metric.file,
+                line: metric.line,
+                column: 1,
+                message: 'Function too long',
+                description: `Function "${metric.name}" spans ${metric.lines} lines (max ${linesMax}).`,
+                evidence: `lines=${metric.lines}`,
+                suggestion: 'Extract smaller helper functions.',
+                fixAvailable: false
+            }));
+        }
+        if ((0, config_1.isRuleEnabled)(context.config, 'COMPLEX004') && metric.parameters > paramsMax) {
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'COMPLEX004',
+                category: 'complexity',
+                severity: severityForOverage(metric.parameters, paramsMax),
+                confidence: 'HIGH',
+                file: metric.file,
+                line: metric.line,
+                column: 1,
+                message: 'Too many parameters',
+                description: `Function "${metric.name}" takes ${metric.parameters} parameters (max ${paramsMax}).`,
+                evidence: `parameters=${metric.parameters}`,
+                suggestion: 'Group related parameters into an options object.',
+                fixAvailable: false
+            }));
+        }
+        if ((0, config_1.isRuleEnabled)(context.config, 'COMPLEX005') && metric.nestingDepth > nestingMax) {
+            findings.push((0, finding_1.buildFinding)({
+                ruleId: 'COMPLEX005',
+                category: 'complexity',
+                severity: severityForOverage(metric.nestingDepth, nestingMax),
+                confidence: 'HIGH',
+                file: metric.file,
+                line: metric.line,
+                column: 1,
+                message: 'Excessive nesting depth',
+                description: `Function "${metric.name}" nests ${metric.nestingDepth} levels deep (max ${nestingMax}).`,
+                evidence: `nestingDepth=${metric.nestingDepth}`,
+                suggestion: 'Use early returns or extract nested blocks into their own functions.',
+                fixAvailable: false
+            }));
+        }
+    }
+    return findings;
+}