api-tests-coverage 1.0.23 → 1.0.25

package/dist/src/unitAnalysis.js

@@ -0,0 +1,1392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeUnitTests = analyzeUnitTests;
+exports.parseJacocoXml = parseJacocoXml;
+exports.parseIstanbulSummary = parseIstanbulSummary;
+exports.parseLcovInfo = parseLcovInfo;
+exports.parseCoverageXml = parseCoverageXml;
+exports.parseGoCoverage = parseGoCoverage;
+exports.parseStrykerReport = parseStrykerReport;
+exports.parseSlowTests = parseSlowTests;
+exports.detectTestSmells = detectTestSmells;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const COVERAGE_REPORT_CANDIDATES = [
+    'target/site/jacoco/jacoco.xml',
+    'build/reports/jacoco/test/jacocoTestReport.xml',
+    'coverage/coverage-summary.json',
+    'coverage/lcov.info',
+    'coverage.xml',
+    '.coverage',
+    'coverage.out',
+];
+const TEST_RESULT_GLOBS = [
+    'target/surefire-reports/*.xml',
+    'build/test-results/**/*.xml',
+    'reports/junit*.xml',
+    'junit*.xml',
+    'results.xml',
+    'jest-results.json',
+    'reports/jest-results.json',
+];
+const PIT_REPORT_GLOBS = [
+    'target/pit-reports/**/mutations.xml',
+    'build/reports/pitest/**/mutations.xml',
+];
+const STRYKER_REPORT_GLOBS = [
+    'reports/mutation/mutation-report.json',
+    'reports/stryker/mutation-report.json',
+    'StrykerOutput/**/mutation-report.json',
+];
+async function analyzeUnitTests(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    const rootDir = path.resolve(options.rootDir);
+    const unitConfig = options.config;
+    const testAnalyses = options.testFiles.map((filePath) => analyzeTestFile(rootDir, filePath));
+    const sourceMethods = options.serviceFiles.flatMap((filePath) => discoverSourceMethods(rootDir, filePath));
+    const unitItems = buildUnitCoverageItems(sourceMethods, testAnalyses);
+    const assertionDensity = computeAssertionDensity(testAnalyses);
+    const smells = ((_a = unitConfig.smellDetection) === null || _a === void 0 ? void 0 : _a.enabled) !== false
+        ? detectTestSmells(rootDir, testAnalyses)
+        : [];
+    const slowTests = parseSlowTests(rootDir, unitConfig);
+    const independence = ((_b = unitConfig.independenceCheck) === null || _b === void 0 ? void 0 : _b.enabled) !== false
+        ? computeIndependence(rootDir, testAnalyses)
+        : null;
+    const coverageDiscovery = ((_c = unitConfig.codeCoverage) === null || _c === void 0 ? void 0 : _c.enabled) !== false
+        ? discoverCoverage(rootDir)
+        : null;
+    const mutationTesting = ((_d = unitConfig.mutationTesting) === null || _d === void 0 ? void 0 : _d.enabled)
+        ? runMutationTesting(rootDir, (_e = options.languages) !== null && _e !== void 0 ? _e : [], unitConfig)
+        : null;
+    const failures = [];
+    const warnings = [];
+    const messages = [];
+    if (coverageDiscovery) {
+        if (coverageDiscovery.summary) {
+            const coverageThresholds = (_f = unitConfig.codeCoverage) === null || _f === void 0 ? void 0 : _f.thresholds;
+            if ((coverageThresholds === null || coverageThresholds === void 0 ? void 0 : coverageThresholds.line) !== undefined && coverageDiscovery.summary.lineCoverage !== null && coverageDiscovery.summary.lineCoverage < coverageThresholds.line) {
+                failures.push(`Unit line coverage ${coverageDiscovery.summary.lineCoverage.toFixed(1)}% is below threshold ${coverageThresholds.line}%`);
+            }
+            if ((coverageThresholds === null || coverageThresholds === void 0 ? void 0 : coverageThresholds.branch) !== undefined && coverageDiscovery.summary.branchCoverage !== null && coverageDiscovery.summary.branchCoverage < coverageThresholds.branch) {
+                failures.push(`Unit branch coverage ${coverageDiscovery.summary.branchCoverage.toFixed(1)}% is below threshold ${coverageThresholds.branch}%`);
+            }
+            if ((coverageThresholds === null || coverageThresholds === void 0 ? void 0 : coverageThresholds.method) !== undefined && coverageDiscovery.summary.methodCoverage !== null && coverageDiscovery.summary.methodCoverage < coverageThresholds.method) {
+                failures.push(`Unit method coverage ${coverageDiscovery.summary.methodCoverage.toFixed(1)}% is below threshold ${coverageThresholds.method}%`);
+            }
+        }
+        else if (coverageDiscovery.missing) {
+            messages.push(coverageDiscovery.missing.message);
+            messages.push(coverageDiscovery.missing.hint);
+        }
+    }
+    if (mutationTesting === null || mutationTesting === void 0 ? void 0 : mutationTesting.summary) {
+        const threshold = (_h = (_g = unitConfig.mutationTesting) === null || _g === void 0 ? void 0 : _g.threshold) !== null && _h !== void 0 ? _h : 70;
+        if (mutationTesting.summary.mutationScore < threshold) {
+            failures.push(`Mutation score ${mutationTesting.summary.mutationScore.toFixed(1)}% is below threshold ${threshold}%`);
+        }
+    }
+    if (mutationTesting === null || mutationTesting === void 0 ? void 0 : mutationTesting.warning) {
+        warnings.push(mutationTesting.warning);
+    }
+    const smellFailOn = (_k = (_j = unitConfig.smellDetection) === null || _j === void 0 ? void 0 : _j.failOn) !== null && _k !== void 0 ? _k : 'CRITICAL';
+    if (smellFailOn !== 'none') {
+        const hasBlockingSmell = smells.some((smell) => severityAtOrAbove(smell.severity, smellFailOn));
+        if (hasBlockingSmell) {
+            failures.push(`Detected test smells at or above ${smellFailOn} severity`);
+        }
+    }
+    if (independence && ((_l = unitConfig.independenceCheck) === null || _l === void 0 ? void 0 : _l.minScore) !== undefined && independence.score < unitConfig.independenceCheck.minScore) {
+        failures.push(`Test independence score ${independence.score} is below minimum ${unitConfig.independenceCheck.minScore}`);
+    }
+    const details = {
+        items: unitItems,
+        codeCoverage: (_m = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _m !== void 0 ? _m : null,
+        codeCoverageMissing: coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.missing,
+        mutationTesting: (_o = mutationTesting === null || mutationTesting === void 0 ? void 0 : mutationTesting.summary) !== null && _o !== void 0 ? _o : null,
+        testSmells: {
+            bySeverity: summarizeSmells(smells),
+            items: smells,
+        },
+        slowTests,
+        independence,
+        assertionDensity,
+        messages,
+    };
+    return {
+        result: {
+            type: 'unit',
+            totalItems: unitItems.length,
+            coveredItems: unitItems.filter((item) => item.covered).length,
+            coveragePercent: unitItems.length > 0
+                ? Number(((unitItems.filter((item) => item.covered).length / unitItems.length) * 100).toFixed(1))
+                : 0,
+            details,
+        },
+        failures,
+        warnings,
+    };
+}
+function analyzeTestFile(rootDir, filePath) {
+    const content = safeRead(filePath);
+    const language = detectTestLanguage(filePath);
+    const blocks = extractTestBlocks(language, content);
+    const assertionCount = countAssertions(language, content);
+    return {
+        filePath,
+        relativePath: normalizePath(path.relative(rootDir, filePath)),
+        language,
+        content,
+        qualityScore: scoreTestQuality(content),
+        parameterizedExpansions: countParameterizedExpansions(content),
+        assertionCount,
+        mockLibrary: detectMockLibrary(content),
+        layer: classifyLayer(content, filePath),
+        coveredMethods: extractCoveredMethods(language, content),
+        instantiatedClasses: extractInstantiatedClasses(content),
+    };
+}
+function discoverSourceMethods(rootDir, filePath) {
+    const content = safeRead(filePath);
+    const language = detectTestLanguage(filePath);
+    const relative = normalizePath(path.relative(rootDir, filePath));
+    if (language === 'java' || language === 'kotlin') {
+        const className = path.basename(filePath, path.extname(filePath));
+        const regex = /(?:public|protected|private|internal)?\s*(?:suspend\s+)?(?:async\s+)?(?:static\s+)?(?:final\s+)?(?:[\w<>\[\],?]+\s+)+([a-zA-Z_]\w*)\s*\([^;{]*\)\s*\{/g;
+        const methods = [];
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const methodName = match[1];
+            if (methodName === className)
+                continue;
+            methods.push({
+                id: `${className}.${methodName}`,
+                className,
+                methodName,
+                file: relative,
+            });
+        }
+        return dedupeBy(methods, (method) => method.id);
+    }
+    if (language === 'typescript' || language === 'javascript') {
+        const className = path.basename(filePath, path.extname(filePath));
+        const methods = [];
+        const classMethodRegex = /(?:public|protected|private|async|static|get|set|readonly|#)?\s*([a-zA-Z_]\w*)\s*\([^;{]*\)\s*\{/g;
+        let match;
+        while ((match = classMethodRegex.exec(content)) !== null) {
+            const methodName = match[1];
+            if (['if', 'for', 'while', 'switch', 'catch', 'constructor'].includes(methodName))
+                continue;
+            methods.push({ id: `${className}.${methodName}`, className, methodName, file: relative });
+        }
+        const exportedFunctionRegex = /export\s+(?:async\s+)?function\s+([a-zA-Z_]\w*)\s*\(/g;
+        while ((match = exportedFunctionRegex.exec(content)) !== null) {
+            const methodName = match[1];
+            methods.push({ id: `${className}.${methodName}`, className, methodName, file: relative });
+        }
+        return dedupeBy(methods, (method) => method.id);
+    }
+    if (language === 'python') {
+        const className = path.basename(filePath, path.extname(filePath));
+        const methods = [];
+        const regex = /^\s*def\s+([a-zA-Z_]\w*)\s*\(/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const methodName = match[1];
+            if (methodName.startsWith('_'))
+                continue;
+            methods.push({ id: `${className}.${methodName}`, className, methodName, file: relative });
+        }
+        return dedupeBy(methods, (method) => method.id);
+    }
+    return [];
+}
+function buildUnitCoverageItems(sourceMethods, testAnalyses) {
+    var _a, _b, _c, _d;
+    const byMethod = new Map();
+    for (const method of sourceMethods) {
+        byMethod.set(method.id, {
+            id: method.id,
+            covered: false,
+            tests: [],
+        });
+    }
+    for (const test of testAnalyses) {
+        for (const methodId of test.coveredMethods) {
+            const existing = (_a = byMethod.get(methodId)) !== null && _a !== void 0 ? _a : {
+                id: methodId,
+                covered: false,
+                tests: [],
+            };
+            const next = {
+                ...existing,
+                covered: true,
+                tests: dedupeStrings([...existing.tests, path.basename(test.relativePath)]),
+                layer: test.layer,
+                mockLibrary: test.mockLibrary,
+                qualityScore: Math.max((_b = existing.qualityScore) !== null && _b !== void 0 ? _b : 0, test.qualityScore),
+                parameterizedExpansions: ((_c = existing.parameterizedExpansions) !== null && _c !== void 0 ? _c : 0) + test.parameterizedExpansions,
+                assertionCount: Math.max((_d = existing.assertionCount) !== null && _d !== void 0 ? _d : 0, test.assertionCount),
+            };
+            byMethod.set(methodId, next);
+        }
+    }
+    return Array.from(byMethod.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+function discoverCoverage(rootDir) {
+    const checkedPaths = COVERAGE_REPORT_CANDIDATES.map((candidate) => normalizePath(candidate));
+    for (const candidate of COVERAGE_REPORT_CANDIDATES) {
+        const fullPath = path.join(rootDir, candidate);
+        if (!fs.existsSync(fullPath))
+            continue;
+        if (candidate.endsWith('jacoco.xml') || candidate.endsWith('jacocoTestReport.xml')) {
+            return { summary: parseJacocoXml(fullPath) };
+        }
+        if (candidate.endsWith('coverage-summary.json')) {
+            return { summary: parseIstanbulSummary(fullPath) };
+        }
+        if (candidate.endsWith('lcov.info')) {
+            return { summary: parseLcovInfo(fullPath) };
+        }
+        if (candidate === 'coverage.xml') {
+            return { summary: parseCoverageXml(fullPath) };
+        }
+        if (candidate === 'coverage.out') {
+            return { summary: parseGoCoverage(fullPath) };
+        }
+    }
+    return {
+        summary: null,
+        missing: {
+            message: 'Run tests with coverage enabled to see report',
+            hint: 'Add jacoco plugin to build.gradle',
+            checkedPaths,
+        },
+    };
+}
+function parseJacocoXml(reportPath) {
+    var _a;
+    const xml = safeRead(reportPath);
+    const counters = extractCounters(xml);
+    const uncoveredMethods = [];
+    const classRegex = /<class\b([^>]*?)name="([^"]+)"([^>]*?)sourcefilename="([^"]+)"([^>]*)>([\s\S]*?)<\/class>/g;
+    let classMatch;
+    while ((classMatch = classRegex.exec(xml)) !== null) {
+        const className = (_a = classMatch[2].split('/').pop()) !== null && _a !== void 0 ? _a : classMatch[2];
+        const file = classMatch[4];
+        const classBody = classMatch[6];
+        const methodRegex = /<method\b[^>]*name="([^"]+)"[^>]*line="(\d+)"[^>]*>([\s\S]*?)<\/method>/g;
+        let methodMatch;
+        while ((methodMatch = methodRegex.exec(classBody)) !== null) {
+            const methodName = methodMatch[1];
+            const line = Number(methodMatch[2]);
+            const body = methodMatch[3];
+            const lineCounter = /<counter\b[^>]*type="LINE"[^>]*missed="(\d+)"[^>]*covered="(\d+)"/.exec(body);
+            if (lineCounter && Number(lineCounter[1]) > 0) {
+                uncoveredMethods.push({ class: className, method: methodName, file, line });
+            }
+        }
+    }
+    return {
+        tool: 'jacoco',
+        lineCoverage: coveragePercent(counters.LINE),
+        branchCoverage: coveragePercent(counters.BRANCH),
+        methodCoverage: coveragePercent(counters.METHOD),
+        classCoverage: coveragePercent(counters.CLASS),
+        uncoveredMethods,
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseIstanbulSummary(reportPath) {
+    var _a;
+    const json = JSON.parse(safeRead(reportPath));
+    const total = ((_a = json['total']) !== null && _a !== void 0 ? _a : {});
+    return {
+        tool: 'istanbul',
+        lineCoverage: readPct(total, 'lines'),
+        branchCoverage: readPct(total, 'branches'),
+        methodCoverage: readPct(total, 'functions'),
+        classCoverage: readPct(total, 'statements'),
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseLcovInfo(reportPath) {
+    var _a, _b;
+    const content = safeRead(reportPath);
+    const files = content.split('end_of_record').map((chunk) => chunk.trim()).filter(Boolean);
+    let totalLines = 0;
+    let hitLines = 0;
+    let totalBranches = 0;
+    let hitBranches = 0;
+    let totalFunctions = 0;
+    let hitFunctions = 0;
+    let coveredFiles = 0;
+    const uncoveredMethods = [];
+    for (const fileChunk of files) {
+        const lines = fileChunk.split('\n');
+        const file = (_b = (_a = lines.find((line) => line.startsWith('SF:'))) === null || _a === void 0 ? void 0 : _a.slice(3)) !== null && _b !== void 0 ? _b : 'unknown';
+        const fnMap = new Map();
+        let fileCovered = false;
+        for (const line of lines) {
+            if (line.startsWith('LF:'))
+                totalLines += Number(line.slice(3));
+            if (line.startsWith('LH:')) {
+                const hits = Number(line.slice(3));
+                hitLines += hits;
+                if (hits > 0)
+                    fileCovered = true;
+            }
+            if (line.startsWith('BRF:'))
+                totalBranches += Number(line.slice(4));
+            if (line.startsWith('BRH:'))
+                hitBranches += Number(line.slice(4));
+            if (line.startsWith('FNF:'))
+                totalFunctions += Number(line.slice(4));
+            if (line.startsWith('FNH:'))
+                hitFunctions += Number(line.slice(4));
+            if (line.startsWith('FN:')) {
+                const [lineNo, name] = line.slice(3).split(',');
+                fnMap.set(name, { line: Number(lineNo), hits: 0 });
+            }
+            if (line.startsWith('FNDA:')) {
+                const [hits, name] = line.slice(5).split(',');
+                const entry = fnMap.get(name);
+                if (entry)
+                    entry.hits = Number(hits);
+            }
+        }
+        if (fileCovered)
+            coveredFiles += 1;
+        for (const [name, data] of fnMap.entries()) {
+            if (data.hits === 0) {
+                uncoveredMethods.push({
+                    class: path.basename(file, path.extname(file)),
+                    method: name,
+                    file: normalizePath(file),
+                    line: data.line,
+                });
+            }
+        }
+    }
+    return {
+        tool: 'lcov',
+        lineCoverage: safePercent(hitLines, totalLines),
+        branchCoverage: safePercent(hitBranches, totalBranches),
+        methodCoverage: safePercent(hitFunctions, totalFunctions),
+        classCoverage: files.length > 0 ? Number(((coveredFiles / files.length) * 100).toFixed(1)) : null,
+        uncoveredMethods,
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseCoverageXml(reportPath) {
+    var _a;
+    const xml = safeRead(reportPath);
+    const linesValid = readNumericAttribute(xml, 'lines-valid');
+    const linesCovered = readNumericAttribute(xml, 'lines-covered');
+    const branchesValid = readNumericAttribute(xml, 'branches-valid');
+    const branchesCovered = readNumericAttribute(xml, 'branches-covered');
+    const classes = [...xml.matchAll(/<class\b[^>]*name="([^"]+)"[^>]*filename="([^"]+)"[\s\S]*?<\/class>/g)];
+    const coveredClasses = classes.filter((match) => /line-rate="(?!0(?:\.0+)?)\d*\.?\d+"/.test(match[0])).length;
+    const uncoveredMethods = [];
+    const methodRegex = /<method\b[^>]*name="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*>([\s\S]*?)<\/method>/g;
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(xml)) !== null) {
+        if (Number(methodMatch[2]) === 0) {
+            const line = (_a = readNumericAttribute(methodMatch[3], 'number')) !== null && _a !== void 0 ? _a : 0;
+            uncoveredMethods.push({
+                class: 'coverage.py',
+                method: methodMatch[1],
+                file: 'coverage.xml',
+                line,
+            });
+        }
+    }
+    const totalMethods = [...xml.matchAll(/<method\b/g)].length;
+    const coveredMethods = [...xml.matchAll(/<method\b[^>]*line-rate="(?!0(?:\.0+)?)\d*\.?\d+"/g)].length;
+    return {
+        tool: 'coverage.py',
+        lineCoverage: safePercent(linesCovered, linesValid),
+        branchCoverage: safePercent(branchesCovered, branchesValid),
+        methodCoverage: safePercent(coveredMethods, totalMethods),
+        classCoverage: classes.length > 0 ? Number(((coveredClasses / classes.length) * 100).toFixed(1)) : null,
+        uncoveredMethods,
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseGoCoverage(reportPath) {
+    const content = safeRead(reportPath);
+    let total = 0;
+    let covered = 0;
+    for (const line of content.split('\n')) {
+        if (!line || line.startsWith('mode:'))
+            continue;
+        const parts = line.trim().split(' ');
+        if (parts.length < 3)
+            continue;
+        const count = Number(parts[2]);
+        const range = parts[1];
+        const lineSpan = range.split(',').map((segment) => segment.split('.'));
+        const startLine = Number(lineSpan[0][0]);
+        const endLine = Number(lineSpan[1][0]);
+        const lines = Math.max(1, endLine - startLine + 1);
+        total += lines;
+        if (count > 0)
+            covered += lines;
+    }
+    return {
+        tool: 'go-cover',
+        lineCoverage: safePercent(covered, total),
+        branchCoverage: null,
+        methodCoverage: null,
+        classCoverage: null,
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
+function runMutationTesting(rootDir, languages, config) {
+    var _a, _b;
+    const selectedTool = resolveMutationTool((_b = (_a = config.mutationTesting) === null || _a === void 0 ? void 0 : _a.tool) !== null && _b !== void 0 ? _b : 'auto', languages, rootDir);
+    if (!selectedTool) {
+        return { summary: null, warning: 'Mutation testing is enabled but no supported mutation tool could be resolved for this project.' };
+    }
+    const command = mutationCommandFor(rootDir, selectedTool);
+    const result = (0, child_process_1.spawnSync)(command.command, command.args, {
+        cwd: rootDir,
+        encoding: 'utf-8',
+        shell: false,
+    });
+    const summary = parseMutationReport(rootDir, selectedTool, result.stdout, result.stderr);
+    if (!summary) {
+        const stderr = [result.stderr, result.stdout].filter(Boolean).join('\n').trim();
+        return {
+            summary: null,
+            warning: stderr || `Mutation testing tool ${selectedTool} did not produce a supported report.`,
+        };
+    }
+    return { summary };
+}
+function resolveMutationTool(tool, languages, rootDir) {
+    if (tool !== 'auto')
+        return tool;
+    const lowerLanguages = languages.map((language) => language.toLowerCase());
+    if (lowerLanguages.includes('java') || lowerLanguages.includes('kotlin'))
+        return 'pitest';
+    if (lowerLanguages.includes('typescript') || lowerLanguages.includes('javascript'))
+        return 'stryker';
+    if (lowerLanguages.includes('python'))
+        return 'mutmut';
+    if (lowerLanguages.includes('go'))
+        return 'go-mutesting';
+    if (lowerLanguages.includes('csharp') || lowerLanguages.includes('dotnet'))
+        return 'dotnet-stryker';
+    if (fs.existsSync(path.join(rootDir, 'package.json')))
+        return 'stryker';
+    if (fs.existsSync(path.join(rootDir, 'pom.xml')))
+        return 'pitest';
+    if (fs.existsSync(path.join(rootDir, 'build.gradle')) || fs.existsSync(path.join(rootDir, 'build.gradle.kts')))
+        return 'pitest';
+    if (fs.existsSync(path.join(rootDir, 'pyproject.toml')) || fs.existsSync(path.join(rootDir, 'setup.py')))
+        return 'mutmut';
+    if (fs.existsSync(path.join(rootDir, 'go.mod')))
+        return 'go-mutesting';
+    if (fast_glob_1.default.sync(['*.sln', '*.csproj'], { cwd: rootDir }).length > 0)
+        return 'dotnet-stryker';
+    return null;
+}
+function mutationCommandFor(rootDir, tool) {
+    switch (tool) {
+        case 'pitest':
+            return fs.existsSync(path.join(rootDir, 'gradlew'))
+                ? { command: path.join(rootDir, 'gradlew'), args: ['pitest'] }
+                : fs.existsSync(path.join(rootDir, 'build.gradle'))
+                    ? { command: 'gradle', args: ['pitest'] }
+                    : { command: 'mvn', args: ['pitest:mutationCoverage'] };
+        case 'stryker':
+            return { command: 'npx', args: ['stryker', 'run'] };
+        case 'mutmut':
+            return { command: 'mutmut', args: ['run'] };
+        case 'go-mutesting':
+            return { command: 'go-mutesting', args: ['./...'] };
+        case 'dotnet-stryker':
+            return { command: 'dotnet', args: ['stryker'] };
+        default:
+            return { command: 'true', args: [] };
+    }
+}
+function parseMutationReport(rootDir, tool, stdout, stderr) {
+    if (tool === 'pitest') {
+        for (const reportPath of fast_glob_1.default.sync([...PIT_REPORT_GLOBS], { cwd: rootDir, absolute: true })) {
+            return parsePitestXml(reportPath);
+        }
+    }
+    if (tool === 'stryker' || tool === 'dotnet-stryker') {
+        for (const reportPath of fast_glob_1.default.sync([...STRYKER_REPORT_GLOBS], { cwd: rootDir, absolute: true })) {
+            return parseStrykerReport(reportPath, tool === 'dotnet-stryker' ? 'dotnet stryker' : 'stryker');
+        }
+    }
+    if (tool === 'mutmut') {
+        const summary = parseMutmutOutput(stdout || stderr);
+        return summary ? { ...summary, tool: 'mutmut' } : null;
+    }
+    if (tool === 'go-mutesting') {
+        const summary = parseGoMutestingOutput(stdout || stderr);
+        return summary ? { ...summary, tool: 'go-mutesting' } : null;
+    }
+    return null;
+}
+function parsePitestXml(reportPath) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const xml = safeRead(reportPath);
+    const mutations = [...xml.matchAll(/<mutation\b([^>]*)>([\s\S]*?)<\/mutation>/g)];
+    const survivedByFile = new Map();
+    let total = 0;
+    let killed = 0;
+    let survived = 0;
+    for (const mutation of mutations) {
+        total += 1;
+        const attrs = mutation[1];
+        const body = mutation[2];
+        const statusMatch = /status="([^"]+)"/.exec(attrs);
+        const status = (_a = statusMatch === null || statusMatch === void 0 ? void 0 : statusMatch[1]) !== null && _a !== void 0 ? _a : 'UNKNOWN';
+        const file = (_b = extractXmlText(body, 'sourceFile')) !== null && _b !== void 0 ? _b : 'unknown';
+        const line = Number((_c = extractXmlText(body, 'lineNumber')) !== null && _c !== void 0 ? _c : '0');
+        const mutator = (_d = extractXmlText(body, 'mutator')) !== null && _d !== void 0 ? _d : 'mutation';
+        const description = (_e = extractXmlText(body, 'description')) !== null && _e !== void 0 ? _e : mutator;
+        const killingTest = extractXmlText(body, 'killingTest');
+        if (status === 'KILLED') {
+            killed += 1;
+        }
+        if (status === 'SURVIVED' || status === 'NO_COVERAGE' || status === 'TIMED_OUT') {
+            survived += 1;
+            const entries = (_f = survivedByFile.get(file)) !== null && _f !== void 0 ? _f : [];
+            entries.push({
+                line,
+                mutation: description,
+                testsThatShouldHaveCaught: killingTest ? [killingTest] : [],
+            });
+            survivedByFile.set(file, entries);
+        }
+    }
+    return {
+        tool: 'pitest',
+        mutationScore: (_g = safePercent(killed, total)) !== null && _g !== void 0 ? _g : 0,
+        totalMutants: total,
+        killedMutants: killed,
+        survivedMutants: survived,
+        survivedByFile: Array.from(survivedByFile.entries()).map(([file, items]) => ({ file, survived: items })),
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseStrykerReport(reportPath, toolName) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const json = JSON.parse(safeRead(reportPath));
+    const files = ((_a = json['files']) !== null && _a !== void 0 ? _a : {});
+    let total = 0;
+    let killed = 0;
+    let survived = 0;
+    const survivedByFile = [];
+    for (const [file, fileValue] of Object.entries(files)) {
+        const fileRecord = fileValue;
+        const mutants = ((_b = fileRecord['mutants']) !== null && _b !== void 0 ? _b : []);
+        const survivors = [];
+        for (const mutant of mutants) {
+            total += 1;
+            const status = String((_c = mutant['status']) !== null && _c !== void 0 ? _c : 'Unknown');
+            if (/Killed/i.test(status))
+                killed += 1;
+            if (/Survived|NoCoverage|Timeout/i.test(status)) {
+                survived += 1;
+                const location = ((_d = mutant['location']) !== null && _d !== void 0 ? _d : {});
+                const start = ((_e = location['start']) !== null && _e !== void 0 ? _e : {});
+                survivors.push({
+                    line: Number((_f = start['line']) !== null && _f !== void 0 ? _f : 0),
+                    mutation: String((_h = (_g = mutant['mutatorName']) !== null && _g !== void 0 ? _g : mutant['id']) !== null && _h !== void 0 ? _h : 'mutation'),
+                    originalCode: typeof mutant['replacement'] === 'string' ? String(mutant['replacement']) : undefined,
+                    mutatedCode: typeof mutant['description'] === 'string' ? String(mutant['description']) : undefined,
+                    testsThatShouldHaveCaught: [],
+                });
+            }
+        }
+        if (survivors.length > 0) {
+            survivedByFile.push({ file: normalizePath(file), survived: survivors });
+        }
+    }
+    return {
+        tool: toolName,
+        mutationScore: (_j = safePercent(killed, total)) !== null && _j !== void 0 ? _j : 0,
+        totalMutants: total,
+        killedMutants: killed,
+        survivedMutants: survived,
+        survivedByFile,
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseMutmutOutput(output) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const total = Number((_b = (_a = /survived\s*:\s*(\d+)/i.exec(output)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 0)
+        + Number((_d = (_c = /killed\s*:\s*(\d+)/i.exec(output)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : 0);
+    const killed = Number((_f = (_e = /killed\s*:\s*(\d+)/i.exec(output)) === null || _e === void 0 ? void 0 : _e[1]) !== null && _f !== void 0 ? _f : 0);
+    const survived = Number((_h = (_g = /survived\s*:\s*(\d+)/i.exec(output)) === null || _g === void 0 ? void 0 : _g[1]) !== null && _h !== void 0 ? _h : 0);
+    if (total === 0)
+        return null;
+    return {
+        mutationScore: (_j = safePercent(killed, total)) !== null && _j !== void 0 ? _j : 0,
+        totalMutants: total,
+        killedMutants: killed,
+        survivedMutants: survived,
+        survivedByFile: [],
+    };
+}
+function parseGoMutestingOutput(output) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const total = Number((_b = (_a = /total mutants:\s*(\d+)/i.exec(output)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 0);
+    const killed = Number((_d = (_c = /killed mutants:\s*(\d+)/i.exec(output)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : 0);
+    const survived = Number((_f = (_e = /survived mutants:\s*(\d+)/i.exec(output)) === null || _e === void 0 ? void 0 : _e[1]) !== null && _f !== void 0 ? _f : 0);
+    if (total === 0)
+        return null;
+    return {
+        mutationScore: (_g = safePercent(killed, total)) !== null && _g !== void 0 ? _g : 0,
+        totalMutants: total,
+        killedMutants: killed,
+        survivedMutants: survived,
+        survivedByFile: [],
+    };
+}
+function parseSlowTests(rootDir, config) {
+    var _a, _b;
+    const reportPaths = fast_glob_1.default.sync([...TEST_RESULT_GLOBS], { cwd: rootDir, absolute: true });
+    if (reportPaths.length === 0)
+        return null;
+    const durations = [];
+    for (const reportPath of reportPaths) {
+        if (reportPath.endsWith('.json')) {
+            durations.push(...parseJestJsonDurations(reportPath));
+        }
+        else {
+            durations.push(...parseJunitXmlDurations(reportPath));
+        }
+    }
+    if (durations.length === 0)
+        return null;
+    const unitThreshold = (_b = (_a = config.slowTestThreshold) === null || _a === void 0 ? void 0 : _a.unit) !== null && _b !== void 0 ? _b : 200;
+    const slowTests = durations
+        .filter((item) => item.durationMs > unitThreshold)
+        .map((item) => ({
+        ...item,
+        severity: item.durationMs > 1000 ? 'HIGH' : 'MEDIUM',
+        hint: buildSlowTestHint(item.durationMs),
+    }))
+        .sort((a, b) => b.durationMs - a.durationMs);
+    const totalDurationMs = durations.reduce((sum, item) => sum + item.durationMs, 0);
+    const fastCount = durations.filter((item) => item.durationMs < 50).length;
+    const slowCount = durations.filter((item) => item.durationMs >= unitThreshold).length;
+    return {
+        slowTests,
+        avgDurationMs: Math.round(totalDurationMs / durations.length),
+        totalDurationMs,
+        fastPercent: Math.round((fastCount / durations.length) * 100),
+        slowPercent: Math.round((slowCount / durations.length) * 100),
+        reportPaths: reportPaths.map((reportPath) => normalizePath(path.relative(rootDir, String(reportPath)))),
+    };
+}
+function parseJunitXmlDurations(reportPath) {
+    const xml = safeRead(reportPath);
+    const testcases = [...xml.matchAll(/<testcase\b([^>]*)\/?>(?:[\s\S]*?<\/testcase>)?/g)];
+    return testcases.map((match) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const attrs = match[1];
+        const name = (_b = (_a = /\bname="([^"]+)"/.exec(attrs)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 'unknown';
+        const className = (_d = (_c = /\bclassname="([^"]+)"/.exec(attrs)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : '';
+        const file = (_g = (_f = (_e = /\bfile="([^"]+)"/.exec(attrs)) === null || _e === void 0 ? void 0 : _e[1]) !== null && _f !== void 0 ? _f : className) !== null && _g !== void 0 ? _g : 'unknown';
+        const timeSeconds = Number((_j = (_h = /\btime="([^"]+)"/.exec(attrs)) === null || _h === void 0 ? void 0 : _h[1]) !== null && _j !== void 0 ? _j : 0);
+        return {
+            file: normalizePath(file),
+            method: name,
+            durationMs: Math.round(timeSeconds * 1000),
+        };
+    });
+}
+function parseJestJsonDurations(reportPath) {
+    var _a, _b, _c, _d, _e, _f;
+    const json = JSON.parse(safeRead(reportPath));
+    const suites = ((_a = json['testResults']) !== null && _a !== void 0 ? _a : []);
+    const durations = [];
+    for (const suite of suites) {
+        const file = normalizePath(String((_b = suite['name']) !== null && _b !== void 0 ? _b : 'unknown'));
+        const assertions = ((_c = suite['assertionResults']) !== null && _c !== void 0 ? _c : []);
+        for (const assertion of assertions) {
+            durations.push({
+                file,
+                method: String((_e = (_d = assertion['fullName']) !== null && _d !== void 0 ? _d : assertion['title']) !== null && _e !== void 0 ? _e : 'unknown'),
+                durationMs: Number((_f = assertion['duration']) !== null && _f !== void 0 ? _f : 0),
+            });
+        }
+    }
+    return durations;
+}
+function buildSlowTestHint(durationMs) {
+    if (durationMs > 5000) {
+        return `Test takes ${(durationMs / 1000).toFixed(1)}s — likely performing real IO or loading a full application context. Mock external calls or use a lighter fixture.`;
+    }
+    if (durationMs > 1000) {
+        return `Test takes ${(durationMs / 1000).toFixed(1)}s — likely loading Spring context or making real HTTP call. Use @MockBean instead.`;
+    }
+    return `Test takes ${durationMs}ms — likely doing avoidable IO. Prefer isolated unit doubles and in-memory fixtures.`;
+}
+function detectTestSmells(rootDir, tests) {
+    const smells = [];
+    for (const test of tests) {
+        smells.push(...detectCommentedOutTests(rootDir, test));
+        smells.push(...detectPerBlockSmells(rootDir, test));
+        smells.push(...detectSharedStateSmells(rootDir, test));
+        smells.push(...detectSleepAndFileSmells(rootDir, test));
+        smells.push(...detectDeadAssertions(rootDir, test));
+        smells.push(...detectProductionInstantiation(rootDir, test));
+    }
+    return smells.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.smellId.localeCompare(b.smellId));
+}
+function detectCommentedOutTests(rootDir, test) {
+    const smells = [];
+    const lines = test.content.split('\n');
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (/^\s*\/\/\s*@Test\b/.test(line) || /^\s*\/\/\s*(?:test|it)\s*\(/.test(line) || /^\s*#\s*def\s+test_/.test(line)) {
+            smells.push({
+                smellId: 'SMELL-02',
+                severity: 'HIGH',
+                file: test.relativePath,
+                line: index + 1,
+                description: 'Commented-out test code detected',
+                fix: 'Delete dead test code or restore it as an active test case',
+            });
+        }
+    }
+    return smells;
+}
+function detectPerBlockSmells(rootDir, test) {
+    const smells = [];
+    const blocks = extractTestBlocks(test.language, test.content);
+    for (const block of blocks) {
+        const body = block.body;
+        const assertionCount = countAssertions(test.language, body);
+        if (assertionCount === 0 && !hasVerificationCall(test.language, body)) {
+            smells.push({
+                smellId: 'SMELL-01',
+                severity: 'CRITICAL',
+                file: test.relativePath,
+                line: block.line,
+                testMethod: block.name,
+                description: 'Test has no assertions — proves nothing',
+                fix: 'Add assertion on the return value or verify mock interaction',
+            });
+        }
+        if (isDisabledWithoutReason(test.language, block, test.content)) {
+            smells.push({
+                smellId: 'SMELL-03',
+                severity: 'HIGH',
+                file: test.relativePath,
+                line: block.line,
+                testMethod: block.name,
+                description: 'Disabled test has no documented reason',
+                fix: 'Add a reason to the skip/disable annotation or re-enable the test',
+            });
+        }
+        if ((test.language === 'java' || test.language === 'kotlin' || test.language === 'javascript' || test.language === 'typescript') && assertionCount > 7 && !hasAssertionMessages(test.language, body)) {
+            smells.push({
+                smellId: 'SMELL-04',
+                severity: 'MEDIUM',
+                file: test.relativePath,
+                line: block.line,
+                testMethod: block.name,
+                description: 'Assertion roulette detected — many assertions with no diagnostic messages',
+                fix: 'Split the test or add assertion messages to clarify failures',
+            });
+        }
+        if (isEagerTest(body)) {
+            smells.push({
+                smellId: 'SMELL-05',
+                severity: 'MEDIUM',
+                file: test.relativePath,
+                line: block.line,
+                testMethod: block.name,
+                description: 'Test appears to exercise too many behaviours',
+                fix: 'Split the test into smaller behaviour-focused test cases',
+            });
+        }
+    }
+    return smells;
+}
+function detectSharedStateSmells(rootDir, test) {
+    var _a, _b, _c;
+    const smells = [];
+    if (test.language === 'java' || test.language === 'kotlin') {
+        const staticFields = [...test.content.matchAll(/(?:private|protected|public)?\s*static\s+(?!final)(?:[\w<>\[\]]+\s+)+([a-zA-Z_]\w*)\s*[;=]/g)];
+        const blocks = extractTestBlocks(test.language, test.content);
+        for (const field of staticFields) {
+            const fieldName = field[1];
+            const assignmentRegex = new RegExp(`\\b${fieldName}\\s*=`, 'm');
+            if (blocks.some((block) => assignmentRegex.test(block.body))) {
+                smells.push({
+                    smellId: 'SMELL-07',
+                    severity: 'HIGH',
+                    file: test.relativePath,
+                    line: lineNumberForIndex(test.content, (_a = field.index) !== null && _a !== void 0 ? _a : 0),
+                    description: `Shared mutable static state detected for ${fieldName}`,
+                    fix: 'Replace shared static mutable state with per-test setup data',
+                });
+            }
+        }
+    }
+    if (test.language === 'javascript' || test.language === 'typescript') {
+        const letMatches = [...test.content.matchAll(/\blet\s+([a-zA-Z_]\w*)\s*[=;]/g)];
+        const blocks = extractTestBlocks(test.language, test.content);
+        for (const match of letMatches) {
+            const variable = match[1];
+            const assignmentRegex = new RegExp(`\\b${variable}\\s*=`, 'm');
+            if (blocks.some((block) => assignmentRegex.test(block.body))) {
+                smells.push({
+                    smellId: 'SMELL-07',
+                    severity: 'HIGH',
+                    file: test.relativePath,
+                    line: lineNumberForIndex(test.content, (_b = match.index) !== null && _b !== void 0 ? _b : 0),
+                    description: `Shared mutable describe-scope variable detected: ${variable}`,
+                    fix: 'Use fresh state per test in beforeEach or local variables',
+                });
+            }
+        }
+    }
+    if (test.language === 'python') {
+        const classAttrs = [...test.content.matchAll(/^\s{4}([a-zA-Z_]\w*)\s*=.+$/gm)];
+        for (const attr of classAttrs) {
+            const attrName = attr[1];
+            const assignmentRegex = new RegExp(`self\\.${attrName}\\s*=`, 'm');
+            if (assignmentRegex.test(test.content)) {
+                smells.push({
+                    smellId: 'SMELL-07',
+                    severity: 'HIGH',
+                    file: test.relativePath,
+                    line: lineNumberForIndex(test.content, (_c = attr.index) !== null && _c !== void 0 ? _c : 0),
+                    description: `Shared mutable class-level attribute detected: ${attrName}`,
+                    fix: 'Move mutable state into per-test fixtures or local variables',
+                });
+            }
+        }
+    }
+    return smells;
+}
+function detectSleepAndFileSmells(rootDir, test) {
+    const smells = [];
+    const lines = test.content.split('\n');
+    const filePattern = /new\s+File\(|Files\.(?:read|write)|readFile\(|fs\.(?:readFile|writeFile)|open\(|Path\.|Paths\.|FileReader\(/;
+    const sleepPattern = /Thread\.sleep\(|time\.sleep\(|setTimeout\(|sleep\(/;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (filePattern.test(line) && !/fixture|fixtures|helper/i.test(line)) {
+            smells.push({
+                smellId: 'SMELL-06',
+                severity: 'MEDIUM',
+                file: test.relativePath,
+                line: index + 1,
+                description: 'Mystery guest detected — test reaches into external files directly',
+                fix: 'Use an explicit fixture helper or inline test data',
+            });
+        }
+        if (sleepPattern.test(line) && !/pollUntil/.test(line)) {
+            if (!/setTimeout\([^,]+,\s*0\s*\)/.test(line)) {
+                smells.push({
+                    smellId: 'SMELL-08',
+                    severity: 'HIGH',
+                    file: test.relativePath,
+                    line: index + 1,
+                    description: 'Sleeping test detected',
+                    fix: 'Use polling helpers or await explicit conditions instead of sleeping',
+                });
+            }
+        }
+    }
+    return smells;
+}
+function detectDeadAssertions(rootDir, test) {
+    const smells = [];
+    const lines = test.content.split('\n');
+    const patterns = [
+        /assertTrue\(\s*true\s*\)/,
+        /assertEquals\(\s*([a-zA-Z_][\w.]*)\s*,\s*\1\s*\)/,
+        /assertNotNull\(\s*new\s+[A-Z][\w<>]*\s*\(/,
+        /expect\(([^)]+)\)\.toBe\(\s*\1\s*\)/,
+        /expect\(\s*true\s*\)\.toBe\(\s*true\s*\)/,
+    ];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (patterns.some((pattern) => pattern.test(line))) {
+            smells.push({
+                smellId: 'SMELL-09',
+                severity: 'CRITICAL',
+                file: test.relativePath,
+                line: index + 1,
+                description: 'Dead assertion detected — assertion always passes',
+                fix: 'Assert on a real behavioural outcome instead of a tautology',
+            });
+        }
+    }
+    return smells;
+}
+function detectProductionInstantiation(rootDir, test) {
+    const smells = [];
+    const lines = test.content.split('\n');
+    if (test.mockLibrary)
+        return smells;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (/new\s+[A-Z]\w*(?:Service|Manager|Controller)\s*\(\s*new\s+[A-Z]\w+/.test(line)) {
+            smells.push({
+                smellId: 'SMELL-10',
+                severity: 'MEDIUM',
+                file: test.relativePath,
+                line: index + 1,
+                description: 'Production class is instantiated with real dependencies in a unit test',
+                fix: 'Inject mocks or fakes instead of concrete production collaborators',
+            });
+        }
+    }
+    return smells;
+}
+function computeIndependence(rootDir, tests) {
+    var _a;
+    const deductions = [];
+    for (const test of tests) {
+        const staticFields = [...test.content.matchAll(/(?:static\s+(?!final)|\blet\s+)([a-zA-Z_]\w*)/g)];
+        for (const field of staticFields) {
+            deductions.push({
+                reason: `Shared mutable state: ${field[1]}`,
+                points: 10,
+                file: test.relativePath,
+                line: lineNumberForIndex(test.content, (_a = field.index) !== null && _a !== void 0 ? _a : 0),
+            });
+        }
+        if (/@TestMethodOrder\(|@Order\(/.test(test.content)) {
+            deductions.push({
+                reason: 'Ordered test chain detected',
+                points: 20,
+                file: test.relativePath,
+            });
+        }
+        if (/(jdbc|EntityManager|Repository|save\(|insert into|select \*)/i.test(test.content) && !/@Transactional|@DirtiesContext/.test(test.content)) {
+            deductions.push({
+                reason: 'Database state dependency without isolation guard',
+                points: 10,
+                file: test.relativePath,
+            });
+        }
+        if (/(writeFile|Files\.write|open\([^)]*,\s*['"]w|FileWriter)/.test(test.content) && /(readFile|Files\.read|open\([^)]*,\s*['"]r|FileReader)/.test(test.content)) {
+            deductions.push({
+                reason: 'File system state shared across tests',
+                points: 10,
+                file: test.relativePath,
+            });
+        }
+        const portMatch = /\b(?:localhost:|server\.port\s*=\s*|bind\()\s*(8080|3000|5000|8000)\b/.exec(test.content);
+        if (portMatch) {
+            deductions.push({
+                reason: `Fixed port binding detected: ${portMatch[1]}`,
+                points: 30,
+                file: test.relativePath,
+            });
+        }
+    }
+    const score = Math.max(0, 100 - deductions.reduce((sum, deduction) => sum + deduction.points, 0));
+    return { score, deductions };
+}
+function computeAssertionDensity(tests) {
+    const files = tests.map((test) => {
+        const blocks = extractTestBlocks(test.language, test.content);
+        const totalLines = blocks.reduce((sum, block) => sum + block.body.split('\n').filter((line) => line.trim()).length, 0);
+        const density = totalLines > 0 ? Number((test.assertionCount / totalLines).toFixed(3)) : 0;
+        return {
+            file: test.relativePath,
+            density,
+            band: density > 0.3 ? 'GREEN' : density >= 0.1 ? 'YELLOW' : 'RED',
+            assertionCount: test.assertionCount,
+            totalLines,
+        };
+    });
+    const averageDensity = files.length > 0
+        ? Number((files.reduce((sum, file) => sum + file.density, 0) / files.length).toFixed(3))
+        : 0;
+    return { averageDensity, files };
+}
+function extractTestBlocks(language, content) {
+    if (language === 'javascript' || language === 'typescript') {
+        const regex = /(x?it|x?test|test\.skip|it\.skip)\s*\(\s*['"`]([^'"`]+)['"`][\s\S]{0,200}?=>\s*\{/g;
+        const blocks = [];
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const start = match.index + match[0].length - 1;
+            const end = findMatchingBrace(content, start);
+            blocks.push({
+                name: match[2],
+                body: content.slice(start + 1, end),
+                line: lineNumberForIndex(content, match.index),
+                decorators: [match[1]],
+            });
+            regex.lastIndex = end + 1;
+        }
+        return blocks;
+    }
+    if (language === 'java' || language === 'kotlin') {
+        const regex = /(?:public|protected|private|internal)?\s*(?:void|fun)\s+([a-zA-Z_]\w*)\s*\([^)]*\)\s*\{/g;
+        const blocks = [];
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const annotations = extractLeadingAnnotations(content, match.index);
+            if (!annotations.some((annotation) => /@(?:Test|ParameterizedTest|Disabled)/.test(annotation)))
+                continue;
+            const start = match.index + match[0].length - 1;
+            const end = findMatchingBrace(content, start);
+            blocks.push({
+                name: match[1],
+                body: content.slice(start + 1, end),
+                line: lineNumberForIndex(content, match.index),
+                decorators: annotations,
+            });
+            regex.lastIndex = end + 1;
+        }
+        return blocks;
+    }
+    if (language === 'python') {
+        const regex = /((?:@[^\n]+\n)*)def\s+(test_[a-zA-Z_]\w*)\s*\([^)]*\):\n([\s\S]*?)(?=\n\S|$)/g;
+        const blocks = [];
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            blocks.push({
+                name: match[2],
+                body: match[3],
+                line: lineNumberForIndex(content, match.index),
+                decorators: match[1].split('\n').map((line) => line.trim()).filter(Boolean),
+            });
+        }
+        return blocks;
+    }
+    return [];
+}
+function hasVerificationCall(language, body) {
+    if (language === 'java' || language === 'kotlin')
+        return /\b(?:verify|check|assert)\w*\s*\(/.test(body);
+    if (language === 'javascript' || language === 'typescript')
+        return /expect\s*\(|toHaveBeenCalled/.test(body);
+    if (language === 'python')
+        return /\bassert\b|assert_called/.test(body);
+    return false;
+}
+function isDisabledWithoutReason(language, block, content) {
+    if (language === 'java' || language === 'kotlin') {
+        return block.decorators.some((decorator) => decorator.startsWith('@Disabled') && !/@Disabled\([^)]*[^\s)]/.test(decorator));
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        const disabled = block.decorators.some((decorator) => /x?it|x?test|test\.skip|it\.skip/.test(decorator));
+        if (!disabled)
+            return false;
+        const lines = content.split('\n');
+        const previousLines = lines.slice(Math.max(0, block.line - 3), block.line - 1);
+        return !previousLines.some((line) => /^\s*\/\//.test(line) || /\/\*/.test(line));
+    }
+    if (language === 'python') {
+        return block.decorators.some((decorator) => /@pytest\.mark\.skip(?!\s*\(|.*reason\s*=)/.test(decorator));
+    }
+    return false;
+}
+function hasAssertionMessages(language, body) {
+    if (language === 'java' || language === 'kotlin')
+        return /assert\w+\(\s*['"][^'"]+['"]\s*,/.test(body);
+    if (language === 'javascript' || language === 'typescript')
+        return /expect\([^)]*['"][^'"]+['"][^)]*\)/.test(body);
+    return false;
+}
+function isEagerTest(body) {
+    var _a, _b;
+    const behaviourBlocks = ((_a = body.match(/\/\/\s*(?:given|when|then)/gi)) !== null && _a !== void 0 ? _a : []).length;
+    const actionCalls = ((_b = body.match(/\.[a-zA-Z_]\w*\s*\(/g)) !== null && _b !== void 0 ? _b : [])
+        .filter((call) => !/\.(?:then|catch|expect|assert|verify|toBe|toEqual)/.test(call))
+        .length;
+    return behaviourBlocks > 3 || actionCalls > 3;
+}
+function extractCoveredMethods(language, content) {
+    if (language === 'java' || language === 'kotlin') {
+        const targets = [];
+        const javaRegex = /@InjectMocks[\s\S]{0,500}?(?:private|protected|public|internal)?\s*(?:lateinit\s+)?(?:var\s+)?([A-Z]\w*)\s+([a-zA-Z_]\w*)\s*(?:=|;)/g;
+        let match;
+        while ((match = javaRegex.exec(content)) !== null) {
+            targets.push({ className: match[1], variableName: match[2] });
+        }
+        const kotlinRegex = /@InjectMocks[\s\S]{0,500}?(?:private|protected|public|internal)?\s*(?:lateinit\s+)?var\s+([a-zA-Z_]\w*)\s*:\s*([A-Z]\w*)/g;
+        while ((match = kotlinRegex.exec(content)) !== null) {
+            targets.push({ className: match[2], variableName: match[1] });
+        }
+        const methods = [];
+        for (const target of targets) {
+            const callRegex = new RegExp(`${target.variableName}\\.([a-zA-Z_]\\w*)\\s*\\(`, 'g');
+            while ((match = callRegex.exec(content)) !== null) {
+                methods.push(`${target.className}.${match[1]}`);
+            }
+        }
+        return dedupeStrings(methods);
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        const targets = [...content.matchAll(/(?:const|let|var)\s+([a-zA-Z_]\w*)\s*=\s*new\s+([A-Z]\w*)\s*\(/g)];
+        const methods = [];
+        for (const target of targets) {
+            const variableName = target[1];
+            const className = target[2];
+            const callRegex = new RegExp(`${variableName}\\.([a-zA-Z_]\\w*)\\s*\\(`, 'g');
+            let match;
+            while ((match = callRegex.exec(content)) !== null) {
+                methods.push(`${className}.${match[1]}`);
+            }
+        }
+        return dedupeStrings(methods);
+    }
+    if (language === 'python') {
+        const targets = [...content.matchAll(/([a-zA-Z_]\w*)\s*=\s*([A-Z]\w*)\s*\(/g)];
+        const methods = [];
+        for (const target of targets) {
+            const variableName = target[1];
+            const className = target[2];
+            const callRegex = new RegExp(`${variableName}\\.([a-zA-Z_]\\w*)\\s*\\(`, 'g');
+            let match;
+            while ((match = callRegex.exec(content)) !== null) {
+                methods.push(`${className}.${match[1]}`);
+            }
+        }
+        return dedupeStrings(methods);
+    }
+    return [];
+}
+function extractInstantiatedClasses(content) {
+    return dedupeStrings([
+        ...[...content.matchAll(/new\s+([A-Z]\w*)\s*\(/g)].map((match) => match[1]),
+        ...[...content.matchAll(/=\s*([A-Z]\w*)\s*\(/g)].map((match) => match[1]),
+    ]);
+}
+function scoreTestQuality(content) {
+    let score = 0;
+    if (/expect\(|assert\w*\(|\bassert\b/.test(content))
+        score += 25;
+    if (/verify\(|toHaveBeenCalled|assert_called/.test(content))
+        score += 20;
+    if (/invalid|error|exception|reject|fail/i.test(content))
+        score += 20;
+    if (!/toBeTruthy\(|toBeDefined\(/.test(content))
+        score += 20;
+    if (/test\(|it\(|@Test|def\s+test_/.test(content))
+        score += 15;
+    return score;
+}
+function countParameterizedExpansions(content) {
+    var _a, _b;
+    const matches = [
+        ...content.matchAll(/@CsvSource\(([^)]*)\)/g),
+        ...content.matchAll(/test\.each\(([^)]*)\)/g),
+        ...content.matchAll(/pytest\.mark\.parametrize\(([^)]*)\)/g),
+    ];
+    let total = 0;
+    for (const match of matches) {
+        const args = match[1];
+        total += Math.max(1, ((_a = args.match(/\[/g)) !== null && _a !== void 0 ? _a : []).length || ((_b = args.match(/,/g)) !== null && _b !== void 0 ? _b : []).length);
+    }
+    return total;
+}
+function detectMockLibrary(content) {
+    if (/Mockito|@Mock\b|mockito/i.test(content))
+        return 'mockito';
+    if (/jest\.mock|vi\.mock|sinon/i.test(content))
+        return 'jest';
+    if (/unittest\.mock|MagicMock|pytest-mock|mocker\./i.test(content))
+        return 'unittest.mock';
+    return undefined;
+}
+function classifyLayer(content, filePath) {
+    if (/supertest|axios|fetch\(|request\(|HttpClient/.test(content))
+        return 'integration';
+    if (/\.integration\.|IntegrationTest|E2E/.test(filePath))
+        return 'integration';
+    return 'unit';
+}
+function countAssertions(language, content) {
+    var _a, _b, _c;
+    if (language === 'java' || language === 'kotlin') {
+        return ((_a = content.match(/\bassert\w*\s*\(|\bverify\s*\(/g)) !== null && _a !== void 0 ? _a : []).length;
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        return ((_b = content.match(/expect\s*\(|assert\./g)) !== null && _b !== void 0 ? _b : []).length;
+    }
+    if (language === 'python') {
+        return ((_c = content.match(/\bassert\b|assert_called/g)) !== null && _c !== void 0 ? _c : []).length;
+    }
+    return 0;
+}
+function summarizeSmells(smells) {
+    return {
+        CRITICAL: smells.filter((smell) => smell.severity === 'CRITICAL').length,
+        HIGH: smells.filter((smell) => smell.severity === 'HIGH').length,
+        MEDIUM: smells.filter((smell) => smell.severity === 'MEDIUM').length,
+    };
+}
+function severityAtOrAbove(actual, threshold) {
+    if (threshold === 'none')
+        return false;
+    const order = {
+        CRITICAL: 3,
+        HIGH: 2,
+        MEDIUM: 1,
+    };
+    return order[actual] >= order[threshold];
+}
+function detectTestLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.java')
+        return 'java';
+    if (ext === '.kt' || ext === '.kts')
+        return 'kotlin';
+    if (ext === '.js' || ext === '.jsx')
+        return 'javascript';
+    if (ext === '.ts' || ext === '.tsx')
+        return 'typescript';
+    if (ext === '.py')
+        return 'python';
+    return 'other';
+}
+function findMatchingBrace(content, openBraceIndex) {
+    let depth = 0;
+    for (let index = openBraceIndex; index < content.length; index += 1) {
+        const char = content[index];
+        if (char === '{')
+            depth += 1;
+        if (char === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return content.length - 1;
+}
+function lineNumberForIndex(content, index) {
+    return content.slice(0, index).split('\n').length;
+}
+function extractLeadingAnnotations(content, index) {
+    const precedingLines = content
+        .slice(0, index)
+        .split('\n')
+        .slice(-6)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const annotations = [];
+    for (let lineIndex = precedingLines.length - 1; lineIndex >= 0; lineIndex -= 1) {
+        const line = precedingLines[lineIndex];
+        if (line.startsWith('@')) {
+            annotations.unshift(line);
+            continue;
+        }
+        if (annotations.length > 0)
+            break;
+    }
+    return annotations;
+}
+function extractCounters(xml) {
+    const counters = {};
+    for (const match of xml.matchAll(/<counter\b[^>]*type="([^"]+)"[^>]*missed="(\d+)"[^>]*covered="(\d+)"/g)) {
+        counters[match[1]] = {
+            missed: Number(match[2]),
+            covered: Number(match[3]),
+        };
+    }
+    return counters;
+}
+function coveragePercent(counter) {
+    if (!counter)
+        return null;
+    return safePercent(counter.covered, counter.covered + counter.missed);
+}
+function safePercent(covered, total) {
+    if (!Number.isFinite(total) || total <= 0)
+        return null;
+    return Number(((covered / total) * 100).toFixed(1));
+}
+function readPct(total, key) {
+    const entry = total[key];
+    if (!entry || typeof entry.pct !== 'number')
+        return null;
+    return Number(entry.pct.toFixed(1));
+}
+function readNumericAttribute(xml, name) {
+    var _a, _b;
+    return Number((_b = (_a = new RegExp(`${name}="([^\"]+)"`).exec(xml)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 0);
+}
+function extractXmlText(xml, tag) {
+    var _a, _b;
+    return (_b = (_a = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`).exec(xml)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.trim();
+}
+function dedupeBy(items, keyFn) {
+    const seen = new Set();
+    const deduped = [];
+    for (const item of items) {
+        const key = keyFn(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}
+function dedupeStrings(items) {
+    return Array.from(new Set(items));
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, '/');
+}
+function safeRead(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}