@vitest-agent/plugin 5.6.2 → 6.0.0

package/utils/runs-in-ci.js

@@ -0,0 +1,15 @@
+import { RuntimeEnv } from "@effected/env";
+import { Option } from "effect";
+
+// src/utils/runs-in-ci.ts
+/**
+* Whether the process runs in CI, by `@effected/env`'s `RuntimeEnv` rule: a
+* truthy `GITHUB_ACTIONS`, or a `CI` / `CONTINUOUS_INTEGRATION` that is set,
+* non-empty, and not `false` / `0` (is-in-ci semantics). Reads `process.env`
+* at call time, so the environment in force when the caller runs decides.
+*
+* @internal
+*/
+const runsInCi = () => Option.isSome(RuntimeEnv.fromRecord(process.env).ci);
+
+export { runsInCi };

package/utils/stray-output-capture.js

@@ -1,45 +1,7 @@
-import { STRAY_OUTPUT_SOURCE, isEscapeOnly, makeStrayOutputRecorder } from "@vitest-agent/sdk";
-import { Writable } from "node:stream";
-import { StringDecoder } from "node:string_decoder";
+import { STRAY_OUTPUT_SOURCE, makeStrayOutputRecorder } from "@vitest-agent/sdk";
+import { CliUi } from "@effected/cli/ui";
 
 // src/utils/stray-output-capture.ts
-/**
-* Stray-output capture: a pass-through over Vitest's `Logger.outputStream` /
-* `errorStream`.
-*
-* Why those two streams (vitest\@5.0.0, `src/node/pools/workers/`): the forks
-* and vmForks pools fork each worker with `stdio: "pipe"` and pipe its stdout
-* and stderr into `project.vitest.logger.outputStream` / `errorStream`,
-* captured when the worker is constructed, so every raw byte a worker writes
-* (a grandchild process that inherits the worker's fds included, such as an
-* `execFileSync("git", …)` with default stdio) arrives on them. The threads
-* and vmThreads pools pipe a worker thread's JS-level `process.stdout` /
-* `stderr` the same way, but a child process spawned from a thread inherits
-* the main process's real fds 1/2, so its bytes reach the terminal directly
-* and nothing here can see them. Workers are constructed lazily by the pool,
-* at run time, long after `configureVitest`, so installing there is early
-* enough. The `Logger`'s own `console` was built from the ORIGINAL streams in
-* its constructor, so Vitest's logging bypasses the wrapper; its few direct
-* `outputStream.write` calls are escape-only (cursor show, clear screen),
-* which pass straight through unrecorded.
-*
-* Every byte is recorded (bounded: counts, a few sample lines). While a
-* printer is routed (the reporter's live view is up) and the stream's
-* original destination is the process terminal, bytes are line-buffered and
-* each whole line goes to the printer, which prints it above the live frame;
-* otherwise bytes pass through to the original stream unchanged. The
-* original is whatever stream object the Logger held: under MCP's
-* `run_tests` that is the server's null sink, so worker output still never
-* reaches the JSON-RPC stdout, and it is never routed.
-*/
-/**
-* The most text a stream holds back waiting for a newline. Past it, the held
-* text is routed as a line of its own, so a child that never writes a newline
-* cannot grow the buffer without bound.
-*
-* @internal
-*/
-const MAX_HELD_CHARS = 8192;
 const isCapture = (value) => typeof value === "object" && value !== null && "route" in value && "snapshot" in value;
 /**
 * The capture installed on `logger`, if any.
@@ -51,42 +13,6 @@ const strayOutputCaptureOf = (logger) => {
 	const value = logger[STRAY_OUTPUT_SOURCE];
 	return isCapture(value) ? value : void 0;
 };
-const DELEGATED = [
-	"isTTY",
-	"columns",
-	"rows",
-	"getColorDepth",
-	"hasColors",
-	"getWindowSize"
-];
-var StrayStream = class extends Writable {
-	original;
-	take;
-	constructor(original, take) {
-		super({ decodeStrings: false });
-		this.original = original;
-		this.take = take;
-		for (const key of DELEGATED) {
-			if (!(key in original)) continue;
-			Object.defineProperty(this, key, {
-				configurable: true,
-				enumerable: true,
-				get: () => {
-					const value = original[key];
-					return typeof value === "function" ? value.bind(original) : value;
-				}
-			});
-		}
-	}
-	_write(chunk, encoding, callback) {
-		try {
-			this.take(chunk, encoding);
-			callback();
-		} catch (err) {
-			callback(err instanceof Error ? err : new Error(String(err)));
-		}
-	}
-};
 /**
 * Wrap `logger`'s output and error streams with the stray-output capture, once
 * per Logger (a second call returns the first capture). The capture is
@@ -103,67 +29,41 @@ const installStrayOutputCapture = (logger, terminal) => {
 	const existing = strayOutputCaptureOf(logger);
 	if (existing !== void 0) return existing;
 	const recorder = makeStrayOutputRecorder();
-	const originals = {
-		stdout: logger.outputStream,
-		stderr: logger.errorStream
-	};
-	const decoders = {
-		stdout: new StringDecoder("utf8"),
-		stderr: new StringDecoder("utf8")
-	};
-	const held = {
-		stdout: "",
-		stderr: ""
-	};
 	let printer;
-	const flushHeld = (stream) => {
-		const text = held[stream];
-		if (text === "") return;
-		held[stream] = "";
-		originals[stream].write(text);
+	const print = (stream, line) => printer?.(stream, line) ?? false;
+	const wrap = (stream, original) => {
+		const routed = CliUi.routeStream(original, print, {
+			stream,
+			onText: (text) => recorder.write(stream, text)
+		});
+		routed.route(false);
+		return routed;
 	};
-	const take = (stream) => (chunk, encoding) => {
-		const original = originals[stream];
-		if (typeof chunk === "string" && isEscapeOnly(chunk)) {
-			original.write(chunk, encoding);
-			return;
-		}
-		const text = typeof chunk === "string" ? chunk : decoders[stream].write(chunk);
-		recorder.write(stream, text);
-		const route = printer !== void 0 && original === terminal[stream] ? printer : void 0;
-		if (route === void 0) {
-			original.write(chunk, encoding);
-			return;
+	const streams = {
+		stdout: {
+			original: logger.outputStream,
+			routed: wrap("stdout", logger.outputStream)
+		},
+		stderr: {
+			original: logger.errorStream,
+			routed: wrap("stderr", logger.errorStream)
 		}
-		const lines = (held[stream] + text).split("\n");
-		const rest = lines.pop() ?? "";
-		if (rest.length > 8192) {
-			lines.push(rest);
-			held[stream] = "";
-		} else held[stream] = rest;
-		for (const line of lines) if (!route(stream, line)) original.write(`${line}\n`);
-	};
-	const flushHeldThrough = (stream) => {
-		const text = held[stream];
-		if (text === "") return;
-		held[stream] = "";
-		if (printer === void 0 || !printer(stream, text)) originals[stream].write(text);
 	};
-	logger.outputStream = new StrayStream(originals.stdout, take("stdout"));
-	logger.errorStream = new StrayStream(originals.stderr, take("stderr"));
+	logger.outputStream = streams.stdout.routed.writable;
+	logger.errorStream = streams.stderr.routed.writable;
 	const capture = {
 		snapshot: recorder.snapshot,
 		reset: recorder.reset,
 		route: (next) => {
-			if (next === void 0) {
-				flushHeld("stdout");
-				flushHeld("stderr");
-			}
 			printer = next;
+			for (const name of ["stdout", "stderr"]) {
+				const { original, routed } = streams[name];
+				routed.route(next !== void 0 && original === terminal[name]);
+			}
 		},
 		flush: () => {
-			flushHeldThrough("stdout");
-			flushHeldThrough("stderr");
+			streams.stdout.routed.flush();
+			streams.stderr.routed.flush();
 		}
 	};
 	Object.defineProperty(logger, STRAY_OUTPUT_SOURCE, {
@@ -173,4 +73,4 @@ const installStrayOutputCapture = (logger, terminal) => {
 	return capture;
 };
 
-export { MAX_HELD_CHARS, installStrayOutputCapture, strayOutputCaptureOf };
+export { installStrayOutputCapture, strayOutputCaptureOf };

package/utils/vitest-diagnostics.js

@@ -0,0 +1,173 @@
+// src/utils/vitest-diagnostics.ts
+/**
+* Ported from vitest@5.0.5 packages/vitest/src/node/reporters/diagnostics.ts
+* and base.ts (report*Diagnostic). Not exported by Vitest; replace with the
+* public export when available. Re-check on every Vitest bump.
+*
+* The functions below diagnostics.ts's are kept verbatim (names, thresholds,
+* arithmetic). `getIsolateDiagnostic` is the computation extracted from
+* `BaseReporter.reportIsolateDiagnostic` (its watch / flag gating stays with
+* the caller), and `formatTime` is ported from
+* packages/vitest/src/node/reporters/renderers/utils.ts.
+*
+* @packageDocumentation
+*/
+const DOM_ENVIRONMENTS = /* @__PURE__ */ new Set(["jsdom", "happy-dom"]);
+/** Minimum summed environment setup time before the hint is worth printing. */
+const MIN_ENVIRONMENT_TIME = 2e3;
+/** Minimum share of the project's tracked time spent setting up environments. */
+const MIN_ENVIRONMENT_SHARE = .25;
+/**
+* A hint has to be worth acting on: the estimated saving must be noticeable.
+* Run-to-run noise of real suites is commonly a few percent, so anything below
+* ~5% of the wall time cannot even be confirmed by trying the change - except
+* on long runs, where 10 seconds is worth attention regardless of percentage.
+* @internal
+*/
+function isSavingWorthHinting(saving, executionTime) {
+	if (saving < 250) return false;
+	return saving >= executionTime * .05 || saving >= 1e4;
+}
+/** Minimum summed import time before the hint is worth printing. */
+const MIN_IMPORT_TIME = 2e3;
+/** Minimum share of the project's tracked time spent importing modules. */
+const MIN_IMPORT_SHARE = .25;
+/**
+* Minimum fraction of module fetches that re-evaluate an already evaluated
+* module. Below this the test files import mostly disjoint graphs and
+* reusing workers would not meaningfully reduce the import work.
+*/
+const MIN_IMPORT_DUPLICATION = .2;
+/**
+* Detects projects where test files repeatedly evaluate the same module
+* graph. Typical for barrel-file imports: every test file pulls hundreds of
+* shared modules to use a few of them, and `isolate: true` re-evaluates that
+* graph for every file. The duplication is measured from the server-side
+* fetch counts, so suites with disjoint per-file graphs - where reusing
+* workers would not help - stay quiet.
+* @internal
+*/
+function getImportDiagnostics(projects) {
+	const diagnostics = [];
+	for (const project of projects) {
+		if (project.pool !== "forks" && project.pool !== "threads" || !project.isolate || project.isolateProvided || project.browser || project.fileCount <= project.parallelism || project.importTime < MIN_IMPORT_TIME || project.trackedTime <= 0 || project.importTime / project.trackedTime < MIN_IMPORT_SHARE) continue;
+		const parallelism = Math.max(1, project.parallelism);
+		let totalFetches = 0;
+		let avoidableFetches = 0;
+		for (const count of project.fetchCounts) {
+			totalFetches += count;
+			avoidableFetches += Math.max(0, count - parallelism);
+		}
+		if (totalFetches === 0) continue;
+		const duplication = avoidableFetches / totalFetches;
+		if (duplication < MIN_IMPORT_DUPLICATION) continue;
+		const estimatedSaving = project.importTime * duplication / parallelism;
+		if (!isSavingWorthHinting(estimatedSaving, project.executionTime)) continue;
+		diagnostics.push({
+			name: project.name,
+			importTime: project.importTime,
+			share: project.importTime / project.trackedTime,
+			totalFetches,
+			uniqueModules: project.fetchCounts.length,
+			duplication,
+			estimatedSaving
+		});
+	}
+	return diagnostics;
+}
+/**
+* Estimates the wall-clock time saved by evaluating shared modules once per
+* worker instead of once per test file. `moduleSelfTimes` holds, per module,
+* the module's own evaluation time in every test file that evaluated it.
+* Reused workers keep ~`parallelism` evaluations of each module (one per
+* lane); the rest of the summed time is avoidable and spread across the
+* lanes.
+* @internal
+*/
+function estimateModuleEvaluationSaving(moduleSelfTimes, parallelism) {
+	const lanes = Math.max(1, parallelism);
+	let avoidable = 0;
+	for (const times of moduleSelfTimes) {
+		if (times.length <= lanes) continue;
+		let sum = 0;
+		for (const time of times) sum += time;
+		avoidable += sum * (times.length - lanes) / times.length;
+	}
+	return avoidable / lanes;
+}
+/** Minimum summed transform time before the hint is worth printing. */
+const MIN_TRANSFORM_TIME = 2e3;
+/** Minimum share of the project's tracked time spent transforming modules. */
+const MIN_TRANSFORM_SHARE = .25;
+/**
+* Detects projects that spend the run transforming modules. Without the fs
+* module cache every `vitest run` starts from scratch and transforms the
+* whole module graph again; `fsModuleCache` persists the results on disk so
+* repeated runs skip them.
+* @internal
+*/
+function getTransformDiagnostics(projects) {
+	return projects.filter((project) => {
+		if (project.fsModuleCache || project.fsModuleCacheProvided || project.transformTime < MIN_TRANSFORM_TIME || project.trackedTime <= 0 || project.transformTime / project.trackedTime < MIN_TRANSFORM_SHARE) return false;
+		return isSavingWorthHinting(project.transformTime, project.executionTime);
+	}).map((project) => ({
+		name: project.name,
+		transformTime: project.transformTime,
+		share: project.transformTime / project.trackedTime
+	}));
+}
+/**
+* Detects projects where re-creating a DOM environment for every test file
+* dominates the run. With an isolating pool the environment is set up once
+* per file; `vmThreads`/`vmForks` set it up once per worker while still
+* giving every file a fresh VM context.
+* @internal
+*/
+function getEnvironmentDiagnostics(projects) {
+	return projects.filter((project) => {
+		if (!DOM_ENVIRONMENTS.has(project.environment) || project.pool !== "forks" && project.pool !== "threads" || !project.isolate || project.browser || project.poolProvided || project.environmentCount <= 1 || project.environmentTime < MIN_ENVIRONMENT_TIME || project.trackedTime <= 0 || project.environmentTime / project.trackedTime < MIN_ENVIRONMENT_SHARE) return false;
+		const parallelism = Math.max(1, project.parallelism);
+		return isSavingWorthHinting(project.environmentTime / parallelism - project.environmentTime / project.environmentCount, project.executionTime);
+	}).map((project) => ({
+		name: project.name,
+		environment: project.environment,
+		environmentTime: project.environmentTime,
+		environmentCount: project.environmentCount,
+		share: project.environmentTime / project.trackedTime,
+		suggestIsolate: !project.isolateProvided
+	}));
+}
+/**
+* Vitest's duration formatting (renderers/utils.ts `formatTime`).
+* @internal
+*/
+function formatTime(time) {
+	if (time > 1e3) return `${(time / 1e3).toFixed(2)}s`;
+	return `${Math.round(time)}ms`;
+}
+/**
+* Surfaces the cost of `isolate: true`: with isolation enabled Vitest spawns a
+* fresh worker (and re-creates the test environment) for every test file.
+* Extracted from `BaseReporter.reportIsolateDiagnostic`.
+* @internal
+*/
+function getIsolateDiagnostic(input) {
+	const numWorkers = input.numWorkers;
+	if (!numWorkers || !input.isolates) return;
+	const startupTime = input.startupTime;
+	const avgStartup = startupTime / numWorkers;
+	const parallelism = Math.max(1, Math.min(input.numFiles, input.maxWorkers));
+	if (numWorkers <= parallelism) return;
+	const wallStartup = startupTime / parallelism;
+	const moduleSavings = input.measuresModules ? estimateModuleEvaluationSaving(input.moduleSelfTimes, parallelism) : 0;
+	const estimatedSaving = wallStartup - avgStartup + moduleSavings;
+	if (!isSavingWorthHinting(estimatedSaving, input.executionTime)) return;
+	return {
+		numWorkers,
+		avgStartup,
+		estimatedSaving,
+		measuresModules: input.measuresModules
+	};
+}
+
+export { estimateModuleEvaluationSaving, formatTime, getEnvironmentDiagnostics, getImportDiagnostics, getIsolateDiagnostic, getTransformDiagnostics, isSavingWorthHinting };

package/utils/walker-fs.js

@@ -1,26 +1,11 @@
-import { readdir, stat } from "node:fs/promises";
-
 // src/utils/walker-fs.ts
-/**
-* {@link WalkerFileSystem} over `node:fs/promises` — the binding every
-* production call site uses, and the default when a walker is called without
-* an explicit port.
-* @public
-*/
-const nodeWalkerFs = {
-	readDirectory: async (dir) => await readdir(dir, { withFileTypes: true }),
-	statEntry: async (path) => {
-		try {
-			const info = await stat(path);
-			return {
-				isFile: info.isFile(),
-				isDirectory: info.isDirectory(),
-				mtimeMs: info.mtimeMs
-			};
-		} catch {
-			return null;
-		}
+/** `stat` of `path`, links followed, or `null` when it is missing or unreadable. */
+function statOrNull(ops, path) {
+	try {
+		return ops.fileSystem.stat(path);
+	} catch {
+		return null;
 	}
-};
+}
 
-export { nodeWalkerFs };
+export { statOrNull };

package/version.js

@@ -8,6 +8,6 @@
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "5.6.2";
+const CURRENT_PLUGIN_VERSION = "6.0.0";
 
 export { CURRENT_PLUGIN_VERSION };