@vitest-agent/plugin 4.0.3 → 4.0.4

package/index.d.ts

@@ -693,6 +693,22 @@ export declare class AgentReporter {
    * @internal
    */
   private neutralizedThresholdSnapshot;
+  /**
+   * Snapshot of `vitest.configOverride.testNamePattern` taken once, at
+   * `onInit`. Vitest's own startup copy of the RESOLVED `testNamePattern`
+   * (merging `vitest.config.ts`'s `test.testNamePattern` with any `-t`
+   * flag) into `configOverride` runs before any reporter's `onInit`
+   * (Vitest 5.0 `Vitest._setServer`), so this snapshot always observes it.
+   * Compared against the same field read again at `onTestRunEnd` — a
+   * difference means a watch-mode `t` keypress (`Vitest.changeNamePattern`)
+   * ran in between; no difference means the pattern, if any, was already
+   * baked into the resolved config (issue #401 regression: a project-level
+   * `testNamePattern` must not make every run partial). See
+   * `hasTestNameFilter` in `utils/is-partial-run.ts` for the decision rule.
+   *
+   * @internal
+   */
+  private initialTestNamePattern;
   constructor(options?: AgentReporterConstructorOptions);
   /**
    * The resolved reporter config built at construction time. Exposed for
@@ -761,8 +777,8 @@ export declare class AgentReporter {
    */
   onTestRunStart(_specifications: ReadonlyArray<unknown>): void;
   /**
-   * Read the owning Vitest project name off a `TestModule`. Vitest 4.x
-   * attaches `project` to every module; an empty name (the unnamed
+   * Read the owning Vitest project name off a `TestModule`. Vitest 5
+   * attaches `project` to every module (`reported-tasks.ts`); an empty name (the unnamed
    * default project) collapses to `undefined` so the renderer treats it
    * as a single anonymous project.
    *
@@ -1236,6 +1252,20 @@ interface CoverageOptions {
    * "N of M test files" instead of just "N".
    */
   readonly totalFiles?: number;
+  /**
+   * The Vitest config root. When set, every coverage-map key is matched
+   * against threshold / target glob patterns as `relative(root, key)` —
+   * the shape Vitest's own threshold evaluator globs on. The v8 and
+   * istanbul providers key the map by ABSOLUTE path, so without this a
+   * relative pattern like `src/**\/*.ts` never matches. Absent, keys are
+   * matched verbatim. Reported `file` fields keep the map's original key.
+   *
+   * `root` does NOT apply to `processScoped`'s `testedFiles`: those are
+   * compared against the map key with only separators normalized, so
+   * callers pass the same shape the provider uses (absolute paths in
+   * production; forward or back slashes both work).
+   */
+  readonly root?: string;
 }
 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

@@ -1,6 +1,9 @@
 import { CoverageAnalyzer } from "../services/CoverageAnalyzer.js";
+import { toPosixPath } from "../utils/to-posix-path.js";
+import { relative } from "node:path";
 import { compressLines } from "@vitest-agent/sdk";
-import { Effect, Layer, Option } from "effect";
+import { Effect, Layer, Option, Result } from "effect";
+import { GlobPattern } from "@effected/glob";
 
 //#region src/layers/CoverageAnalyzerLive.ts
 /**
@@ -23,12 +26,29 @@ function isIstanbulCoverageMap(value) {
 	return typeof obj.getCoverageSummary === "function" && typeof obj.files === "function" && typeof obj.fileCoverageFor === "function";
 }
 /**
-* Match a file path against a glob pattern using basic matching.
-* Supports `*` (any segment chars) and `**` (any path segments).
+* Compiled matchers keyed by pattern source. Threshold patterns are a
+* small, fixed set per run and `processCoverageInternal` matches every
+* file against every pattern, so compile once and reuse.
+*/
+const globCache = /* @__PURE__ */ new Map();
+/**
+* Match a file path against a coverage-threshold glob with the same
+* semantics Vitest applies to `coverage.thresholds` keys (picomatch under
+* default options): `**` spans zero or more directories, `*` and `?`
+* never cross a slash, brace groups expand, character classes and
+* extglobs work, and dotfiles are not matched by wildcards (issue #381).
+* `@effected/glob` is minimatch-based and agrees with picomatch on every
+* shape a threshold key realistically takes. A pattern that fails to
+* compile (guard trip on an absurd input) matches nothing.
 */
 function matchGlob(filePath, pattern) {
-	const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*").replace(/\?/g, "[^/]");
-	return new RegExp(`^${regexStr}$`).test(filePath);
+	let compiled = globCache.get(pattern);
+	if (compiled === void 0) {
+		const result = GlobPattern.compileResult(pattern);
+		compiled = Result.isSuccess(result) ? result.success : null;
+		globCache.set(pattern, compiled);
+	}
+	return compiled?.matches(filePath) ?? false;
 }
 /**
 * Resolve the effective thresholds for a file path by checking pattern
@@ -85,10 +105,13 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		functions: summary.functions.pct,
 		lines: summary.lines.pct
 	};
-	const testedFileSet = testedFiles ? new Set(testedFiles) : void 0;
+	const testedFileSet = testedFiles ? new Set(testedFiles.map(toPosixPath)) : void 0;
 	const lowCoverage = [];
 	const belowTarget = [];
+	const { root } = options;
+	const matchKey = (filePath) => toPosixPath(root === void 0 ? filePath : relative(root, filePath));
 	for (const filePath of coverageMap.files()) {
+		const matchPath = matchKey(filePath);
 		const fileCoverage = coverageMap.fileCoverageFor(filePath);
 		const fileSummary = fileCoverage.toSummary();
 		const fileStats = {
@@ -99,8 +122,8 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 		};
 		const isBareZero = fileStats.statements === 0 && fileStats.branches === 0 && fileStats.functions === 0 && fileStats.lines === 0;
 		if (isBareZero && !includeBareZero) continue;
-		if (scoped && !testedFileSet?.has(filePath)) continue;
-		const isBelowThreshold = isBelowMetricThresholds(fileStats, resolveEffectivePerFileThresholds(filePath, options.thresholds) ?? resolveEffectiveThresholds(filePath, options.thresholds));
+		if (scoped && !testedFileSet?.has(toPosixPath(filePath))) continue;
+		const isBelowThreshold = isBelowMetricThresholds(fileStats, resolveEffectivePerFileThresholds(matchPath, options.thresholds) ?? resolveEffectiveThresholds(matchPath, options.thresholds));
 		if (isBareZero || isBelowThreshold) {
 			const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
 			lowCoverage.push({
@@ -111,7 +134,7 @@ function processCoverageInternal(coverageMap, options, testedFiles) {
 			continue;
 		}
 		if (options.targets) {
-			if (isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(filePath, options.targets))) {
+			if (isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(matchPath, options.targets))) {
 				const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
 				belowTarget.push({
 					file: filePath,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "4.0.3",
+	"version": "4.0.4",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -44,13 +44,13 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.115",
-		"@effect/sql-sqlite-node": "4.0.0-rc.115",
+		"@effected/glob": "^0.6.0",
 		"@effected/workspaces": "^0.22.0",
-		"@vitest-agent/cli": "3.0.2",
-		"@vitest-agent/engine": "0.1.2",
-		"@vitest-agent/mcp": "4.0.2",
-		"@vitest-agent/reporter": "3.0.5",
-		"@vitest-agent/sdk": "5.0.0",
+		"@vitest-agent/cli": "3.0.3",
+		"@vitest-agent/engine": "0.1.3",
+		"@vitest-agent/mcp": "4.0.3",
+		"@vitest-agent/reporter": "3.0.6",
+		"@vitest-agent/sdk": "5.0.1",
 		"effect": "4.0.0-rc.115",
 		"magic-string": "^1.4.1"
 	},

package/plugin.js

@@ -40,16 +40,22 @@ import { Effect, Schema } from "effect";
 *   the dedicated `ci-annotations` reporter is opt-in until the GHA
 *   annotations writer ships).
 *
+* An invalid `VITEST_AGENT_CONSOLE` value is ignored with a diagnostic
+* line sent to `report` (default: `process.stderr`). `configureVitest`
+* passes the per-Vitest-instance dedupe sink so the line prints once per
+* run rather than once per project (issue #459).
+*
 * @internal
 */
-function resolveConsoleMode(options, executor, _env) {
+function resolveConsoleMode(options, executor, _env, report = (line) => {
+	process.stderr.write(line);
+}) {
 	const override = process.env.VITEST_AGENT_CONSOLE;
 	if (override !== void 0 && override !== "") {
 		if (executor === "human" && Schema.is(HumanConsoleMode)(override)) return override;
 		if (executor === "agent" && Schema.is(AgentConsoleMode)(override)) return override;
 		if (executor !== "human" && executor !== "agent" && Schema.is(CiConsoleMode)(override)) return override;
-		const accepted = executor === "human" ? HumanConsoleMode.literals : executor === "agent" ? AgentConsoleMode.literals : CiConsoleMode.literals;
-		process.stderr.write(`[vitest-agent:plugin] ignoring invalid VITEST_AGENT_CONSOLE="${override}" for ${executor} executor; accepted for ${executor}: ${accepted.join(" | ")}\n`);
+		report(`[vitest-agent:plugin] ignoring invalid VITEST_AGENT_CONSOLE="${override}" for ${executor} executor; accepted for ${executor}: ${(executor === "human" ? HumanConsoleMode.literals : executor === "agent" ? AgentConsoleMode.literals : CiConsoleMode.literals).join(" | ")}\n`);
 	}
 	const console = options.console;
 	if (executor === "human") return console?.human ?? "passthrough";
@@ -120,6 +126,20 @@ const cacheKeyGeneratorByVitest = /* @__PURE__ */ new WeakSet();
 */
 const coverageDirDecidedByVitest = /* @__PURE__ */ new WeakSet();
 /**
+* Per-Vitest-instance memory of which `ConfigValidation` diagnostic lines
+* have already been written to stderr (issue #400). `configureVitest` fires
+* once per project, but `ConfigValidation` runs against root-level Vitest
+* config that is identical across every project in the run — without this
+* guard, an N-project run prints N identical copies of every warning/info
+* line. Keyed on the vitest instance (like its `WeakSet` siblings above) so
+* a different Vitest run in the same process gets a fresh, empty `Set` and
+* reports again; the dedupe key is the fully rendered line (code + message
+* + remediation), matching what actually reaches stderr.
+*
+* @internal
+*/
+const reportedConfigDiagnosticsByVitest = /* @__PURE__ */ new WeakMap();
+/**
 * 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
@@ -127,7 +147,7 @@ const coverageDirDecidedByVitest = /* @__PURE__ */ new WeakSet();
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "4.0.3";
+const CURRENT_PLUGIN_VERSION = "4.0.4";
 const TEST_FILE_DIR_RE = new RegExp(`/(?:${SRC_DIR}|${TEST_DIR})/`);
 const isTestFile = (id) => isTestFileName(id) && TEST_FILE_DIR_RE.test(id);
 /**
@@ -209,7 +229,17 @@ function AgentPlugin(options = {}, _layer) {
 				const reportOption = options.report;
 				const reportScope = reportOption === false ? void 0 : executor === "human" && reportOption === void 0 ? void 0 : reportOption?.scope ?? "vitest-agent";
 				if (reportScope !== void 0) assertFlatScope(reportScope);
-				const consoleMode = resolveConsoleMode(options, executor, env);
+				let reportedDiagnostics = reportedConfigDiagnosticsByVitest.get(vitest);
+				if (!reportedDiagnostics) {
+					reportedDiagnostics = /* @__PURE__ */ new Set();
+					reportedConfigDiagnosticsByVitest.set(vitest, reportedDiagnostics);
+				}
+				const reportOnce = (line) => {
+					if (reportedDiagnostics.has(line)) return;
+					reportedDiagnostics.add(line);
+					process.stderr.write(line);
+				};
+				const consoleMode = resolveConsoleMode(options, executor, env, reportOnce);
 				const format = resolveFormat(consoleMode);
 				const mcp = executor === "agent";
 				log("env:", env, "| executor:", executor, "| consoleMode:", consoleMode, "| format:", format, "| mcp (auto):", mcp);
@@ -234,8 +264,8 @@ function AgentPlugin(options = {}, _layer) {
 					vitestConfig: vitest.config,
 					pluginOptions: options
 				})), ConfigValidationLive));
-				for (const w of validation.warnings) process.stderr.write(`[vitest-agent:plugin] warning ${w.code}: ${w.message}` + (w.remediation ? `\n  ${w.remediation}` : "") + "\n");
-				for (const i of validation.info) process.stderr.write(`[vitest-agent:plugin] info ${i.code}: ${i.message}\n`);
+				for (const w of validation.warnings) reportOnce(`[vitest-agent:plugin] warning ${w.code}: ${w.message}` + (w.remediation ? `\n  ${w.remediation}` : "") + "\n");
+				for (const i of validation.info) reportOnce(`[vitest-agent:plugin] info ${i.code}: ${i.message}\n`);
 				if (validation.errors.length > 0) {
 					const body = validation.errors.map((e) => `${e.code}${e.path ? ` @ ${e.path}` : ""}: ${e.message}` + (e.remediation ? `\n  ${e.remediation}` : "")).join("\n");
 					throw new Error(body);

package/reporter.js

@@ -387,6 +387,22 @@ var AgentReporter = class {
 	* @internal
 	*/
 	neutralizedThresholdSnapshot = /* @__PURE__ */ new Map();
+	/**
+	* Snapshot of `vitest.configOverride.testNamePattern` taken once, at
+	* `onInit`. Vitest's own startup copy of the RESOLVED `testNamePattern`
+	* (merging `vitest.config.ts`'s `test.testNamePattern` with any `-t`
+	* flag) into `configOverride` runs before any reporter's `onInit`
+	* (Vitest 5.0 `Vitest._setServer`), so this snapshot always observes it.
+	* Compared against the same field read again at `onTestRunEnd` — a
+	* difference means a watch-mode `t` keypress (`Vitest.changeNamePattern`)
+	* ran in between; no difference means the pattern, if any, was already
+	* baked into the resolved config (issue #401 regression: a project-level
+	* `testNamePattern` must not make every run partial). See
+	* `hasTestNameFilter` in `utils/is-partial-run.ts` for the decision rule.
+	*
+	* @internal
+	*/
+	initialTestNamePattern;
 	constructor(options = {}) {
 		this.logLevel = resolveLogLevel(process.env);
 		this.logFile = resolveLogFile(process.env);
@@ -467,6 +483,7 @@ var AgentReporter = class {
 	*/
 	async onInit(vitest) {
 		this._vitest = vitest;
+		this.initialTestNamePattern = vitest?.configOverride?.testNamePattern;
 		if (this.options.reportScope !== void 0) {
 			assertReportCapable(vitest);
 			this.reportWriter = createReportWriter(vitest, this.options.reportScope);
@@ -611,8 +628,8 @@ var AgentReporter = class {
 		});
 	}
 	/**
-	* Read the owning Vitest project name off a `TestModule`. Vitest 4.x
-	* attaches `project` to every module; an empty name (the unnamed
+	* Read the owning Vitest project name off a `TestModule`. Vitest 5
+	* attaches `project` to every module (`reported-tasks.ts`); an empty name (the unnamed
 	* default project) collapses to `undefined` so the renderer treats it
 	* as a single anonymous project.
 	*
@@ -1055,9 +1072,15 @@ var AgentReporter = class {
 			filenamePattern: vitestForPartialCheck?.filenamePattern,
 			startedSpecCount,
 			totalSpecCount,
-			projectFilter: opts.projectFilter
+			projectFilter: opts.projectFilter,
+			cliFilters: vitestForPartialCheck?.config?.cliOptions,
+			testNamePattern: {
+				cli: vitestForPartialCheck?.config?.cliOptions?.testNamePattern,
+				initial: this.initialTestNamePattern,
+				current: vitestForPartialCheck?.configOverride?.testNamePattern
+			}
 		});
-		const testedFiles = isPartial ? Array.from(new Set(modules.map((m) => m.relativeModuleId.replace(/\.test\.([^.]+)$/, ".$1").replace(/\.spec\.([^.]+)$/, ".$1")))) : void 0;
+		const testedFiles = isPartial ? Array.from(new Set(modules.map((m) => m.moduleId.replace(/\.test\.([^.]+)$/, ".$1").replace(/\.spec\.([^.]+)$/, ".$1")))) : void 0;
 		if (isPartial) {
 			this.neutralizedThresholdSnapshot = /* @__PURE__ */ new Map();
 			try {
@@ -1201,12 +1224,14 @@ var AgentReporter = class {
 			}
 			const primaryProject = Array.from(projectModuleCounts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
 			const isFirstProject = !opts.projectFilter || opts.projectFilter === primaryProject;
+			const coverageRoot = typeof vitestConfig.root === "string" ? vitestConfig.root : void 0;
 			const coverageOpts = {
 				thresholds: opts.coverageThresholds,
 				includeBareZero: opts.includeBareZero,
 				...opts.coverageTargets ? { targets: opts.coverageTargets } : {},
 				...baselines ? { baselines } : {},
-				...isPartial ? { totalFiles: totalSpecCount } : {}
+				...isPartial ? { totalFiles: totalSpecCount } : {},
+				...coverageRoot !== void 0 ? { root: coverageRoot } : {}
 			};
 			const coverageResult = stashedCoverage && isFirstProject ? isPartial ? yield* analyzer.processScoped(stashedCoverage, coverageOpts, testedFiles ?? []) : yield* analyzer.process(stashedCoverage, coverageOpts) : Option.none();
 			const coverageReport = Option.getOrUndefined(coverageResult);

package/utils/is-partial-run.js

@@ -1,5 +1,63 @@
 //#region src/utils/is-partial-run.ts
 /**
+* Stable comparison key for a `configOverride.testNamePattern` value: `""`
+* for `undefined`, otherwise `RegExp#toString()` (`/source/flags`) — two
+* distinct `RegExp` objects constructed from the same pattern compare equal.
+*/
+function testNamePatternKey(pattern) {
+	return pattern === void 0 ? "" : pattern.toString();
+}
+/**
+* Pure decision function: does the `{ cli, initial, current }` snapshot
+* indicate a per-run test-name filter (as opposed to the project's own
+* `vitest.config.ts`-declared `testNamePattern`)?
+*
+* @remarks
+* - When `initial` and `current` differ (by stable key, not identity): the
+*   run is partial iff `current` is truthy — a watch-mode filter was just
+*   applied (partial) or just cleared (full).
+* - When `initial` and `current` are the same: the run is partial iff `cli`
+*   is truthy — a CLI `-t foo` (partial), vs. `-t ""`/unset or a
+*   config-file-only pattern where `cli` is `undefined` (full either way).
+*
+* @public
+*/
+function hasTestNameFilter(input) {
+	if (input === void 0) return false;
+	const { cli, initial, current } = input;
+	if (testNamePatternKey(initial) !== testNamePatternKey(current)) return current !== void 0;
+	return cli !== void 0 && cli !== "";
+}
+/**
+* Pure predicate: does `cliFilters` carry at least one non-empty CLI/
+* programmatic scope filter?
+*
+* @remarks
+* Each field is checked independently so a single unset/empty field never
+* masks another that IS set:
+* - `project` — non-empty array, or non-empty string.
+* - `tagsFilter` — non-empty array.
+* - `changed` — `true`, or a non-empty ref string.
+* - `related` — non-empty array, or non-empty string.
+* - `shard` — any non-empty string.
+*
+* `testNamePattern` is NOT part of {@link CliScopeFilters} — it needs the
+* snapshot-diff rule in {@link hasTestNameFilter}, which {@link isPartialRun}
+* applies separately.
+*
+* @public
+*/
+function hasCliScopeFilter(cliFilters) {
+	if (cliFilters === void 0) return false;
+	const { project, tagsFilter, changed, related, shard } = cliFilters;
+	if (project !== void 0 && project.length > 0) return true;
+	if (tagsFilter !== void 0 && tagsFilter.length > 0) return true;
+	if (changed !== void 0 && changed !== false) return true;
+	if (related !== void 0 && related.length > 0) return true;
+	if (shard !== void 0 && shard.length > 0) return true;
+	return false;
+}
+/**
 * Pure decision function: was this Vitest run scoped to a subset of the
 * project's test files?
 *
@@ -7,7 +65,14 @@
 * 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.
+* - `AgentReporter`'s construction-time `projectFilter` option was set (not
+*   the CLI `--project` flag — see {@link IsPartialRunInput.projectFilter}).
+* - Any recognized CLI/programmatic scope filter is set on `cliFilters`:
+*   `--project`, `--tags-filter`, `--changed`, `--related`, or `--shard`
+*   (issue #401).
+* - {@link hasTestNameFilter} finds a per-run test-name filter (`-t`, or a
+*   watch-mode `t` change) — NOT a permanent `vitest.config.ts`
+*   `testNamePattern`, which is the project's own scope and stays full.
 *
 * Any of these makes coverage's whole-project denominator meaningless for
 * threshold enforcement (issue #160).
@@ -15,12 +80,14 @@
 * @public
 */
 function isPartialRun(input) {
-	const { filenamePattern, startedSpecCount, totalSpecCount, projectFilter } = input;
+	const { filenamePattern, startedSpecCount, totalSpecCount, projectFilter, cliFilters, testNamePattern } = input;
 	if (filenamePattern !== void 0 && filenamePattern.length > 0) return true;
 	if (startedSpecCount < totalSpecCount) return true;
 	if (projectFilter !== void 0) return true;
+	if (hasCliScopeFilter(cliFilters)) return true;
+	if (hasTestNameFilter(testNamePattern)) return true;
 	return false;
 }
 
 //#endregion
-export { isPartialRun };
+export { hasCliScopeFilter, hasTestNameFilter, isPartialRun };