@vitest-agent/plugin 2.5.4 → 2.5.5

package/index.d.ts

@@ -643,6 +643,35 @@ declare class AgentReporter {
    * @internal
    */
   private hookStartedAt;
+  /**
+   * Count of test specifications Vitest started for the current run,
+   * captured from `onTestRunStart`'s `specifications` argument. Used
+   * alongside a fresh `globTestSpecifications()` total in `onTestRunEnd`
+   * as one of `isPartialRun`'s signals (issue #160 gap 2) — a tags-only
+   * `run_tests` filter narrows the run without setting `filenamePattern`
+   * or `projectFilter`, so the spec-count comparison is the only signal
+   * that catches it. `undefined` when `onTestRunStart` never fired
+   * (tests invoking `onTestRunEnd` directly); `onTestRunEnd` falls back
+   * to the executed module count in that case.
+   *
+   * @internal
+   */
+  private startedSpecCount;
+  /**
+   * Original values of coverage-threshold keys deleted from
+   * `vitest.coverageProvider.options.thresholds` while neutralizing a
+   * partial run (issue #160). In `run` mode Vitest re-initializes the
+   * provider on every `vitest.start`, so the snapshot is moot — but in
+   * watch mode the provider is created once and scoped reruns go through
+   * `rerunFiles` without re-initializing it, so a deleted key would stay
+   * gone for the rest of the watch session. `onTestRunStart` restores
+   * these keys (only if still absent — a legitimately re-initialized
+   * provider is left alone) and clears the map. Empty when the last run
+   * was not partial.
+   *
+   * @internal
+   */
+  private neutralizedThresholdSnapshot;
   constructor(options?: AgentReporterConstructorOptions);
   /**
    * The resolved reporter config built at construction time. Exposed for
@@ -1134,6 +1163,13 @@ interface CoverageOptions {
   readonly baselines?: CoverageBaselines;
   /** When true, include files with zero coverage rather than omitting them. */
   readonly includeBareZero: boolean;
+  /**
+   * Total test-file count for the project, when known (issue #160 gap 1).
+   * Only meaningful on a scoped run — threaded onto the returned
+   * `CoverageReport.totalFiles` so the scoped-coverage note can render
+   * "N of M test files" instead of just "N".
+   */
+  readonly totalFiles?: number;
 }
 declare const CoverageAnalyzer_base: Context.ServiceClass<CoverageAnalyzer, "vitest-agent/CoverageAnalyzer", {
   readonly process: (coverage: unknown, options: CoverageOptions) => Effect.Effect<Option.Option<CoverageReport>>;

package/layers/CoverageAnalyzerLive.js

@@ -112,6 +112,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		} } : {},
 		scoped,
 		...scoped && testedFiles ? { scopedFiles: [...testedFiles] } : {},
+		...scoped && options.totalFiles !== void 0 ? { totalFiles: options.totalFiles } : {},
 		lowCoverage,
 		lowCoverageFiles: lowCoverage.map((f) => f.file),
 		...options.targets ? {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "2.5.4",
+	"version": "2.5.5",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -41,11 +41,11 @@
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.109",
 		"@effect/sql-sqlite-node": "4.0.0-rc.109",
-		"@effected/workspaces": "^0.18.3",
-		"@vitest-agent/cli": "2.2.13",
-		"@vitest-agent/mcp": "2.4.12",
-		"@vitest-agent/reporter": "2.2.2",
-		"@vitest-agent/sdk": "2.4.13",
+		"@effected/workspaces": "^0.19.0",
+		"@vitest-agent/cli": "2.2.14",
+		"@vitest-agent/mcp": "2.4.13",
+		"@vitest-agent/reporter": "2.2.3",
+		"@vitest-agent/sdk": "2.5.0",
 		"effect": "4.0.0-rc.109",
 		"magic-string": "^1.2.3"
 	},

package/plugin.js

@@ -8,9 +8,13 @@ import { discoverProjects } from "./utils/discover-projects.js";
 import { ensureGithubActionsReporter } from "./utils/ensure-github-reporter.js";
 import { injectTags } from "./utils/inject-tags.js";
 import { isBenignViteSourceMapWarning } from "./utils/is-benign-vite-source-map-warning.js";
+import { resolveCoverageDirIsolation } from "./utils/resolve-coverage-dir-isolation.js";
 import { DEFAULT_BUILT_RECENTLY_MS, DEFAULT_LOCK_STALE_MS, DEFAULT_LOCK_WAIT_TIMEOUT_MS, acquireRunScriptLock, markRunScriptDone, parseLockTimingOverride, releaseRunScriptLock } from "./utils/run-script-lock.js";
 import { stripConsoleReporters } from "./utils/strip-console-reporters.js";
 import { execSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { AgentConsoleMode, CiConsoleMode, CoverageLevel, EnvironmentDetector, EnvironmentDetectorLive, HumanConsoleMode, SRC_DIR, TEST_DIR, formatFatalError, isTestFileName, resolveLogLevel } from "@vitest-agent/sdk";
 import { Effect, Schema } from "effect";
 
@@ -94,6 +98,15 @@ function resolveFormat(mode) {
 */
 const aggregatedReporterByVitest = /* @__PURE__ */ new WeakSet();
 /**
+* Guards the coverage.reportsDirectory isolation decision (issue #194) to
+* run at most once per Vitest run — `configureVitest` fires once per
+* project, but `coverage.reportsDirectory` is root-level config shared by
+* every project in that run.
+*
+* @internal
+*/
+const coverageDirDecidedByVitest = /* @__PURE__ */ new WeakSet();
+/**
 * The version of this package, inlined at build time from
 * `package.json#version` via rslib-builder's `__PACKAGE_VERSION__` substitution.
 * Re-exported from the package barrel as the public symbol; defined here so
@@ -101,7 +114,7 @@ const aggregatedReporterByVitest = /* @__PURE__ */ new WeakSet();
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "2.5.4";
+const CURRENT_PLUGIN_VERSION = "2.5.5";
 const TEST_FILE_DIR_RE = new RegExp(`/(?:${SRC_DIR}|${TEST_DIR})/`);
 const isTestFile = (id) => isTestFileName(id) && TEST_FILE_DIR_RE.test(id);
 /**
@@ -203,6 +216,31 @@ function AgentPlugin(options = {}, _layer) {
 				const rawTargets = options.coverageTargets;
 				const coverageTargets = rawTargets ? resolveThresholds(rawTargets) : void 0;
 				const coverageMode = coverageConfig?.enabled === false ? "ui-only" : "full";
+				if (coverageConfig && !coverageDirDecidedByVitest.has(vitest)) {
+					coverageDirDecidedByVitest.add(vitest);
+					const dirDecision = resolveCoverageDirIsolation({
+						executor,
+						coverageEnabled: coverageMode === "full",
+						env: process.env,
+						configured: coverageConfig.reportsDirectory
+					});
+					if (dirDecision.kind === "isolate") {
+						const isolatedDir = mkdtempSync(join(tmpdir(), "vitest-agent-cov-"));
+						log("isolating coverage.reportsDirectory ->", isolatedDir);
+						coverageConfig.reportsDirectory = isolatedDir;
+						vitest.onClose(() => {
+							try {
+								rmSync(isolatedDir, {
+									recursive: true,
+									force: true
+								});
+							} catch {}
+						});
+					} else if (dirDecision.kind === "explicit") {
+						log("using explicit VITEST_AGENT_COVERAGE_DIR ->", dirDecision.dir);
+						coverageConfig.reportsDirectory = dirDecision.dir;
+					}
+				}
 				const transport = options.transport ?? { kind: "local" };
 				log("transport.kind:", transport.kind);
 				const passWithNoTestsRaw = vitest.config.passWithNoTests;

package/reporter.js

@@ -4,14 +4,15 @@ import { ReporterLive } from "./layers/ReporterLive.js";
 import { buildReporterKit, normalizeReporters } from "./utils/build-reporter-kit.js";
 import { captureEnvVars } from "./utils/capture-env.js";
 import { captureSettings, hashSettings } from "./utils/capture-settings.js";
+import { isPartialRun } from "./utils/is-partial-run.js";
 import { processFailure } from "./utils/process-failure.js";
 import { routeRenderedOutput } from "./utils/route-rendered-output.js";
 import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
 import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorResolver, FormatSelector, HistoryTracker, OutputPipelineLive, PathResolutionLive, buildAgentReport, coerceErrorField, computeTrend, ensureMigrated, formatFatalError, historyKey, isTimeoutError, probeHostMetadataFromEnv, resolveDataPath, resolveLogFile, resolveLogLevel } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
 import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
 import { NodeServices } from "@effect/platform-node";
 import { DefaultVitestAgentReporter } from "@vitest-agent/reporter";
 
@@ -199,6 +200,35 @@ var AgentReporter = class {
 	* @internal
 	*/
 	hookStartedAt = /* @__PURE__ */ new Map();
+	/**
+	* Count of test specifications Vitest started for the current run,
+	* captured from `onTestRunStart`'s `specifications` argument. Used
+	* alongside a fresh `globTestSpecifications()` total in `onTestRunEnd`
+	* as one of `isPartialRun`'s signals (issue #160 gap 2) — a tags-only
+	* `run_tests` filter narrows the run without setting `filenamePattern`
+	* or `projectFilter`, so the spec-count comparison is the only signal
+	* that catches it. `undefined` when `onTestRunStart` never fired
+	* (tests invoking `onTestRunEnd` directly); `onTestRunEnd` falls back
+	* to the executed module count in that case.
+	*
+	* @internal
+	*/
+	startedSpecCount;
+	/**
+	* Original values of coverage-threshold keys deleted from
+	* `vitest.coverageProvider.options.thresholds` while neutralizing a
+	* partial run (issue #160). In `run` mode Vitest re-initializes the
+	* provider on every `vitest.start`, so the snapshot is moot — but in
+	* watch mode the provider is created once and scoped reruns go through
+	* `rerunFiles` without re-initializing it, so a deleted key would stay
+	* gone for the rest of the watch session. `onTestRunStart` restores
+	* these keys (only if still absent — a legitimately re-initialized
+	* provider is left alone) and clears the map. Empty when the last run
+	* was not partial.
+	*
+	* @internal
+	*/
+	neutralizedThresholdSnapshot = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.logLevel = resolveLogLevel();
 		this.logFile = resolveLogFile();
@@ -397,6 +427,16 @@ var AgentReporter = class {
 	* `RunStarted` event for live subscribers.
 	*/
 	onTestRunStart(_specifications) {
+		this.startedSpecCount = _specifications.length;
+		if (this.neutralizedThresholdSnapshot.size > 0) {
+			try {
+				const thresholds = (this._vitest?.coverageProvider)?.options?.thresholds;
+				if (thresholds !== void 0 && typeof thresholds === "object") {
+					for (const [key, value] of this.neutralizedThresholdSnapshot) if (!(key in thresholds)) thresholds[key] = value;
+				}
+			} catch {}
+			this.neutralizedThresholdSnapshot = /* @__PURE__ */ new Map();
+		}
 		if (!this.wantsRunEvents()) return;
 		this.currentRunId = randomUUID();
 		this.moduleStartedAt.clear();
@@ -791,6 +831,7 @@ var AgentReporter = class {
 	async onTestRunEnd(testModules, unhandledErrors, reason) {
 		if (this.rendered) return;
 		this.rendered = true;
+		const errors = unhandledErrors;
 		if (this.wantsRunEvents() && this.currentRunId !== null) {
 			let pass = 0;
 			let fail = 0;
@@ -820,11 +861,11 @@ var AgentReporter = class {
 				timeoutCount: timeout,
 				durationMs: totalDuration,
 				// @vitest-agent/ui, which both populate `collectedModules` on their
-				collectedModules: testModules.length
+				collectedModules: testModules.length,
+				...errors.length > 0 && { unhandledErrors: errors }
 			});
 		}
 		const modules = testModules;
-		const errors = unhandledErrors;
 		const opts = this.options;
 		const stashedCoverage = this.coverage;
 		const stashedVitest = this._vitest;
@@ -832,6 +873,31 @@ var AgentReporter = class {
 		const logFile = this.logFile;
 		const runEvents = this.runEvents;
 		const preBuiltReporters = this.reporters;
+		const vitestForPartialCheck = stashedVitest;
+		const startedSpecCount = this.startedSpecCount ?? modules.length;
+		let totalSpecCount = startedSpecCount;
+		try {
+			const specs = await vitestForPartialCheck?.globTestSpecifications?.();
+			if (specs !== void 0) totalSpecCount = specs.length;
+		} catch {}
+		const isPartial = isPartialRun({
+			filenamePattern: vitestForPartialCheck?.filenamePattern,
+			startedSpecCount,
+			totalSpecCount,
+			projectFilter: opts.projectFilter
+		});
+		const testedFiles = isPartial ? Array.from(new Set(modules.map((m) => m.relativeModuleId.replace(/\.test\.([^.]+)$/, ".$1").replace(/\.spec\.([^.]+)$/, ".$1")))) : void 0;
+		if (isPartial) {
+			this.neutralizedThresholdSnapshot = /* @__PURE__ */ new Map();
+			try {
+				const thresholds = (stashedVitest?.coverageProvider)?.options?.thresholds;
+				if (thresholds !== void 0 && typeof thresholds === "object") for (const key of Object.keys(thresholds)) {
+					if (key === "perFile" || key === "autoUpdate" || key === "100") continue;
+					this.neutralizedThresholdSnapshot.set(key, thresholds[key]);
+					delete thresholds[key];
+				}
+			} catch {}
+		}
 		const emitEvent = (event) => {
 			this.emit(event);
 		};
@@ -964,9 +1030,10 @@ var AgentReporter = class {
 				thresholds: opts.coverageThresholds,
 				includeBareZero: opts.includeBareZero,
 				...opts.coverageTargets ? { targets: opts.coverageTargets } : {},
-				...baselines ? { baselines } : {}
+				...baselines ? { baselines } : {},
+				...isPartial ? { totalFiles: totalSpecCount } : {}
 			};
-			const coverageResult = stashedCoverage && isFirstProject ? yield* analyzer.process(stashedCoverage, coverageOpts) : Option.none();
+			const coverageResult = stashedCoverage && isFirstProject ? isPartial ? yield* analyzer.processScoped(stashedCoverage, coverageOpts, testedFiles ?? []) : yield* analyzer.process(stashedCoverage, coverageOpts) : Option.none();
 			const coverageReport = Option.getOrUndefined(coverageResult);
 			if (wantsRunEvents && coverageReport !== void 0) {
 				const globalThresholds = coverageReport.thresholds.global;
@@ -978,9 +1045,12 @@ var AgentReporter = class {
 						file: fc.file,
 						missing: fc.summary,
 						uncoveredLines: fc.uncoveredLines
-					}))
+					})),
+					...coverageReport.scoped ? { scoped: coverageReport.scoped } : {},
+					...coverageReport.scopedFiles !== void 0 ? { scopedFiles: coverageReport.scopedFiles.length } : {},
+					...coverageReport.totalFiles !== void 0 ? { totalFiles: coverageReport.totalFiles } : {}
 				});
-				for (const metric of [
+				if (!coverageReport.scoped) for (const metric of [
 					"lines",
 					"branches",
 					"functions",
@@ -1029,7 +1099,7 @@ var AgentReporter = class {
 					passed: baseReport.summary.passed,
 					failed: baseReport.summary.failed,
 					skipped: baseReport.summary.skipped,
-					scoped: false,
+					scoped: isPartial,
 					actorType: attribution.actorType,
 					agentId: attribution.agentId,
 					conversationId: attribution.conversationId,
@@ -1311,6 +1381,10 @@ var AgentReporter = class {
 				const newBaselines = computeUpdatedBaselines(baselines, coverageReport.totals, opts.coverageTargets);
 				yield* store.writeBaselines(newBaselines);
 			}
+			if (coverageReport && !coverageReport.scoped) {
+				if (opts.coverageThresholds !== void 0) yield* store.writeThresholds(opts.coverageThresholds);
+				if (opts.coverageTargets !== void 0) yield* store.writeTargets(opts.coverageTargets);
+			}
 			let trendSummary;
 			if (coverageReport && !coverageReport.scoped) {
 				const firstProjectKey = Array.from(projectGroups.keys())[0];

package/utils/discover-projects.js

@@ -2,8 +2,8 @@ import { toPosixPath } from "./to-posix-path.js";
 import { nodeWalkerFs } from "./walker-fs.js";
 import { DefaultDiscoverStrategy } from "./discover-strategy.js";
 import { isTestShapedPackage } from "./is-test-shaped-package.js";
-import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR } from "@vitest-agent/sdk";
 import { isAbsolute, join, normalize, relative } from "node:path";
+import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR } from "@vitest-agent/sdk";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 import { nodeSyncOps } from "@effected/workspaces/node-sync";
 

package/utils/discover-strategy.js

@@ -1,8 +1,8 @@
 import { nodeWalkerFs } from "./walker-fs.js";
 import { findTestFiles } from "./find-test-files.js";
 import { Tag } from "./tag.js";
-import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX, TEST_HELPER_DIRS } from "@vitest-agent/sdk";
 import { join, sep } from "node:path";
+import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX, TEST_HELPER_DIRS } from "@vitest-agent/sdk";
 import { configDefaults } from "vitest/config";
 
 //#region src/utils/discover-strategy.ts

package/utils/find-test-files.js

@@ -1,7 +1,7 @@
 import { toPosixPath } from "./to-posix-path.js";
 import { nodeWalkerFs } from "./walker-fs.js";
-import { NON_DISCOVERABLE_DIRS } from "@vitest-agent/sdk";
 import { join, relative } from "node:path";
+import { NON_DISCOVERABLE_DIRS } from "@vitest-agent/sdk";
 
 //#region src/utils/find-test-files.ts
 function globToRegex(pattern) {

package/utils/is-partial-run.js

@@ -0,0 +1,26 @@
+//#region src/utils/is-partial-run.ts
+/**
+* Pure decision function: was this Vitest run scoped to a subset of the
+* project's test files?
+*
+* @remarks
+* A run is partial when any of the following holds:
+* - Vitest's `filenamePattern` was set (a non-empty array) for this run.
+* - Fewer specifications started than exist in total for the same project set.
+* - An explicit `--project` filter was supplied.
+*
+* Any of these makes coverage's whole-project denominator meaningless for
+* threshold enforcement (issue #160).
+*
+* @public
+*/
+function isPartialRun(input) {
+	const { filenamePattern, startedSpecCount, totalSpecCount, projectFilter } = input;
+	if (filenamePattern !== void 0 && filenamePattern.length > 0) return true;
+	if (startedSpecCount < totalSpecCount) return true;
+	if (projectFilter !== void 0) return true;
+	return false;
+}
+
+//#endregion
+export { isPartialRun };

package/utils/is-test-shaped-package.js

@@ -1,7 +1,7 @@
 import { nodeWalkerFs } from "./walker-fs.js";
 import { findTestFiles } from "./find-test-files.js";
-import { SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX } from "@vitest-agent/sdk";
 import { join } from "node:path";
+import { SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX } from "@vitest-agent/sdk";
 
 //#region src/utils/is-test-shaped-package.ts
 /**

package/utils/process-failure.js

@@ -1,5 +1,5 @@
-import { computeFailureSignature, findFunctionBoundary } from "@vitest-agent/sdk";
 import { readFileSync } from "node:fs";
+import { computeFailureSignature, findFunctionBoundary } from "@vitest-agent/sdk";
 
 //#region src/utils/process-failure.ts
 const FRAME_LINE_REGEX = /^\s*at\s+(?:([\w$.<>[\] ]+?)\s+)?\(?([^\n)]+):(\d+):(\d+)\)?\s*$/;

package/utils/resolve-coverage-dir-isolation.js

@@ -0,0 +1,44 @@
+//#region src/utils/resolve-coverage-dir-isolation.ts
+/**
+* Values of `VITEST_AGENT_COVERAGE_DIR_ISOLATION` that opt out of the
+* per-process coverage directory rewrite.
+*/
+const OPT_OUT_VALUES = /* @__PURE__ */ new Set([
+	"off",
+	"0",
+	"false"
+]);
+/**
+* Pure decision function: should this Vitest run's `coverage.reportsDirectory`
+* be isolated to a per-process temp directory?
+*
+* @remarks
+* Two concurrent plain-CLI `vitest run` invocations in one checkout share
+* `coverage.reportsDirectory` by default; the v8 provider's `clean: true`
+* default `rm -rf`s that directory at run start, so one run can delete the
+* other's `.tmp` files mid-run (issue #194). The MCP `run_tests` path
+* already isolates via `makeCoverageDirOverride()`; this function drives
+* the equivalent decision for the plain-CLI (`AgentPlugin.configureVitest`)
+* path.
+*
+* Only the `agent` executor is ever isolated — a human's `./coverage`
+* artifacts, and CI's configured directory, are never relocated.
+*
+* @public
+*/
+function resolveCoverageDirIsolation(input) {
+	const { executor, coverageEnabled, env } = input;
+	if (!coverageEnabled) return { kind: "keep" };
+	if (executor !== "agent") return { kind: "keep" };
+	const isolationOverride = env.VITEST_AGENT_COVERAGE_DIR_ISOLATION;
+	if (isolationOverride !== void 0 && OPT_OUT_VALUES.has(isolationOverride)) return { kind: "keep" };
+	const explicitDir = env.VITEST_AGENT_COVERAGE_DIR;
+	if (explicitDir !== void 0 && explicitDir.length > 0) return {
+		kind: "explicit",
+		dir: explicitDir
+	};
+	return { kind: "isolate" };
+}
+
+//#endregion
+export { resolveCoverageDirIsolation };

package/utils/run-script-lock.js

@@ -1,7 +1,7 @@
-import { createHash, randomBytes } from "node:crypto";
 import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
 
 //#region src/utils/run-script-lock.ts
 /**