@vitest-agent/plugin 5.2.2 → 5.3.0

package/layers/CoverageAnalyzerLive.js

@@ -17,6 +17,59 @@ function isBelowMetricThresholds(stats, thresholds) {
 	if (thresholds.statements !== void 0 && stats.statements < thresholds.statements) return true;
 	return false;
 }
+const METRICS = [
+	"statements",
+	"branches",
+	"functions",
+	"lines"
+];
+/**
+* Istanbul's own percentage: `covered / total` floored to two decimals, and
+* 100 for an empty (`total === 0`) metric. Mirrors `istanbul-lib-coverage`'s
+* `percent()` so an aggregate computed here equals what Vitest compares.
+*/
+function istanbulPercent(covered, total) {
+	return total > 0 ? Math.floor(1e4 * covered / total) / 100 : 100;
+}
+/**
+* Aggregate a glob's matched files the way Vitest builds a glob coverage map:
+* sum `covered` and `total` per metric across the files' summaries, then take
+* the percentage of the sums (NOT a mean of per-file percentages). Returns
+* `undefined` when any file's summary lacks counts, since no honest aggregate
+* exists then.
+*/
+function aggregateSummaries(summaries) {
+	const sums = {
+		statements: {
+			covered: 0,
+			total: 0
+		},
+		branches: {
+			covered: 0,
+			total: 0
+		},
+		functions: {
+			covered: 0,
+			total: 0
+		},
+		lines: {
+			covered: 0,
+			total: 0
+		}
+	};
+	for (const s of summaries) for (const m of METRICS) {
+		const { covered, total } = s[m];
+		if (typeof covered !== "number" || typeof total !== "number") return void 0;
+		sums[m].covered += covered;
+		sums[m].total += total;
+	}
+	return {
+		statements: istanbulPercent(sums.statements.covered, sums.statements.total),
+		branches: istanbulPercent(sums.branches.covered, sums.branches.total),
+		functions: istanbulPercent(sums.functions.covered, sums.functions.total),
+		lines: istanbulPercent(sums.lines.covered, sums.lines.total)
+	};
+}
 /**
 * Runtime duck-type check for istanbul CoverageMap.
 */
@@ -86,6 +139,53 @@ function resolveEffectivePerFileThresholds(filePath, resolved) {
 	return setting;
 }
 /**
+* Find the threshold globs whose aggregate coverage is below their own metric
+* numbers (issue #391), matching Vitest 5: a glob's coverage map holds every
+* file in the run that matches it (a file may belong to several globs), the
+* aggregate is `sum(covered) / sum(total)` per metric, and it is enforced in
+* addition to any object `perFile`. A glob with `perFile: true` is checked per
+* file only, so it has no aggregate to fail.
+*
+* Choices (document before changing):
+* - Bare-zero files COUNT toward the aggregate, regardless of
+*   `includeBareZero`. That option only decides whether such files are listed
+*   per file; Vitest's aggregate includes them, and dropping them would hide
+*   exactly the shortfall they cause.
+* - Scoped runs never produce shortfalls (the caller skips this): a partial
+*   coverage map says nothing about a glob's full aggregate, mirroring how
+*   scoped runs never flag threshold violations.
+* - Only non-negative numbers are compared (minimum percentages). Vitest's
+*   negative "max uncovered count" form is not evaluated here.
+* - A glob that matches no file, or whose matched summaries lack
+*   covered/total counts, yields nothing.
+*/
+function computeGlobShortfalls(files, resolved) {
+	const shortfalls = [];
+	for (const [pattern, metrics] of resolved.patterns ?? []) {
+		if (metrics.perFile === true) continue;
+		const thresholds = {
+			...metrics.lines !== void 0 ? { lines: metrics.lines } : {},
+			...metrics.functions !== void 0 ? { functions: metrics.functions } : {},
+			...metrics.branches !== void 0 ? { branches: metrics.branches } : {},
+			...metrics.statements !== void 0 ? { statements: metrics.statements } : {}
+		};
+		if (METRICS.every((m) => thresholds[m] === void 0)) continue;
+		const matched = files.filter((f) => matchGlob(f.matchPath, pattern));
+		if (matched.length === 0) continue;
+		const aggregate = aggregateSummaries(matched.map((f) => f.summary));
+		if (aggregate === void 0) continue;
+		if (METRICS.some((m) => {
+			const min = thresholds[m];
+			return min !== void 0 && min >= 0 && aggregate[m] < min;
+		})) shortfalls.push({
+			pattern,
+			summary: aggregate,
+			thresholds
+		});
+	}
+	return shortfalls;
+}
+/**
 * Internal coverage processing logic. Shared by both `process` and `processScoped`.
 *
 * @param coverageMap - The value received by `onCoverage`; duck-typed at runtime
@@ -110,10 +210,15 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 	const belowTarget = [];
 	const { root } = options;
 	const matchKey = (filePath) => toPosixPath(root === void 0 ? filePath : relative(root, filePath));
+	const mapSummaries = [];
 	for (const filePath of coverageMap.files()) {
 		const matchPath = matchKey(filePath);
 		const fileCoverage = coverageMap.fileCoverageFor(filePath);
 		const fileSummary = fileCoverage.toSummary();
+		mapSummaries.push({
+			matchPath,
+			summary: fileSummary
+		});
 		const fileStats = {
 			statements: fileSummary.statements.pct,
 			branches: fileSummary.branches.pct,
@@ -134,7 +239,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 			continue;
 		}
 		if (options.targets) {
-			if (isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(matchPath, options.targets))) {
+			if (isBelowMetricThresholds(fileStats, resolveEffectivePerFileThresholds(matchPath, options.targets) ?? resolveEffectiveThresholds(matchPath, options.targets))) {
 				const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
 				belowTarget.push({
 					file: filePath,
@@ -144,6 +249,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 			}
 		}
 	}
+	const globShortfalls = scoped ? [] : computeGlobShortfalls(mapSummaries, options.thresholds);
 	lowCoverage.sort((a, b) => a.summary.lines - b.summary.lines);
 	belowTarget.sort((a, b) => a.summary.lines - b.summary.lines);
 	return {
@@ -165,6 +271,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		...scoped && options.totalFiles !== void 0 ? { totalFiles: options.totalFiles } : {},
 		lowCoverage,
 		lowCoverageFiles: lowCoverage.map((f) => f.file),
+		...globShortfalls.length > 0 ? { globShortfalls } : {},
 		...options.targets ? {
 			belowTarget,
 			belowTargetFiles: belowTarget.map((f) => f.file)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "5.2.2",
+	"version": "5.3.0",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -49,11 +49,11 @@
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",
 		"@effected/workspaces": "^0.31.0",
-		"@vitest-agent/cli": "4.0.2",
-		"@vitest-agent/engine": "0.6.0",
-		"@vitest-agent/mcp": "5.1.8",
-		"@vitest-agent/reporter": "4.1.0",
-		"@vitest-agent/sdk": "6.0.0",
+		"@vitest-agent/cli": "4.0.3",
+		"@vitest-agent/engine": "0.6.1",
+		"@vitest-agent/mcp": "5.1.9",
+		"@vitest-agent/reporter": "4.1.1",
+		"@vitest-agent/sdk": "6.1.0",
 		"effect": "^4.0.0",
 		"magic-string": "^1.4.2"
 	},

package/reporter.js

@@ -1287,7 +1287,8 @@ var AgentReporter = class {
 					})),
 					...coverageReport.scoped ? { scoped: coverageReport.scoped } : {},
 					...coverageReport.scopedFiles !== void 0 ? { scopedFiles: coverageReport.scopedFiles.length } : {},
-					...coverageReport.totalFiles !== void 0 ? { totalFiles: coverageReport.totalFiles } : {}
+					...coverageReport.totalFiles !== void 0 ? { totalFiles: coverageReport.totalFiles } : {},
+					...coverageReport.globShortfalls !== void 0 ? { globShortfalls: coverageReport.globShortfalls } : {}
 				});
 				if (!coverageReport.scoped) for (const metric of [
 					"lines",

package/version.js

@@ -8,7 +8,7 @@
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "5.2.2";
+const CURRENT_PLUGIN_VERSION = "5.3.0";
 
 //#endregion
 export { CURRENT_PLUGIN_VERSION };