api-tests-coverage 1.0.24 → 1.0.26

package/dist/src/unitAnalysis.js

@@ -44,40 +44,76 @@ exports.parseCoverageXml = parseCoverageXml;
 exports.parseGoCoverage = parseGoCoverage;
 exports.parseStrykerReport = parseStrykerReport;
 exports.parseSlowTests = parseSlowTests;
+exports.calculateDynamicPassRate = calculateDynamicPassRate;
+exports.calculateUnitScore = calculateUnitScore;
 exports.detectTestSmells = detectTestSmells;
+exports.calculateWeightedCoveredItems = calculateWeightedCoveredItems;
 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',
+    'build/reports/jacoco/jacocoTestReport.xml',
+    'build/reports/jacoco/**/*.xml',
+    'target/site/jacoco/*.xml',
     'coverage/lcov.info',
+    'coverage/coverage-summary.json',
+    '.nyc_output/**/*.json',
     'coverage.xml',
     '.coverage',
+    'coverage/.resultset.json',
     'coverage.out',
+    'build/reports/kover/**/*.xml',
+    'build/reports/clover.xml',
 ];
 const TEST_RESULT_GLOBS = [
-    'target/surefire-reports/*.xml',
     'build/test-results/**/*.xml',
-    'reports/junit*.xml',
+    'target/surefire-reports/**/*.xml',
+    'build/reports/tests/**/*.xml',
+    'test-results/**/*.xml',
     'junit*.xml',
-    'results.xml',
-    'jest-results.json',
-    'reports/jest-results.json',
+    '.test-results/**/*.xml',
 ];
-const PIT_REPORT_GLOBS = [
-    'target/pit-reports/**/mutations.xml',
+const MUTATION_REPORT_GLOBS = [
     'build/reports/pitest/**/mutations.xml',
+    'target/pit-reports/**/mutations.xml',
+    'build/reports/pitest/**/*.xml',
+    'reports/mutation/**/*.json',
+    'reports/stryker/**/*.json',
+    'stryker-tmp/**/*.json',
+    '.mutmut-cache',
+    'reports/infection.json',
 ];
-const STRYKER_REPORT_GLOBS = [
-    'reports/mutation/mutation-report.json',
-    'reports/stryker/mutation-report.json',
-    'StrykerOutput/**/mutation-report.json',
+const CONTRACT_REPORT_GLOBS = [
+    'target/pacts/**/*.json',
+    'pacts/**/*.json',
+    'build/pacts/**/*.json',
+    '.pact/pacts/**/*.json',
 ];
+const AST_ASSERTION_FULL_SCORE = 20;
+const AST_ASSERTION_PARTIAL_SCORE = 10;
+const AST_ASSERTION_PARTIAL_THRESHOLD = 0.1;
+const AST_ISOLATION_FULL_SCORE = 20;
+const AST_ISOLATION_PARTIAL_SCORE = 10;
+const AST_ISOLATION_FULL_THRESHOLD = 80;
+const AST_ISOLATION_PARTIAL_THRESHOLD = 50;
+const AST_NAMING_FULL_SCORE = 20;
+const AST_NAMING_PARTIAL_SCORE = 10;
+const AST_NAMING_FULL_THRESHOLD = 80;
+const AST_NAMING_PARTIAL_THRESHOLD = 50;
+const AST_DISABLED_FULL_SCORE = 20;
+const AST_DISABLED_PARTIAL_SCORE = 10;
+const AST_DISABLED_PARTIAL_THRESHOLD = 2;
+const AST_CRITICAL_SMELL_BASE_SCORE = 20;
+const AST_CRITICAL_SMELL_DEDUCTION = 5;
+const SCORE_WEIGHTS = {
+    astOnly: { ast: 1 },
+    astMutation: { ast: 0.6, mutation: 0.4 },
+    astRuntime: { ast: 0.4, line: 0.4, branch: 0.2 },
+    astRuntimeMutation: { ast: 0.3, line: 0.3, branch: 0.2, mutation: 0.2 },
+};
 async function analyzeUnitTests(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
     const rootDir = path.resolve(options.rootDir);
     const unitConfig = options.config;
     const testAnalyses = options.testFiles.map((filePath) => analyzeTestFile(rootDir, filePath));
@@ -87,7 +123,8 @@ async function analyzeUnitTests(options) {
     const smells = ((_a = unitConfig.smellDetection) === null || _a === void 0 ? void 0 : _a.enabled) !== false
         ? detectTestSmells(rootDir, testAnalyses)
         : [];
-    const slowTests = parseSlowTests(rootDir, unitConfig);
+    const ast = buildAstSummary(testAnalyses, smells);
+    const dynamicDiscovery = discoverDynamicResults(rootDir, unitConfig);
     const independence = ((_b = unitConfig.independenceCheck) === null || _b === void 0 ? void 0 : _b.enabled) !== false
         ? computeIndependence(rootDir, testAnalyses)
         : null;
@@ -95,14 +132,23 @@ async function analyzeUnitTests(options) {
         ? 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;
+        ? discoverMutationTesting(rootDir)
+        : { summary: null };
+    const contractTesting = discoverContractTesting(rootDir);
     const failures = [];
     const warnings = [];
     const messages = [];
+    const consoleLines = buildUnitAnalysisConsoleLines({
+        ast,
+        dynamic: dynamicDiscovery.summary,
+        coverage: (_e = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _e !== void 0 ? _e : null,
+        mutation: mutationTesting.summary,
+        contract: contractTesting.summary,
+        languages: (_f = options.languages) !== null && _f !== void 0 ? _f : [],
+    });
     if (coverageDiscovery) {
         if (coverageDiscovery.summary) {
-            const coverageThresholds = (_f = unitConfig.codeCoverage) === null || _f === void 0 ? void 0 : _f.thresholds;
+            const coverageThresholds = (_g = unitConfig.codeCoverage) === null || _g === void 0 ? void 0 : _g.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}%`);
             }
@@ -118,51 +164,102 @@ async function analyzeUnitTests(options) {
             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) {
+        const threshold = (_j = (_h = unitConfig.mutationTesting) === null || _h === void 0 ? void 0 : _h.threshold) !== null && _j !== void 0 ? _j : 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) {
+    if (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';
+    const smellFailOn = (_l = (_k = unitConfig.smellDetection) === null || _k === void 0 ? void 0 : _k.failOn) !== null && _l !== void 0 ? _l : '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) {
+    if (independence && ((_m = unitConfig.independenceCheck) === null || _m === void 0 ? void 0 : _m.minScore) !== undefined && independence.score < unitConfig.independenceCheck.minScore) {
         failures.push(`Test independence score ${independence.score} is below minimum ${unitConfig.independenceCheck.minScore}`);
     }
+    const layersApplied = ['ast'];
+    if (dynamicDiscovery.summary)
+        layersApplied.push('dynamic');
+    if (coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary)
+        layersApplied.push('coverage');
+    if (mutationTesting.summary)
+        layersApplied.push('mutation');
+    if (contractTesting.summary)
+        layersApplied.push('contract');
+    const scoreInput = {
+        astQuality: ast.qualityScore,
+        dynamicPassRate: dynamicDiscovery.summary ? calculateDynamicPassRate(dynamicDiscovery.summary) : null,
+        lineCoverage: (_p = (_o = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _o === void 0 ? void 0 : _o.lineCoverage) !== null && _p !== void 0 ? _p : null,
+        branchCoverage: (_r = (_q = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _q === void 0 ? void 0 : _q.branchCoverage) !== null && _r !== void 0 ? _r : null,
+        mutationScore: (_t = (_s = mutationTesting.summary) === null || _s === void 0 ? void 0 : _s.mutationScore) !== null && _t !== void 0 ? _t : null,
+        layersApplied,
+    };
+    const weightedScore = calculateUnitScore(scoreInput);
+    const scoreWeighting = describeAppliedWeighting(scoreInput);
+    const appliedScoreWeights = getAppliedUnitScoreWeights(scoreInput);
+    consoleLines.push('');
+    consoleLines.push(`  Final score: ${weightedScore}% (${scoreWeighting})`);
+    appendDetectedSmells(consoleLines, ast);
+    appendLowCoverageFiles(consoleLines, (_u = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _u !== void 0 ? _u : null);
+    const totalItems = ast.testCount;
+    const qualityPassingTests = countPassingQualityTests(testAnalyses);
+    const coveredItems = calculateWeightedCoveredItems(totalItems, weightedScore);
     const details = {
         items: unitItems,
-        codeCoverage: (_m = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _m !== void 0 ? _m : null,
+        layersApplied,
+        ast,
+        dynamic: dynamicDiscovery.summary,
+        coverage: (_v = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _v !== void 0 ? _v : null,
+        mutation: mutationTesting.summary,
+        contract: contractTesting.summary,
+        codeCoverage: (_w = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) !== null && _w !== void 0 ? _w : 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,
+        mutationTesting: mutationTesting.summary,
+        filesScanned: ast.filesScanned,
+        smells,
+        enrichedByRuntime: Boolean(appliedScoreWeights.line || appliedScoreWeights.branch),
+        enrichedByMutation: Boolean(appliedScoreWeights.mutation),
+        lineCoverage: (_x = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _x === void 0 ? void 0 : _x.lineCoverage,
+        branchCoverage: (_y = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _y === void 0 ? void 0 : _y.branchCoverage,
+        classCoverage: (_z = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _z === void 0 ? void 0 : _z.classCoverage,
+        methodCoverage: (_0 = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _0 === void 0 ? void 0 : _0.methodCoverage,
+        uncoveredFiles: (_1 = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _1 === void 0 ? void 0 : _1.uncoveredFiles,
+        lowCoverageFiles: (_2 = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _2 === void 0 ? void 0 : _2.lowCoverageFiles,
+        runtimeReportPath: (_3 = coverageDiscovery === null || coverageDiscovery === void 0 ? void 0 : coverageDiscovery.summary) === null || _3 === void 0 ? void 0 : _3.reportPath,
+        mutationScore: (_4 = mutationTesting.summary) === null || _4 === void 0 ? void 0 : _4.mutationScore,
+        mutationSurvivedCount: (_5 = mutationTesting.summary) === null || _5 === void 0 ? void 0 : _5.survivedMutants,
+        mutationKilledCount: (_6 = mutationTesting.summary) === null || _6 === void 0 ? void 0 : _6.killedMutants,
+        worstMutationFiles: (_7 = mutationTesting.summary) === null || _7 === void 0 ? void 0 : _7.worstMutationFiles,
+        mutationReportPath: (_8 = mutationTesting.summary) === null || _8 === void 0 ? void 0 : _8.reportPath,
         testSmells: {
             bySeverity: summarizeSmells(smells),
             items: smells,
         },
-        slowTests,
+        slowTests: dynamicDiscovery.summary,
         independence,
         assertionDensity,
         messages,
+        weightedScore,
+        scoreWeighting,
+        qualityPassingTests,
     };
     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,
+            totalItems,
+            coveredItems,
+            coveragePercent: clampScore(weightedScore),
             details,
         },
         failures,
         warnings,
+        consoleLines,
     };
 }
 function analyzeTestFile(rootDir, filePath) {
@@ -170,14 +267,35 @@ function analyzeTestFile(rootDir, filePath) {
     const language = detectTestLanguage(filePath);
     const blocks = extractTestBlocks(language, content);
     const assertionCount = countAssertions(language, content);
+    const isolationUsage = blocks.filter((block) => testUsesIsolation(language, block.body)).length;
     return {
         filePath,
         relativePath: normalizePath(path.relative(rootDir, filePath)),
         language,
         content,
+        testBlocks: blocks,
+        testCount: blocks.length,
         qualityScore: scoreTestQuality(content),
         parameterizedExpansions: countParameterizedExpansions(content),
         assertionCount,
+        testClassCount: countTestClasses(language, content),
+        mockCount: countMockSignals(content),
+        stubCount: countStubSignals(content),
+        spyCount: countSpySignals(content),
+        testsUsingIsolation: isolationUsage,
+        descriptiveTestNameCount: blocks.filter((block) => isDescriptiveTestName(block.name)).length,
+        genericNameExamples: blocks
+            .map((block) => block.name)
+            .filter((name) => isGenericTestName(name))
+            .slice(0, 5),
+        emptyTestBodies: blocks
+            .filter((block) => isEmptyTestBody(block.body))
+            .map((block) => `${normalizePath(path.relative(rootDir, filePath))}#${block.name}`),
+        threadSleepUsage: collectLineMatches(rootDir, filePath, content, /Thread\.sleep\(|time\.sleep\(|setTimeout\(|\bSleep\(/),
+        systemOutUsage: collectLineMatches(rootDir, filePath, content, /System\.out\.println\(|console\.log\(|print\(/),
+        hardcodedCredentials: collectLineMatches(rootDir, filePath, content, /\b(?:password|secret|token|api[_-]?key)\b\s*[:=]\s*['"][^'"]+['"]/i),
+        staticMutableStateModified: hasStaticMutableStateMutation(language, content),
+        sharedMutableFields: collectSharedMutableFields(language, content),
         mockLibrary: detectMockLibrary(content),
         layer: classifyLayer(content, filePath),
         coveredMethods: extractCoveredMethods(language, content),
@@ -271,34 +389,155 @@ function buildUnitCoverageItems(sourceMethods, testAnalyses) {
     }
     return Array.from(byMethod.values()).sort((a, b) => a.id.localeCompare(b.id));
 }
+function buildAstSummary(testAnalyses, smells) {
+    const totalTests = testAnalyses.reduce((sum, test) => sum + test.testCount, 0);
+    const parameterizedTestCount = testAnalyses.reduce((sum, test) => sum + countParameterizedTests(test.language, test.content), 0);
+    const testClassCount = testAnalyses.reduce((sum, test) => sum + test.testClassCount, 0);
+    const mockCount = testAnalyses.reduce((sum, test) => sum + test.mockCount, 0);
+    const stubCount = testAnalyses.reduce((sum, test) => sum + test.stubCount, 0);
+    const spyCount = testAnalyses.reduce((sum, test) => sum + test.spyCount, 0);
+    const isolatedTests = testAnalyses.reduce((sum, test) => sum + test.testsUsingIsolation, 0);
+    const assertionCount = testAnalyses.reduce((sum, test) => sum + test.assertionCount, 0);
+    const testsWithZeroAssertions = testAnalyses.flatMap((test) => test.testBlocks
+        .filter((block) => countAssertions(test.language, block.body) === 0 && !hasVerificationCall(test.language, block.body))
+        .map((block) => `${test.relativePath}#${block.name}`));
+    const testsWithTooManyAssertions = testAnalyses.flatMap((test) => test.testBlocks
+        .filter((block) => countAssertions(test.language, block.body) > 10)
+        .map((block) => `${test.relativePath}#${block.name}`));
+    const descriptiveNameCount = testAnalyses.reduce((sum, test) => sum + test.descriptiveTestNameCount, 0);
+    const genericNameExamples = dedupeStrings(testAnalyses.flatMap((test) => test.genericNameExamples)).slice(0, 5);
+    const disabledTests = testAnalyses.flatMap((test) => test.testBlocks
+        .filter((block) => isDisabledBlock(test.language, block))
+        .map((block) => `${test.relativePath}#${block.name}`));
+    const emptyTestBodies = testAnalyses.flatMap((test) => test.emptyTestBodies);
+    const threadSleepUsage = testAnalyses.flatMap((test) => test.threadSleepUsage);
+    const systemOutUsage = testAnalyses.flatMap((test) => test.systemOutUsage);
+    const hardcodedCredentials = testAnalyses.flatMap((test) => test.hardcodedCredentials);
+    const sharedMutableFields = dedupeStrings(testAnalyses.flatMap((test) => test.sharedMutableFields));
+    const staticMutableStateModified = testAnalyses.some((test) => test.staticMutableStateModified);
+    // Scoring mirrors the cascaded unit-analysis specification:
+    // 20 points when every test asserts, 10 points when fewer than 10% miss assertions,
+    // otherwise 0 so AST-only mode still surfaces weak test suites clearly.
+    const assertionCompleteness = testsWithZeroAssertions.length === 0
+        ? AST_ASSERTION_FULL_SCORE
+        : totalTests > 0 && (testsWithZeroAssertions.length / totalTests) < AST_ASSERTION_PARTIAL_THRESHOLD
+            ? AST_ASSERTION_PARTIAL_SCORE
+            : 0;
+    const isolationPercent = totalTests > 0 ? Number(((isolatedTests / totalTests) * 100).toFixed(1)) : 0;
+    const testIsolation = isolationPercent >= AST_ISOLATION_FULL_THRESHOLD
+        ? AST_ISOLATION_FULL_SCORE
+        : isolationPercent >= AST_ISOLATION_PARTIAL_THRESHOLD
+            ? AST_ISOLATION_PARTIAL_SCORE
+            : 0;
+    const descriptiveNamePercent = totalTests > 0 ? Number(((descriptiveNameCount / totalTests) * 100).toFixed(1)) : 0;
+    const namingQuality = descriptiveNamePercent >= AST_NAMING_FULL_THRESHOLD
+        ? AST_NAMING_FULL_SCORE
+        : descriptiveNamePercent >= AST_NAMING_PARTIAL_THRESHOLD
+            ? AST_NAMING_PARTIAL_SCORE
+            : 0;
+    const disabledTestsScore = disabledTests.length === 0
+        ? AST_DISABLED_FULL_SCORE
+        : disabledTests.length <= AST_DISABLED_PARTIAL_THRESHOLD
+            ? AST_DISABLED_PARTIAL_SCORE
+            : 0;
+    // Critical smells share equal deductions because each one represents a strong signal
+    // that the test is timing-dependent, empty, or leaking credentials.
+    const criticalSmells = Math.max(0, AST_CRITICAL_SMELL_BASE_SCORE - ((threadSleepUsage.length + emptyTestBodies.length + hardcodedCredentials.length) * AST_CRITICAL_SMELL_DEDUCTION));
+    const qualityScore = clampScore(assertionCompleteness + testIsolation + namingQuality + disabledTestsScore + criticalSmells);
+    return {
+        filesScanned: testAnalyses.length,
+        testCount: totalTests,
+        parameterizedTestCount,
+        testClassCount,
+        mockCount,
+        stubCount,
+        spyCount,
+        isolationPercent,
+        assertionCount,
+        assertionsPerTest: totalTests > 0 ? Number((assertionCount / totalTests).toFixed(1)) : 0,
+        testsWithZeroAssertions,
+        testsWithTooManyAssertions,
+        descriptiveNamePercent,
+        genericNameExamples,
+        qualityScore,
+        dimensionScores: {
+            assertionCompleteness,
+            testIsolation,
+            namingQuality,
+            disabledTests: disabledTestsScore,
+            criticalSmells,
+        },
+        smells,
+        disabledTests,
+        emptyTestBodies,
+        threadSleepUsage,
+        systemOutUsage,
+        hardcodedCredentials,
+        staticMutableStateModified,
+        sharedMutableFields,
+    };
+}
+function discoverFirstMatchingPaths(rootDir, patterns) {
+    for (const pattern of patterns) {
+        const matchedPaths = fast_glob_1.default.sync(pattern, {
+            cwd: rootDir,
+            absolute: true,
+            onlyFiles: true,
+            unique: true,
+        }).sort((a, b) => a.length - b.length || a.localeCompare(b));
+        if (matchedPaths.length > 0) {
+            return {
+                summary: null,
+                matchedPaths,
+                checkedPaths: patterns.map((candidate) => normalizePath(candidate)),
+            };
+        }
+    }
+    return {
+        summary: null,
+        matchedPaths: [],
+        checkedPaths: patterns.map((candidate) => normalizePath(candidate)),
+    };
+}
 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) };
+    const discovery = discoverFirstMatchingPaths(rootDir, COVERAGE_REPORT_CANDIDATES);
+    const [reportPath] = discovery.matchedPaths;
+    if (reportPath) {
+        const relativePath = normalizePath(path.relative(rootDir, reportPath));
+        if (/jacoco|kover/i.test(relativePath)) {
+            return { summary: { ...parseJacocoXml(reportPath), reportPath: relativePath } };
+        }
+        if (relativePath.endsWith('coverage-summary.json')) {
+            return { summary: { ...parseIstanbulSummary(reportPath), reportPath: relativePath } };
+        }
+        if (relativePath.endsWith('lcov.info')) {
+            return { summary: { ...parseLcovInfo(reportPath), reportPath: relativePath } };
+        }
+        if (relativePath.includes('.nyc_output/') && relativePath.endsWith('.json')) {
+            return { summary: { ...parseNycCoverageJson(reportPath), reportPath: relativePath } };
         }
-        if (candidate.endsWith('coverage-summary.json')) {
-            return { summary: parseIstanbulSummary(fullPath) };
+        if (relativePath.endsWith('coverage.xml')) {
+            return { summary: { ...parseCoverageXml(reportPath), reportPath: relativePath } };
         }
-        if (candidate.endsWith('lcov.info')) {
-            return { summary: parseLcovInfo(fullPath) };
+        if (relativePath.endsWith('.coverage')) {
+            return { summary: { ...parseCoveragePyBinary(reportPath), reportPath: relativePath } };
         }
-        if (candidate === 'coverage.xml') {
-            return { summary: parseCoverageXml(fullPath) };
+        if (relativePath.endsWith('coverage/.resultset.json')) {
+            return { summary: { ...parseSimpleCovJson(reportPath), reportPath: relativePath } };
         }
-        if (candidate === 'coverage.out') {
-            return { summary: parseGoCoverage(fullPath) };
+        if (relativePath.endsWith('coverage.out')) {
+            return { summary: { ...parseGoCoverage(reportPath), reportPath: relativePath } };
+        }
+        if (relativePath.endsWith('clover.xml')) {
+            return { summary: { ...parseCloverXml(reportPath), reportPath: relativePath } };
         }
     }
     return {
         summary: null,
         missing: {
             message: 'Run tests with coverage enabled to see report',
-            hint: 'Add jacoco plugin to build.gradle',
-            checkedPaths,
+            hint: 'Write JaCoCo, Kover, LCOV, coverage.py, or Clover reports to one of the supported paths',
+            checkedPaths: discovery.checkedPaths,
         },
     };
 }
@@ -307,12 +546,25 @@ function parseJacocoXml(reportPath) {
     const xml = safeRead(reportPath);
     const counters = extractCounters(xml);
     const uncoveredMethods = [];
+    const uncoveredClasses = [];
+    const fileCoverage = [];
     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 classBodyWithoutMethods = classBody.replace(/<method\b[\s\S]*?<\/method>/g, '');
+        const classLineCounter = /<counter\b[^>]*type="LINE"[^>]*missed="(\d+)"[^>]*covered="(\d+)"/.exec(classBodyWithoutMethods);
+        const classLineCoverage = classLineCounter
+            ? safePercent(Number(classLineCounter[2]), Number(classLineCounter[1]) + Number(classLineCounter[2]))
+            : null;
+        if (classLineCoverage !== null) {
+            fileCoverage.push({ file: normalizePath(file), lineCoverage: classLineCoverage });
+        }
+        if (classLineCounter && Number(classLineCounter[2]) === 0 && Number(classLineCounter[1]) > 0) {
+            uncoveredClasses.push(className);
+        }
         const methodRegex = /<method\b[^>]*name="([^"]+)"[^>]*line="(\d+)"[^>]*>([\s\S]*?)<\/method>/g;
         let methodMatch;
         while ((methodMatch = methodRegex.exec(classBody)) !== null) {
@@ -331,6 +583,9 @@ function parseJacocoXml(reportPath) {
         branchCoverage: coveragePercent(counters.BRANCH),
         methodCoverage: coveragePercent(counters.METHOD),
         classCoverage: coveragePercent(counters.CLASS),
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: dedupeStrings(uncoveredClasses),
         uncoveredMethods,
         reportPath: normalizePath(reportPath),
     };
@@ -339,18 +594,34 @@ function parseIstanbulSummary(reportPath) {
     var _a;
     const json = JSON.parse(safeRead(reportPath));
     const total = ((_a = json['total']) !== null && _a !== void 0 ? _a : {});
+    const fileCoverage = Object.entries(json)
+        .filter(([key, value]) => key !== 'total' && typeof value === 'object' && value !== null)
+        .map(([key, value]) => {
+        var _a;
+        return ({
+            file: normalizePath(key),
+            lineCoverage: (_a = readPct(value, 'lines')) !== null && _a !== void 0 ? _a : 0,
+        });
+    });
+    const uncoveredClasses = Object.entries(json)
+        .filter(([key, value]) => key !== 'total' && typeof value === 'object' && value !== null)
+        .filter(([, value]) => readPct(value, 'lines') === 0)
+        .map(([key]) => path.basename(key, path.extname(key)));
     return {
         tool: 'istanbul',
         lineCoverage: readPct(total, 'lines'),
         branchCoverage: readPct(total, 'branches'),
         methodCoverage: readPct(total, 'functions'),
         classCoverage: readPct(total, 'statements'),
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: dedupeStrings(uncoveredClasses),
         uncoveredMethods: [],
         reportPath: normalizePath(reportPath),
     };
 }
 function parseLcovInfo(reportPath) {
-    var _a, _b;
+    var _a, _b, _c;
     const content = safeRead(reportPath);
     const files = content.split('end_of_record').map((chunk) => chunk.trim()).filter(Boolean);
     let totalLines = 0;
@@ -360,20 +631,25 @@ function parseLcovInfo(reportPath) {
     let totalFunctions = 0;
     let hitFunctions = 0;
     let coveredFiles = 0;
+    const uncoveredClasses = [];
     const uncoveredMethods = [];
+    const fileCoverage = [];
     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;
+        let fileTotalLines = 0;
+        let fileHitLines = 0;
         for (const line of lines) {
-            if (line.startsWith('LF:'))
-                totalLines += Number(line.slice(3));
+            if (line.startsWith('LF:')) {
+                const count = Number(line.slice(3));
+                totalLines += count;
+                fileTotalLines += count;
+            }
             if (line.startsWith('LH:')) {
                 const hits = Number(line.slice(3));
                 hitLines += hits;
-                if (hits > 0)
-                    fileCovered = true;
+                fileHitLines += hits;
             }
             if (line.startsWith('BRF:'))
                 totalBranches += Number(line.slice(4));
@@ -394,8 +670,13 @@ function parseLcovInfo(reportPath) {
                     entry.hits = Number(hits);
             }
         }
-        if (fileCovered)
+        const fileLineCoverage = (_c = safePercent(fileHitLines, fileTotalLines)) !== null && _c !== void 0 ? _c : 0;
+        fileCoverage.push({ file: normalizePath(file), lineCoverage: fileLineCoverage });
+        if (fileLineCoverage > 0)
             coveredFiles += 1;
+        if (fileLineCoverage === 0) {
+            uncoveredClasses.push(path.basename(file, path.extname(file)));
+        }
         for (const [name, data] of fnMap.entries()) {
             if (data.hits === 0) {
                 uncoveredMethods.push({
@@ -413,10 +694,71 @@ function parseLcovInfo(reportPath) {
         branchCoverage: safePercent(hitBranches, totalBranches),
         methodCoverage: safePercent(hitFunctions, totalFunctions),
         classCoverage: files.length > 0 ? Number(((coveredFiles / files.length) * 100).toFixed(1)) : null,
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: dedupeStrings(uncoveredClasses),
         uncoveredMethods,
         reportPath: normalizePath(reportPath),
     };
 }
+function parseNycCoverageJson(reportPath) {
+    const json = JSON.parse(safeRead(reportPath));
+    const fileCoverage = Object.entries(json).map(([file, value]) => {
+        var _a, _b;
+        const statements = Object.values((_a = value.s) !== null && _a !== void 0 ? _a : {});
+        const coveredStatements = statements.filter((count) => count > 0).length;
+        return {
+            file: normalizePath(file),
+            lineCoverage: (_b = safePercent(coveredStatements, statements.length)) !== null && _b !== void 0 ? _b : 0,
+        };
+    });
+    const statementCounts = Object.values(json).flatMap((value) => { var _a; return Object.values((_a = value.s) !== null && _a !== void 0 ? _a : {}); });
+    const branchCounts = Object.values(json).flatMap((value) => { var _a; return Object.values((_a = value.b) !== null && _a !== void 0 ? _a : {}).flat(); });
+    const functionCounts = Object.values(json).flatMap((value) => { var _a; return Object.values((_a = value.f) !== null && _a !== void 0 ? _a : {}); });
+    return {
+        tool: 'nyc',
+        lineCoverage: safePercent(statementCounts.filter((count) => count > 0).length, statementCounts.length),
+        branchCoverage: safePercent(branchCounts.filter((count) => count > 0).length, branchCounts.length),
+        methodCoverage: safePercent(functionCounts.filter((count) => count > 0).length, functionCounts.length),
+        classCoverage: null,
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: [],
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseSimpleCovJson(reportPath) {
+    var _a, _b;
+    const json = JSON.parse(safeRead(reportPath));
+    const fileCoverage = [];
+    let totalExecutable = 0;
+    let totalCovered = 0;
+    for (const run of Object.values(json)) {
+        for (const [file, hits] of Object.entries((_a = run.coverage) !== null && _a !== void 0 ? _a : {})) {
+            const executable = hits.filter((hit) => hit !== null).length;
+            const covered = hits.filter((hit) => typeof hit === 'number' && hit > 0).length;
+            totalExecutable += executable;
+            totalCovered += covered;
+            fileCoverage.push({
+                file: normalizePath(file),
+                lineCoverage: (_b = safePercent(covered, executable)) !== null && _b !== void 0 ? _b : 0,
+            });
+        }
+    }
+    return {
+        tool: 'simplecov',
+        lineCoverage: safePercent(totalCovered, totalExecutable),
+        branchCoverage: null,
+        methodCoverage: null,
+        classCoverage: null,
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: [],
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
 function parseCoverageXml(reportPath) {
     var _a;
     const xml = safeRead(reportPath);
@@ -426,6 +768,16 @@ function parseCoverageXml(reportPath) {
     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 uncoveredClasses = classes
+        .filter((match) => /line-rate="0(?:\.0+)?"/.test(match[0]))
+        .map((match) => { var _a; return (_a = String(match[1]).split('.').pop()) !== null && _a !== void 0 ? _a : String(match[1]); });
+    const fileCoverage = classes.map((match) => {
+        var _a, _b;
+        return ({
+            file: normalizePath(String(match[2])),
+            lineCoverage: Number((Number((_b = (_a = /line-rate="([^"]+)"/.exec(match[0])) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 0) * 100).toFixed(1)),
+        });
+    });
     const uncoveredMethods = [];
     const methodRegex = /<method\b[^>]*name="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*>([\s\S]*?)<\/method>/g;
     let methodMatch;
@@ -448,14 +800,19 @@ function parseCoverageXml(reportPath) {
         branchCoverage: safePercent(branchesCovered, branchesValid),
         methodCoverage: safePercent(coveredMethods, totalMethods),
         classCoverage: classes.length > 0 ? Number(((coveredClasses / classes.length) * 100).toFixed(1)) : null,
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: dedupeStrings(uncoveredClasses),
         uncoveredMethods,
         reportPath: normalizePath(reportPath),
     };
 }
 function parseGoCoverage(reportPath) {
+    var _a;
     const content = safeRead(reportPath);
     let total = 0;
     let covered = 0;
+    const fileStats = new Map();
     for (const line of content.split('\n')) {
         if (!line || line.startsWith('mode:'))
             continue;
@@ -463,121 +820,102 @@ function parseGoCoverage(reportPath) {
         if (parts.length < 3)
             continue;
         const count = Number(parts[2]);
-        const range = parts[1];
+        const file = normalizePath(parts[0].split(':')[0]);
+        const range = parts[0].includes(':') ? parts[0].slice(parts[0].indexOf(':') + 1) : 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)
+        const stat = (_a = fileStats.get(file)) !== null && _a !== void 0 ? _a : { total: 0, covered: 0 };
+        stat.total += lines;
+        if (count > 0) {
             covered += lines;
+            stat.covered += lines;
+        }
+        fileStats.set(file, stat);
     }
+    const fileCoverage = Array.from(fileStats.entries()).map(([file, stat]) => {
+        var _a;
+        return ({
+            file,
+            lineCoverage: (_a = safePercent(stat.covered, stat.total)) !== null && _a !== void 0 ? _a : 0,
+        });
+    });
     return {
         tool: 'go-cover',
         lineCoverage: safePercent(covered, total),
         branchCoverage: null,
         methodCoverage: null,
         classCoverage: null,
+        ...buildCoverageFileFields(fileCoverage),
+        fileCoverage: sortCoverageFiles(fileCoverage),
+        uncoveredClasses: [],
         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();
+function parseCoveragePyBinary(reportPath) {
+    return {
+        tool: 'coverage.py',
+        lineCoverage: null,
+        branchCoverage: null,
+        methodCoverage: null,
+        classCoverage: null,
+        uncoveredFiles: [],
+        lowCoverageFiles: [],
+        fileCoverage: [],
+        uncoveredClasses: [],
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
+function parseCloverXml(reportPath) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const xml = safeRead(reportPath);
+    const lineRate = safePercent(Number((_b = (_a = /coveredstatements="(\d+)"/.exec(xml)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 0), Number((_d = (_c = /statements="(\d+)"/.exec(xml)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : 0));
+    const branchRate = safePercent(Number((_f = (_e = /coveredconditionals="(\d+)"/.exec(xml)) === null || _e === void 0 ? void 0 : _e[1]) !== null && _f !== void 0 ? _f : 0), Number((_h = (_g = /conditionals="(\d+)"/.exec(xml)) === null || _g === void 0 ? void 0 : _g[1]) !== null && _h !== void 0 ? _h : 0));
+    const methodRate = safePercent(Number((_k = (_j = /coveredmethods="(\d+)"/.exec(xml)) === null || _j === void 0 ? void 0 : _j[1]) !== null && _k !== void 0 ? _k : 0), Number((_m = (_l = /methods="(\d+)"/.exec(xml)) === null || _l === void 0 ? void 0 : _l[1]) !== null && _m !== void 0 ? _m : 0));
+    return {
+        tool: 'clover',
+        lineCoverage: lineRate,
+        branchCoverage: branchRate,
+        methodCoverage: methodRate,
+        classCoverage: null,
+        uncoveredFiles: [],
+        lowCoverageFiles: [],
+        fileCoverage: [],
+        uncoveredClasses: [],
+        uncoveredMethods: [],
+        reportPath: normalizePath(reportPath),
+    };
+}
+function discoverMutationTesting(rootDir) {
+    const discovery = discoverFirstMatchingPaths(rootDir, MUTATION_REPORT_GLOBS);
+    const [reportPath] = discovery.matchedPaths;
+    if (!reportPath) {
+        return { summary: null };
+    }
+    try {
+        const relativePath = normalizePath(path.relative(rootDir, reportPath));
+        if (reportPath.endsWith('.xml')) {
+            return { summary: { ...parsePitestXml(reportPath), reportPath: relativePath } };
+        }
+        return { summary: { ...parseStrykerReport(reportPath, /stryker/i.test(reportPath) ? 'stryker' : 'mutation'), reportPath: relativePath } };
+    }
+    catch (error) {
         return {
             summary: null,
-            warning: stderr || `Mutation testing tool ${selectedTool} did not produce a supported report.`,
+            warning: `Mutation report ${normalizePath(path.relative(rootDir, reportPath))} could not be parsed: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    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;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const xml = safeRead(reportPath);
     const mutations = [...xml.matchAll(/<mutation\b([^>]*)>([\s\S]*?)<\/mutation>/g)];
     const survivedByFile = new Map();
+    const fileStats = new Map();
     let total = 0;
     let killed = 0;
     let survived = 0;
@@ -588,16 +926,20 @@ function parsePitestXml(reportPath) {
         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 stats = (_c = fileStats.get(file)) !== null && _c !== void 0 ? _c : { total: 0, killed: 0 };
+        stats.total += 1;
+        fileStats.set(file, stats);
+        const line = Number((_d = extractXmlText(body, 'lineNumber')) !== null && _d !== void 0 ? _d : '0');
+        const mutator = (_e = extractXmlText(body, 'mutator')) !== null && _e !== void 0 ? _e : 'mutation';
+        const description = (_f = extractXmlText(body, 'description')) !== null && _f !== void 0 ? _f : mutator;
         const killingTest = extractXmlText(body, 'killingTest');
         if (status === 'KILLED') {
             killed += 1;
+            stats.killed += 1;
         }
         if (status === 'SURVIVED' || status === 'NO_COVERAGE' || status === 'TIMED_OUT') {
             survived += 1;
-            const entries = (_f = survivedByFile.get(file)) !== null && _f !== void 0 ? _f : [];
+            const entries = (_g = survivedByFile.get(file)) !== null && _g !== void 0 ? _g : [];
             entries.push({
                 line,
                 mutation: description,
@@ -608,38 +950,45 @@ function parsePitestXml(reportPath) {
     }
     return {
         tool: 'pitest',
-        mutationScore: (_g = safePercent(killed, total)) !== null && _g !== void 0 ? _g : 0,
+        mutationScore: (_h = safePercent(killed, total)) !== null && _h !== void 0 ? _h : 0,
         totalMutants: total,
         killedMutants: killed,
         survivedMutants: survived,
+        worstMutationFiles: rankWorstMutationFiles(fileStats),
+        weakestFiles: rankWeakestMutationFiles(fileStats),
         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;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     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 fileStats = new Map();
     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 = [];
+        const stats = (_c = fileStats.get(file)) !== null && _c !== void 0 ? _c : { total: 0, killed: 0 };
         for (const mutant of mutants) {
             total += 1;
-            const status = String((_c = mutant['status']) !== null && _c !== void 0 ? _c : 'Unknown');
-            if (/Killed/i.test(status))
+            stats.total += 1;
+            const status = String((_d = mutant['status']) !== null && _d !== void 0 ? _d : 'Unknown');
+            if (/Killed/i.test(status)) {
                 killed += 1;
+                stats.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 : {});
+                const location = ((_e = mutant['location']) !== null && _e !== void 0 ? _e : {});
+                const start = ((_f = location['start']) !== null && _f !== void 0 ? _f : {});
                 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'),
+                    line: Number((_g = start['line']) !== null && _g !== void 0 ? _g : 0),
+                    mutation: String((_j = (_h = mutant['mutatorName']) !== null && _h !== void 0 ? _h : mutant['id']) !== null && _j !== void 0 ? _j : 'mutation'),
                     originalCode: typeof mutant['replacement'] === 'string' ? String(mutant['replacement']) : undefined,
                     mutatedCode: typeof mutant['description'] === 'string' ? String(mutant['description']) : undefined,
                     testsThatShouldHaveCaught: [],
@@ -649,13 +998,16 @@ function parseStrykerReport(reportPath, toolName) {
         if (survivors.length > 0) {
             survivedByFile.push({ file: normalizePath(file), survived: survivors });
         }
+        fileStats.set(file, stats);
     }
     return {
         tool: toolName,
-        mutationScore: (_j = safePercent(killed, total)) !== null && _j !== void 0 ? _j : 0,
+        mutationScore: (_k = safePercent(killed, total)) !== null && _k !== void 0 ? _k : 0,
         totalMutants: total,
         killedMutants: killed,
         survivedMutants: survived,
+        worstMutationFiles: rankWorstMutationFiles(fileStats),
+        weakestFiles: rankWeakestMutationFiles(fileStats),
         survivedByFile,
         reportPath: normalizePath(reportPath),
     };
@@ -673,6 +1025,8 @@ function parseMutmutOutput(output) {
         totalMutants: total,
         killedMutants: killed,
         survivedMutants: survived,
+        worstMutationFiles: [],
+        weakestFiles: [],
         survivedByFile: [],
     };
 }
@@ -688,25 +1042,78 @@ function parseGoMutestingOutput(output) {
         totalMutants: total,
         killedMutants: killed,
         survivedMutants: survived,
+        worstMutationFiles: [],
+        weakestFiles: [],
         survivedByFile: [],
     };
 }
+function discoverDynamicResults(rootDir, config) {
+    var _a;
+    const discovery = discoverFirstMatchingPaths(rootDir, TEST_RESULT_GLOBS);
+    if (discovery.matchedPaths.length === 0) {
+        return discovery;
+    }
+    const junitReportPaths = discovery.matchedPaths.filter((reportPath) => isLikelyJunitXml(reportPath));
+    if (junitReportPaths.length === 0) {
+        return {
+            matchedPaths: [],
+            checkedPaths: discovery.checkedPaths,
+            summary: null,
+        };
+    }
+    const tests = junitReportPaths.flatMap((reportPath) => parseJunitXmlResults(reportPath));
+    const durations = tests.map((test) => ({
+        file: test.file,
+        method: test.method,
+        durationMs: test.durationMs,
+    }));
+    const slowSummary = buildSlowTestSummary(durations, junitReportPaths.map((reportPath) => normalizePath(path.relative(rootDir, reportPath))), config);
+    const failures = tests
+        .filter((test) => test.status === 'failed' && test.failureMessage)
+        .map((test) => {
+        var _a;
+        return ({
+            file: test.file,
+            method: test.method,
+            message: (_a = test.failureMessage) !== null && _a !== void 0 ? _a : 'Test failed',
+            stackTrace: test.stackTrace,
+        });
+    });
+    const byTest = new Map();
+    for (const test of tests) {
+        const key = `${test.file}#${test.method}`;
+        const statuses = (_a = byTest.get(key)) !== null && _a !== void 0 ? _a : new Set();
+        statuses.add(test.status);
+        byTest.set(key, statuses);
+    }
+    return {
+        matchedPaths: junitReportPaths,
+        checkedPaths: discovery.checkedPaths,
+        summary: {
+            passed: tests.filter((test) => test.status === 'passed').length,
+            failed: tests.filter((test) => test.status === 'failed').length,
+            skipped: tests.filter((test) => test.status === 'skipped').length,
+            flakyTests: Array.from(byTest.entries())
+                .filter(([, statuses]) => statuses.has('passed') && statuses.has('failed'))
+                .map(([key]) => key),
+            failures,
+            ...slowSummary,
+        },
+    };
+}
+function isLikelyJunitXml(reportPath) {
+    if (path.extname(reportPath).toLowerCase() !== '.xml') {
+        return false;
+    }
+    const xml = safeReadHead(reportPath);
+    return /<testsuites?\b|<testcase\b/.test(xml);
+}
 function parseSlowTests(rootDir, config) {
+    const discovery = discoverDynamicResults(rootDir, config);
+    return discovery.summary;
+}
+function buildSlowTestSummary(durations, reportPaths, 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)
@@ -716,32 +1123,43 @@ function parseSlowTests(rootDir, config) {
         hint: buildSlowTestHint(item.durationMs),
     }))
         .sort((a, b) => b.durationMs - a.durationMs);
-    const totalDurationMs = durations.reduce((sum, item) => sum + item.durationMs, 0);
+    const totalDurationMs = durations.length > 0
+        ? durations.reduce((sum, item) => sum + item.durationMs, 0)
+        : 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),
+        avgDurationMs: durations.length > 0 ? Math.round(totalDurationMs / durations.length) : 0,
         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)))),
+        fastPercent: durations.length > 0 ? Math.round((fastCount / durations.length) * 100) : 0,
+        slowPercent: durations.length > 0 ? Math.round((slowCount / durations.length) * 100) : 0,
+        reportPaths,
     };
 }
-function parseJunitXmlDurations(reportPath) {
+function parseJunitXmlResults(reportPath) {
     const xml = safeRead(reportPath);
-    const testcases = [...xml.matchAll(/<testcase\b([^>]*)\/?>(?:[\s\S]*?<\/testcase>)?/g)];
+    const testcases = [...xml.matchAll(/<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g)];
     return testcases.map((match) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         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);
+        const body = (_a = match[2]) !== null && _a !== void 0 ? _a : '';
+        const name = (_c = (_b = /\bname="([^"]+)"/.exec(attrs)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : 'unknown';
+        const className = ((_d = /\bclassname="([^"]+)"/.exec(attrs)) === null || _d === void 0 ? void 0 : _d[1]) || 'unknown';
+        const file = ((_e = /\bfile="([^"]+)"/.exec(attrs)) === null || _e === void 0 ? void 0 : _e[1]) || className;
+        const timeSeconds = Number((_g = (_f = /\btime="([^"]+)"/.exec(attrs)) === null || _f === void 0 ? void 0 : _f[1]) !== null && _g !== void 0 ? _g : 0);
+        const failureMatch = /<(failure|error)\b([^>]*)>([\s\S]*?)<\/\1>/.exec(body);
+        const skippedMatch = /<skipped\b/.exec(body);
+        const failureAttrs = (_h = failureMatch === null || failureMatch === void 0 ? void 0 : failureMatch[2]) !== null && _h !== void 0 ? _h : '';
+        const failureBody = sanitizeXmlText((_j = failureMatch === null || failureMatch === void 0 ? void 0 : failureMatch[3]) !== null && _j !== void 0 ? _j : '');
+        const failureMessage = (_l = (_k = /\bmessage="([^"]+)"/.exec(failureAttrs)) === null || _k === void 0 ? void 0 : _k[1]) !== null && _l !== void 0 ? _l : failureBody.split('\n').map((line) => line.trim()).find(Boolean);
         return {
             file: normalizePath(file),
             method: name,
+            status: failureMatch ? 'failed' : skippedMatch ? 'skipped' : 'passed',
             durationMs: Math.round(timeSeconds * 1000),
+            failureMessage,
+            stackTrace: failureBody || undefined,
         };
     });
 }
@@ -763,6 +1181,40 @@ function parseJestJsonDurations(reportPath) {
     }
     return durations;
 }
+function discoverContractTesting(rootDir) {
+    const discovery = discoverFirstMatchingPaths(rootDir, CONTRACT_REPORT_GLOBS);
+    if (discovery.matchedPaths.length === 0) {
+        return discovery;
+    }
+    const failedVerifications = [];
+    let verifiedContracts = 0;
+    for (const contractPath of discovery.matchedPaths) {
+        try {
+            const json = JSON.parse(safeRead(contractPath));
+            const contractName = formatContractName(json, contractPath);
+            const verification = extractContractVerificationStatus(json);
+            if (verification === true) {
+                verifiedContracts += 1;
+            }
+            if (verification === false) {
+                failedVerifications.push(`${contractName}: ${extractContractFailureReason(json)}`);
+            }
+        }
+        catch {
+            failedVerifications.push(`${normalizePath(path.relative(rootDir, contractPath))}: invalid JSON`);
+        }
+    }
+    return {
+        matchedPaths: discovery.matchedPaths,
+        checkedPaths: discovery.checkedPaths,
+        summary: {
+            totalContracts: discovery.matchedPaths.length,
+            verifiedContracts,
+            failedVerifications,
+            contractPaths: discovery.matchedPaths.map((contractPath) => normalizePath(path.relative(rootDir, contractPath))),
+        },
+    };
+}
 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.`;
@@ -772,6 +1224,143 @@ function buildSlowTestHint(durationMs) {
     }
     return `Test takes ${durationMs}ms — likely doing avoidable IO. Prefer isolated unit doubles and in-memory fixtures.`;
 }
+function calculateDynamicPassRate(summary) {
+    const total = summary.passed + summary.failed + summary.skipped;
+    if (total === 0)
+        return 0;
+    return Number(((summary.passed / total) * 100).toFixed(1));
+}
+function calculateUnitScore(input) {
+    var _a, _b, _c, _d, _e, _f;
+    const weights = getAppliedUnitScoreWeights(input);
+    return Number(((input.astQuality * weights.ast)
+        + (((_a = input.lineCoverage) !== null && _a !== void 0 ? _a : 0) * ((_b = weights.line) !== null && _b !== void 0 ? _b : 0))
+        + (((_c = input.branchCoverage) !== null && _c !== void 0 ? _c : 0) * ((_d = weights.branch) !== null && _d !== void 0 ? _d : 0))
+        + (((_e = input.mutationScore) !== null && _e !== void 0 ? _e : 0) * ((_f = weights.mutation) !== null && _f !== void 0 ? _f : 0))).toFixed(1));
+}
+function describeAppliedWeighting(input) {
+    const weights = getAppliedUnitScoreWeights({
+        astQuality: 0,
+        dynamicPassRate: null,
+        lineCoverage: input.lineCoverage,
+        branchCoverage: input.branchCoverage,
+        mutationScore: input.mutationScore,
+        layersApplied: input.layersApplied,
+    });
+    const parts = [`AST ${formatWeightPercent(weights.ast)}`];
+    if (weights.line) {
+        parts.push(`Line ${formatWeightPercent(weights.line)}`);
+    }
+    if (weights.branch) {
+        parts.push(`Branch ${formatWeightPercent(weights.branch)}`);
+    }
+    if (weights.mutation) {
+        parts.push(`Mutation ${formatWeightPercent(weights.mutation)}`);
+    }
+    return parts.join(' + ');
+}
+function getAppliedUnitScoreWeights(input) {
+    const hasRuntime = input.layersApplied.includes('coverage') && input.lineCoverage !== null;
+    const hasBranch = hasRuntime && input.branchCoverage !== null;
+    const hasMutation = input.layersApplied.includes('mutation') && input.mutationScore !== null;
+    if (hasRuntime && hasMutation) {
+        return hasBranch
+            ? SCORE_WEIGHTS.astRuntimeMutation
+            : normalizeUnitScoreWeights({
+                ast: SCORE_WEIGHTS.astRuntimeMutation.ast,
+                line: SCORE_WEIGHTS.astRuntimeMutation.line,
+                mutation: SCORE_WEIGHTS.astRuntimeMutation.mutation,
+            });
+    }
+    if (hasRuntime) {
+        return hasBranch
+            ? SCORE_WEIGHTS.astRuntime
+            : normalizeUnitScoreWeights({
+                ast: SCORE_WEIGHTS.astRuntime.ast,
+                line: SCORE_WEIGHTS.astRuntime.line,
+            });
+    }
+    if (hasMutation) {
+        return SCORE_WEIGHTS.astMutation;
+    }
+    return SCORE_WEIGHTS.astOnly;
+}
+function normalizeUnitScoreWeights(weights) {
+    if (Object.values(weights).some((weight) => weight !== undefined && weight < 0)) {
+        return { ast: 1 };
+    }
+    const total = Object.values(weights).reduce((sum, value) => sum + value, 0);
+    if (total <= 0) {
+        return { ast: 1 };
+    }
+    const normalized = {
+        ast: weights.ast / total,
+    };
+    if (weights.line) {
+        normalized.line = weights.line / total;
+    }
+    if (weights.branch) {
+        normalized.branch = weights.branch / total;
+    }
+    if (weights.mutation) {
+        normalized.mutation = weights.mutation / total;
+    }
+    return normalized;
+}
+function formatWeightPercent(weight) {
+    const percent = weight * 100;
+    const rounded = percent.toFixed(1);
+    return rounded.endsWith('.0') ? `${rounded.slice(0, -2)}%` : `${rounded}%`;
+}
+function buildUnitAnalysisConsoleLines(input) {
+    var _a;
+    const lines = [
+        '=== Unit Analysis ===',
+        `Files scanned: ${input.ast.filesScanned} test files, ${input.ast.testCount} test methods`,
+        '',
+        `AST Quality Score: ${input.ast.qualityScore}/100`,
+        `  ${scoreIcon(input.ast.dimensionScores.assertionCompleteness)} Assertion completeness: ${input.ast.dimensionScores.assertionCompleteness}/20 (${describeAssertionCompleteness(input.ast)})`,
+        `  ${scoreIcon(input.ast.dimensionScores.testIsolation)} Test isolation: ${input.ast.dimensionScores.testIsolation}/20 (${input.ast.isolationPercent}% use mocks/stubs/spies)`,
+        `  ${scoreIcon(input.ast.dimensionScores.namingQuality)} Naming quality: ${input.ast.dimensionScores.namingQuality}/20 (${input.ast.descriptiveNamePercent}% descriptive names)`,
+        `  ${scoreIcon(input.ast.dimensionScores.disabledTests)} No disabled tests: ${input.ast.dimensionScores.disabledTests}/20 (${input.ast.disabledTests.length} disabled tests)`,
+        `  ${scoreIcon(input.ast.dimensionScores.criticalSmells)} Smell-free: ${input.ast.dimensionScores.criticalSmells}/20 (${describeCriticalSmells(input.ast)})`,
+    ];
+    if (input.coverage) {
+        lines.push('');
+        lines.push(`Runtime enrichment: ✓ ${input.coverage.tool} found at ${input.coverage.reportPath}`);
+        lines.push(`  Line coverage:   ${formatPct(input.coverage.lineCoverage)}`);
+        lines.push(`  Branch coverage: ${formatPct(input.coverage.branchCoverage)}`);
+        if (input.coverage.methodCoverage !== null) {
+            lines.push(`  Method coverage: ${formatPct(input.coverage.methodCoverage)}`);
+        }
+        if (input.coverage.classCoverage !== null) {
+            lines.push(`  Class coverage:  ${formatPct(input.coverage.classCoverage)}`);
+        }
+    }
+    else {
+        lines.push('');
+        lines.push('Runtime enrichment: · Not found (reads existing coverage artifacts only)');
+    }
+    if (input.mutation) {
+        lines.push('');
+        lines.push(`Mutation enrichment: ✓ ${input.mutation.tool} found at ${(_a = input.mutation.reportPath) !== null && _a !== void 0 ? _a : 'mutation report'}`);
+        lines.push(`  Mutation score: ${input.mutation.mutationScore}%`);
+        lines.push(`  Survived: ${input.mutation.survivedMutants}`);
+        lines.push(`  Killed:   ${input.mutation.killedMutants}`);
+    }
+    else {
+        lines.push('');
+        lines.push(`Mutation enrichment: · Not found (run: ${suggestMutationCommand(input.languages)})`);
+    }
+    if (input.dynamic) {
+        lines.push('');
+        lines.push(`Dynamic evidence: ${input.dynamic.reportPaths[0]} (${input.dynamic.passed} passed, ${input.dynamic.failed} failed, ${input.dynamic.skipped} skipped)`);
+    }
+    if (input.contract) {
+        lines.push(`Contract evidence: ${input.contract.totalContracts} contracts, ${input.contract.verifiedContracts} verified`);
+    }
+    return lines;
+}
 function detectTestSmells(rootDir, tests) {
     const smells = [];
     for (const test of tests) {
@@ -819,6 +1408,17 @@ function detectPerBlockSmells(rootDir, test) {
                 fix: 'Add assertion on the return value or verify mock interaction',
             });
         }
+        if (isEmptyTestBody(body)) {
+            smells.push({
+                smellId: 'SMELL-11',
+                severity: 'HIGH',
+                file: test.relativePath,
+                line: block.line,
+                testMethod: block.name,
+                description: 'Empty test body detected',
+                fix: 'Add test steps and assertions or remove the placeholder test',
+            });
+        }
         if (isDisabledWithoutReason(test.language, block, test.content)) {
             smells.push({
                 smellId: 'SMELL-03',
@@ -1106,6 +1706,37 @@ function extractTestBlocks(language, content) {
         }
         return blocks;
     }
+    if (language === 'ruby') {
+        const regex = /(xit|xspecify|it|specify|test)\s*(?:\(\s*)?['"]([^'"]+)['"](?:\s*\))?\s*do\s*\n([\s\S]*?)(?=\n\s*end\b)/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]],
+            });
+        }
+        return blocks;
+    }
+    if (language === 'go') {
+        const regex = /func\s+(Test[a-zA-Z_]\w*)\s*\([^)]*\)\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[1],
+                body: content.slice(start + 1, end),
+                line: lineNumberForIndex(content, match.index),
+                decorators: [],
+            });
+            regex.lastIndex = end + 1;
+        }
+        return blocks;
+    }
     return [];
 }
 function hasVerificationCall(language, body) {
@@ -1115,6 +1746,10 @@ function hasVerificationCall(language, body) {
         return /expect\s*\(|toHaveBeenCalled/.test(body);
     if (language === 'python')
         return /\bassert\b|assert_called/.test(body);
+    if (language === 'ruby')
+        return /\bexpect\(|assert_|refute_|have_received/.test(body);
+    if (language === 'go')
+        return /\b(?:assert|require)\.\w+\(|t\.Fatalf?\(|t\.Errorf?\(/.test(body);
     return false;
 }
 function isDisabledWithoutReason(language, block, content) {
@@ -1132,6 +1767,24 @@ function isDisabledWithoutReason(language, block, content) {
     if (language === 'python') {
         return block.decorators.some((decorator) => /@pytest\.mark\.skip(?!\s*\(|.*reason\s*=)/.test(decorator));
     }
+    if (language === 'ruby') {
+        return block.decorators.some((decorator) => /^(xit|xspecify)$/.test(decorator));
+    }
+    return false;
+}
+function isDisabledBlock(language, block) {
+    if (language === 'java' || language === 'kotlin') {
+        return block.decorators.some((decorator) => decorator.startsWith('@Disabled'));
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        return block.decorators.some((decorator) => /^(xit|xtest|test\.skip|it\.skip)$/.test(decorator));
+    }
+    if (language === 'python') {
+        return block.decorators.some((decorator) => /@pytest\.mark\.skip/.test(decorator));
+    }
+    if (language === 'ruby') {
+        return block.decorators.some((decorator) => /^(xit|xspecify)$/.test(decorator));
+    }
     return false;
 }
 function hasAssertionMessages(language, body) {
@@ -1224,6 +1877,7 @@ function countParameterizedExpansions(content) {
     var _a, _b;
     const matches = [
         ...content.matchAll(/@CsvSource\(([^)]*)\)/g),
+        ...content.matchAll(/@ParameterizedTest/g),
         ...content.matchAll(/test\.each\(([^)]*)\)/g),
         ...content.matchAll(/pytest\.mark\.parametrize\(([^)]*)\)/g),
     ];
@@ -1241,6 +1895,10 @@ function detectMockLibrary(content) {
         return 'jest';
     if (/unittest\.mock|MagicMock|pytest-mock|mocker\./i.test(content))
         return 'unittest.mock';
+    if (/\bdouble\(|instance_double\(|allow\(|stub_const\(/.test(content))
+        return 'rspec';
+    if (/gomock|testify\/mock/.test(content))
+        return 'gomock';
     return undefined;
 }
 function classifyLayer(content, filePath) {
@@ -1251,7 +1909,7 @@ function classifyLayer(content, filePath) {
     return 'unit';
 }
 function countAssertions(language, content) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (language === 'java' || language === 'kotlin') {
         return ((_a = content.match(/\bassert\w*\s*\(|\bverify\s*\(/g)) !== null && _a !== void 0 ? _a : []).length;
     }
@@ -1261,8 +1919,151 @@ function countAssertions(language, content) {
     if (language === 'python') {
         return ((_c = content.match(/\bassert\b|assert_called/g)) !== null && _c !== void 0 ? _c : []).length;
     }
+    if (language === 'ruby') {
+        return ((_d = content.match(/\bexpect\(|\bassert_\w+|\brefute_\w+|have_received/g)) !== null && _d !== void 0 ? _d : []).length;
+    }
+    if (language === 'go') {
+        return ((_e = content.match(/\b(?:assert|require)\.\w+\(|t\.Fatalf?\(|t\.Errorf?\(/g)) !== null && _e !== void 0 ? _e : []).length;
+    }
     return 0;
 }
+function countTestClasses(language, content) {
+    var _a, _b, _c, _d;
+    if (language === 'java' || language === 'kotlin') {
+        return ((_a = content.match(/\bclass\s+[A-Z]\w*Test\b/g)) !== null && _a !== void 0 ? _a : []).length || 1;
+    }
+    if (language === 'python') {
+        return ((_b = content.match(/^\s*class\s+\w+\(.*TestCase.*\):/gm)) !== null && _b !== void 0 ? _b : []).length || 1;
+    }
+    if (language === 'ruby') {
+        return ((_c = content.match(/\bRSpec\.describe\b|\bdescribe\s+['"]/g)) !== null && _c !== void 0 ? _c : []).length || 1;
+    }
+    if (language === 'go') {
+        return 1;
+    }
+    return ((_d = content.match(/\bdescribe\s*\(/g)) !== null && _d !== void 0 ? _d : []).length || 1;
+}
+function countParameterizedTests(language, content) {
+    var _a, _b, _c, _d;
+    if (language === 'java' || language === 'kotlin')
+        return ((_a = content.match(/@ParameterizedTest/g)) !== null && _a !== void 0 ? _a : []).length;
+    if (language === 'javascript' || language === 'typescript')
+        return ((_b = content.match(/\b(?:test|it)\.each\s*\(/g)) !== null && _b !== void 0 ? _b : []).length;
+    if (language === 'python')
+        return ((_c = content.match(/pytest\.mark\.parametrize/g)) !== null && _c !== void 0 ? _c : []).length;
+    if (language === 'ruby')
+        return ((_d = content.match(/\bshared_examples\b|\beach do \|/g)) !== null && _d !== void 0 ? _d : []).length;
+    return 0;
+}
+function countMockSignals(content) {
+    var _a;
+    return ((_a = content.match(/@MockBean\b|@Mock\b|\bmock\(|jest\.mock\(|vi\.mock\(|patch\(|MagicMock|mocker\.|double\(|gomock|testify\/mock/g)) !== null && _a !== void 0 ? _a : []).length;
+}
+function countStubSignals(content) {
+    var _a;
+    return ((_a = content.match(/thenReturn\(|mockReturnValue\(|returns\(|allow\(.+\)\.to receive|stub\(/g)) !== null && _a !== void 0 ? _a : []).length;
+}
+function countSpySignals(content) {
+    var _a;
+    return ((_a = content.match(/@Spy\b|jest\.spyOn\(|vi\.spyOn\(|spyOn\(/g)) !== null && _a !== void 0 ? _a : []).length;
+}
+function testUsesIsolation(language, body) {
+    if (language === 'java' || language === 'kotlin')
+        return /@Mock\b|@MockBean\b|verify\(|mock\(|when\(.+\)\.thenReturn|spy\(/.test(body);
+    if (language === 'javascript' || language === 'typescript')
+        return /jest\.mock\(|vi\.mock\(|jest\.spyOn\(|vi\.spyOn\(|mockReturnValue|toHaveBeenCalled/.test(body);
+    if (language === 'python')
+        return /patch\(|MagicMock|mocker\.|assert_called/.test(body);
+    if (language === 'ruby')
+        return /double\(|instance_double\(|allow\(|have_received/.test(body);
+    if (language === 'go')
+        return /gomock|testify\/mock|mock\./.test(body);
+    return false;
+}
+function isDescriptiveTestName(name) {
+    const normalized = name
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[_\-]+/g, ' ')
+        .trim();
+    return normalized.split(/\s+/).filter(Boolean).length > 3;
+}
+function isGenericTestName(name) {
+    return /^(test\d+|testMethod\d+|testMethod|shouldWork|works|test)$/i.test(name.replace(/\s+/g, ''));
+}
+function isEmptyTestBody(body) {
+    const meaningful = body
+        .split('\n')
+        .map((line) => line.replace(/\/\/.*$/, '').trim())
+        .filter(Boolean);
+    return meaningful.length === 0 || meaningful.every((line) => /^(pass|todo)$/i.test(line) || /^(\/\/|#)/.test(line));
+}
+function collectLineMatches(rootDir, filePath, content, pattern) {
+    const relativePath = normalizePath(path.relative(rootDir, filePath));
+    return content
+        .split('\n')
+        .flatMap((line, index) => (pattern.test(line) ? [`${relativePath}:${index + 1}`] : []));
+}
+function hasStaticMutableStateMutation(language, content) {
+    var _a, _b, _c, _d;
+    if (language === 'java' || language === 'kotlin') {
+        const beforeAllBlock = (_b = (_a = /@BeforeAll[\s\S]*?\{([\s\S]*?)\}/.exec(content)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
+        const staticFields = [...content.matchAll(/static\s+(?!final)[^{;=]+([a-zA-Z_]\w*)/g)].map((match) => match[1]);
+        if (staticFields.length === 0)
+            return false;
+        const mutatedFields = staticFields.filter((field) => new RegExp(`\\b${field}\\s*=`).test(beforeAllBlock));
+        if (mutatedFields.length === 0)
+            return false;
+        const afterAllBlock = (_d = (_c = /@AfterAll[\s\S]*?\{([\s\S]*?)\}/.exec(content)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : '';
+        return mutatedFields.some((field) => !new RegExp(`\\b${field}\\s*=`).test(afterAllBlock));
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        return /\blet\s+[a-zA-Z_]\w*/.test(content) && /beforeAll\s*\([\s\S]*?\b[a-zA-Z_]\w*\s*=/.test(content);
+    }
+    if (language === 'python') {
+        return /@classmethod\s+def\s+setUpClass/.test(content) && /cls\.[a-zA-Z_]\w*\s*=/.test(content) && !/@classmethod\s+def\s+tearDownClass/.test(content);
+    }
+    return false;
+}
+function collectSharedMutableFields(language, content) {
+    if (language === 'java' || language === 'kotlin') {
+        return dedupeStrings([...content.matchAll(/(?:private|protected|public)?\s*(?!final)(?:[\w<>\[\]]+\s+)+([a-zA-Z_]\w*)\s*[;=]/g)].map((match) => match[1]));
+    }
+    if (language === 'javascript' || language === 'typescript') {
+        return dedupeStrings([...content.matchAll(/\blet\s+([a-zA-Z_]\w*)\s*[=;]/g)].map((match) => match[1]));
+    }
+    if (language === 'python') {
+        return dedupeStrings([...content.matchAll(/self\.([a-zA-Z_]\w*)\s*=/g)].map((match) => match[1]));
+    }
+    return [];
+}
+function clampScore(score) {
+    return Math.max(0, Math.min(100, Number(score.toFixed(1))));
+}
+function calculateWeightedCoveredItems(totalItems, weightedScore) {
+    if (totalItems <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.min(totalItems, Math.round((totalItems * clampScore(weightedScore)) / 100)));
+}
+function countPassingQualityTests(tests) {
+    let passing = 0;
+    for (const test of tests) {
+        for (const block of test.testBlocks) {
+            const assertionCount = countAssertions(test.language, block.body);
+            const hasCriticalSmell = isEmptyTestBody(block.body)
+                || /Thread\.sleep\(|time\.sleep\(|setTimeout\(/.test(block.body)
+                || /\b(?:password|secret|token|api[_-]?key)\b\s*[:=]\s*['"][^'"]+['"]/i.test(block.body);
+            const passes = assertionCount > 0
+                && !isDisabledBlock(test.language, block)
+                && isDescriptiveTestName(block.name)
+                && !hasCriticalSmell;
+            if (passes) {
+                passing += 1;
+            }
+        }
+    }
+    return passing;
+}
 function summarizeSmells(smells) {
     return {
         CRITICAL: smells.filter((smell) => smell.severity === 'CRITICAL').length,
@@ -1292,6 +2093,10 @@ function detectTestLanguage(filePath) {
         return 'typescript';
     if (ext === '.py')
         return 'python';
+    if (ext === '.rb')
+        return 'ruby';
+    if (ext === '.go')
+        return 'go';
     return 'other';
 }
 function findMatchingBrace(content, openBraceIndex) {
@@ -1345,6 +2150,19 @@ function coveragePercent(counter) {
         return null;
     return safePercent(counter.covered, counter.covered + counter.missed);
 }
+function sortCoverageFiles(fileCoverage) {
+    return dedupeBy(fileCoverage, (entry) => entry.file)
+        .sort((a, b) => a.lineCoverage - b.lineCoverage || a.file.localeCompare(b.file));
+}
+function buildCoverageFileFields(fileCoverage) {
+    const sorted = sortCoverageFiles(fileCoverage);
+    return {
+        uncoveredFiles: sorted.filter((entry) => entry.lineCoverage === 0).map((entry) => entry.file),
+        lowCoverageFiles: sorted
+            .filter((entry) => entry.lineCoverage < 50)
+            .map((entry) => ({ file: entry.file, lineCoverage: entry.lineCoverage })),
+    };
+}
 function safePercent(covered, total) {
     if (!Number.isFinite(total) || total <= 0)
         return null;
@@ -1364,6 +2182,126 @@ 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 sanitizeXmlText(value) {
+    return value
+        .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .trim();
+}
+function rankWorstMutationFiles(fileStats) {
+    return Array.from(fileStats.entries())
+        .filter(([, stats]) => stats.total > 0)
+        .map(([file, stats]) => ({
+        file: normalizePath(file),
+        survived: stats.total - stats.killed,
+        killed: stats.killed,
+    }))
+        .sort((a, b) => b.survived - a.survived || a.file.localeCompare(b.file))
+        .slice(0, 5);
+}
+function rankWeakestMutationFiles(fileStats) {
+    return Array.from(fileStats.entries())
+        .filter(([, stats]) => stats.total > 0)
+        .sort((a, b) => {
+        const aScore = (a[1].killed / a[1].total) * 100;
+        const bScore = (b[1].killed / b[1].total) * 100;
+        return aScore - bScore || a[0].localeCompare(b[0]);
+    })
+        .slice(0, 5)
+        .map(([file]) => normalizePath(file));
+}
+function formatPct(value) {
+    return value === null ? 'n/a' : `${value}%`;
+}
+function scoreIcon(score) {
+    return score >= 20 ? '✓' : score > 0 ? '⚠' : '✗';
+}
+function describeAssertionCompleteness(ast) {
+    if (ast.testsWithZeroAssertions.length === 0) {
+        return 'all tests have assertions';
+    }
+    return `${ast.testsWithZeroAssertions.length} tests without assertions`;
+}
+function describeCriticalSmells(ast) {
+    const parts = [
+        ast.threadSleepUsage.length > 0 ? `${ast.threadSleepUsage.length} sleep usages` : undefined,
+        ast.emptyTestBodies.length > 0 ? `${ast.emptyTestBodies.length} empty bodies` : undefined,
+        ast.hardcodedCredentials.length > 0 ? `${ast.hardcodedCredentials.length} hardcoded credentials` : undefined,
+    ].filter((value) => Boolean(value));
+    return parts.length > 0 ? parts.join(', ') : 'no critical smells';
+}
+function appendDetectedSmells(lines, ast) {
+    const smellEntries = [
+        ...ast.threadSleepUsage.map((entry) => `  ⚠ Thread.sleep()/sleep usage in ${entry}`),
+        ...ast.emptyTestBodies.map((entry) => `  ⚠ Empty test body: ${entry}`),
+        ...ast.disabledTests.map((entry) => `  ⚠ Disabled test: ${entry}`),
+    ];
+    if (smellEntries.length === 0)
+        return;
+    lines.push('');
+    lines.push(`Smells detected (${smellEntries.length}):`);
+    for (const entry of smellEntries.slice(0, 10)) {
+        lines.push(entry);
+    }
+}
+function appendLowCoverageFiles(lines, coverage) {
+    if (!coverage || coverage.lowCoverageFiles.length === 0)
+        return;
+    lines.push('');
+    lines.push('Low coverage files (< 50%):');
+    for (const entry of coverage.lowCoverageFiles.slice(0, 10)) {
+        lines.push(`  ⚠ ${entry.file}: ${entry.lineCoverage}% line coverage`);
+    }
+}
+function suggestMutationCommand(languages) {
+    const lowerLanguages = languages.map((language) => language.toLowerCase());
+    if (lowerLanguages.some((language) => language === 'java' || language === 'kotlin'))
+        return 'gradle pitest';
+    if (lowerLanguages.some((language) => language === 'typescript' || language === 'javascript'))
+        return 'npx stryker run';
+    if (lowerLanguages.includes('python'))
+        return 'mutmut run';
+    if (lowerLanguages.includes('ruby'))
+        return 'configure a mutation report under reports/mutation/';
+    return 'write a supported mutation report under build/reports/pitest or reports/mutation';
+}
+function formatContractName(contract, contractPath) {
+    var _a, _b;
+    const consumer = typeof contract['consumer'] === 'object' && contract['consumer'] !== null
+        ? String((_a = contract['consumer']['name']) !== null && _a !== void 0 ? _a : 'unknown')
+        : 'unknown';
+    const provider = typeof contract['provider'] === 'object' && contract['provider'] !== null
+        ? String((_b = contract['provider']['name']) !== null && _b !== void 0 ? _b : 'unknown')
+        : 'unknown';
+    return consumer !== 'unknown' || provider !== 'unknown'
+        ? `${consumer}→${provider}`
+        : normalizePath(contractPath);
+}
+function extractContractVerificationStatus(contract) {
+    var _a, _b, _c, _d;
+    const metadata = ((_a = contract['metadata']) !== null && _a !== void 0 ? _a : {});
+    const verification = ((_d = (_c = (_b = contract['verificationResult']) !== null && _b !== void 0 ? _b : contract['verification']) !== null && _c !== void 0 ? _c : metadata['verificationResult']) !== null && _d !== void 0 ? _d : metadata['verification']);
+    if (typeof verification === 'boolean')
+        return verification;
+    if (verification && typeof verification === 'object') {
+        if (typeof verification['success'] === 'boolean')
+            return verification['success'];
+        if (typeof verification['passed'] === 'boolean')
+            return verification['passed'];
+        if (typeof verification['verified'] === 'boolean')
+            return verification['verified'];
+    }
+    if (typeof contract['verified'] === 'boolean')
+        return contract['verified'];
+    return null;
+}
+function extractContractFailureReason(contract) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const metadata = ((_a = contract['metadata']) !== null && _a !== void 0 ? _a : {});
+    const verification = ((_d = (_c = (_b = contract['verificationResult']) !== null && _b !== void 0 ? _b : contract['verification']) !== null && _c !== void 0 ? _c : metadata['verificationResult']) !== null && _d !== void 0 ? _d : metadata['verification']);
+    return String((_g = (_f = (_e = verification === null || verification === void 0 ? void 0 : verification['reason']) !== null && _e !== void 0 ? _e : verification === null || verification === void 0 ? void 0 : verification['message']) !== null && _f !== void 0 ? _f : contract['verificationError']) !== null && _g !== void 0 ? _g : 'verification failed');
+}
 function dedupeBy(items, keyFn) {
     const seen = new Set();
     const deduped = [];
@@ -1390,3 +2328,19 @@ function safeRead(filePath) {
         return '';
     }
 }
+function safeReadHead(filePath, maxBytes = 4096) {
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            const buffer = Buffer.alloc(maxBytes);
+            const bytesRead = fs.readSync(fd, buffer, 0, maxBytes, 0);
+            return buffer.toString('utf-8', 0, bytesRead);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return '';
+    }
+}