@vitest-agent/plugin 5.1.2 → 5.2.1

package/index.d.ts

@@ -1,3 +1,4 @@
+import "@effected/env";
 import { EnvironmentDetector, PlatformOptions, PlatformServices, SettingsInput, StackFrameInput } from "@vitest-agent/engine";
 import { AgentPluginOptions, AgentReporterOptions, ConsoleMode, CoverageBaselines, CoverageInput, CoverageLevel, CoverageLevelName, CoverageLevelName as CoverageLevelName$1, CoverageReport, OutputFormat, ResolvedReporterConfig, ResolvedThresholds, RunEvent, Transport, VitestAgentReporterFactory, resolveCoverageInput, validateCoverageConfig } from "@vitest-agent/sdk";
 import { Context, Effect, Layer, Option } from "effect";
@@ -693,6 +694,13 @@ export declare class AgentReporter {
    * @internal
    */
   private reporters;
+  /**
+   * The one close of the run-event channel and the reporters, started at
+   * Vitest's close (see `closeReporters`). Undefined until then.
+   *
+   * @internal
+   */
+  private closing;
   /**
    * Whether the user supplied a custom `reporter` factory. A custom
    * reporter may subscribe to the run-event channel in any console mode,
@@ -777,6 +785,18 @@ export declare class AgentReporter {
    * @param vitest - The Vitest instance
    */
   onInit(vitest: unknown): Promise<void>;
+  /**
+   * Close the reporters resolved at `onInit`, then end the run-event
+   * channel, once, at Vitest's close. Reporters first: a live view folds
+   * every event still queued in its subscription and commits its last
+   * frame in `close`, and `PubSub.shutdown` would drop whatever a
+   * subscriber has not taken yet. The shutdown after is harmless to a
+   * closed view and ends any other subscriber. A failing close is logged,
+   * never thrown — Vitest is shutting down.
+   *
+   * @internal
+   */
+  private closeReporters;
   /**
    * Resolve the reporter factory at run start.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "5.1.2",
+	"version": "5.2.1",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -43,15 +43,18 @@
 		"vitest-agent-mcp": "bin/vitest-agent-mcp.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.118",
-		"@effected/glob": "^0.9.0",
-		"@effected/workspaces": "^0.30.3",
-		"@vitest-agent/cli": "3.2.7",
-		"@vitest-agent/engine": "0.3.2",
-		"@vitest-agent/mcp": "5.1.5",
-		"@vitest-agent/reporter": "3.1.3",
-		"@vitest-agent/sdk": "5.1.3",
-		"effect": "4.0.0-rc.118",
+		"@effect/platform-node": "^4.0.0",
+		"@effected/cli": "^0.11.0",
+		"@effected/env": "^0.1.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/walker": "^0.15.0",
+		"@effected/workspaces": "^0.31.0",
+		"@vitest-agent/cli": "4.0.1",
+		"@vitest-agent/engine": "0.5.0",
+		"@vitest-agent/mcp": "5.1.7",
+		"@vitest-agent/reporter": "4.0.1",
+		"@vitest-agent/sdk": "6.0.0",
+		"effect": "^4.0.0",
 		"magic-string": "^1.4.2"
 	},
 	"peerDependencies": {

package/plugin.js

@@ -20,9 +20,11 @@ import { execSync } from "node:child_process";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { EnvironmentDetector, EnvironmentDetectorLive, resolveLogLevel } from "@vitest-agent/engine";
+import { CliLog } from "@effected/cli";
+import { Audience, EnvOverride } from "@effected/env";
+import { EnvironmentDetector, EnvironmentDetectorLive, ExecutorResolver, ExecutorResolverLive, LoggerLive, resolveLogLevel } from "@vitest-agent/engine";
 import { AgentConsoleMode, CiConsoleMode, CoverageLevel, HumanConsoleMode, SRC_DIR, TEST_DIR, formatFatalError, isTestFileName } from "@vitest-agent/sdk";
-import { Effect, Schema } from "effect";
+import { Effect, Layer, Option } from "effect";
 
 //#region src/plugin.ts
 /**
@@ -41,29 +43,53 @@ 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).
+* `VITEST_AGENT_CONSOLE` is read through `@effected/env`'s `EnvOverride`
+* (case-insensitive, per-audience accepted literals), with the executor as
+* the `Audience`. A value the executor does not accept is ignored with one
+* `[vitest-agent:plugin]` diagnostic line, worded here from
+* `EnvOverride.readResult`'s structured rejection and sent to `report`
+* (default: `process.stderr`), never stdout. `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, 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;
-		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 { accepted, rejected } = Effect.runSync(readConsoleOverride.pipe(Effect.provideService(Audience, {
+		kind: executor,
+		source: "detected"
+	})));
+	if (Option.isSome(rejected)) {
+		const { value, audience, accepts } = rejected.value;
+		report(`[vitest-agent:plugin] ignoring VITEST_AGENT_CONSOLE=${value}: not accepted for the ${audience} audience (accepts ${accepts.join("|")})\n`);
 	}
+	if (Option.isSome(accepted)) return accepted.value;
 	const console = options.console;
 	if (executor === "human") return console?.human ?? "passthrough";
 	if (executor === "agent") return console?.agent ?? "agent";
 	return console?.ci ?? "passthrough";
 }
 /**
+* The `VITEST_AGENT_CONSOLE` override for the current `Audience`, without
+* logging: `accepted` is the literal that audience accepts, `rejected` a set
+* value it does not (with the value, the audience and its literals), both
+* `None` when unset or empty. The accepted type is the union of every slot's
+* literals, not the current audience's; the audience check is a runtime one.
+*
+* @internal
+*/
+const readConsoleOverride = EnvOverride.readResult({
+	envVar: "VITEST_AGENT_CONSOLE",
+	source: process.env,
+	accepts: {
+		human: HumanConsoleMode.literals,
+		agent: AgentConsoleMode.literals,
+		ci: CiConsoleMode.literals
+	}
+});
+/**
 * The plugin owns stdout when the resolved console mode produces visible
 * output that would conflict with Vitest's own reporters. Passthrough lets
 * Vitest emit progress normally; silent strips everything; the other modes
@@ -143,19 +169,6 @@ const reportedConfigDiagnosticsByVitest = /* @__PURE__ */ new WeakMap();
 const TEST_FILE_DIR_RE = new RegExp(`/(?:${SRC_DIR}|${TEST_DIR})/`);
 const isTestFile = (id) => isTestFileName(id) && TEST_FILE_DIR_RE.test(id);
 /**
-* Map a detected {@link Environment} to its {@link Executor}. Inline copy
-* of the `ExecutorResolverLive` mapping so the plugin can compute it
-* synchronously inside `configureVitest` without spinning up an Effect
-* runtime.
-*
-* @internal
-*/
-function envToExecutor(env) {
-	if (env === "agent-shell") return "agent";
-	if (env === "terminal") return "human";
-	return "ci";
-}
-/**
 * Wraps `resolvedConfig.logger.warn` in place so the benign Vite
 * "Failed to load source map" / ENOENT `.js.map` noise (GitHub issue #110)
 * never reaches stdout, while every other warning still passes through
@@ -192,7 +205,10 @@ function installViteSourceMapWarningFilter(resolvedConfig) {
 function AgentPlugin(options = {}, _layer) {
 	const layer = _layer ?? EnvironmentDetectorLive(process.env);
 	const logLevel = resolveLogLevel(process.env);
-	const log = logLevel !== void 0 && logLevel !== "None" ? (...args) => process.stderr.write(`[vitest-agent:plugin] ${args.map(String).join(" ")}\n`) : (..._args) => {};
+	const diagnostics = logLevel === "Debug" || logLevel === "Trace" || logLevel === "All" ? LoggerLive(logLevel, void 0, process.env) : void 0;
+	const log = diagnostics ? (...args) => {
+		Effect.runSync(Effect.logDebug(args.map(String).join(" ")).pipe(CliLog.component("vitest-agent:plugin"), Effect.provide(diagnostics)));
+	} : (..._args) => {};
 	const discoverStrategyResolved = options.discoverStrategy === false ? null : options.discoverStrategy ?? new DefaultDiscoverStrategy();
 	const classifyForCache = (id) => {
 		if (!discoverStrategyResolved) return void 0;
@@ -216,8 +232,13 @@ function AgentPlugin(options = {}, _layer) {
 					ctx.defineCacheKeyGenerator(makeTagCacheKeyGenerator(classifyForCache));
 					log("registered fsModuleCache tag cache-key generator");
 				}
-				const env = await Effect.runPromise(Effect.provide(Effect.flatMap(EnvironmentDetector, (d) => d.detect()), layer));
-				const executor = envToExecutor(env);
+				const { env, executor } = await Effect.runPromise(Effect.gen(function* () {
+					const env = yield* (yield* EnvironmentDetector).detect();
+					return {
+						env,
+						executor: yield* (yield* ExecutorResolver).resolve(env)
+					};
+				}).pipe(Effect.provide(Layer.merge(layer, ExecutorResolverLive))));
 				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);
@@ -451,4 +472,4 @@ function makeDiscoverBuilder(options) {
 })(AgentPlugin || (AgentPlugin = {}));
 
 //#endregion
-export { AgentPlugin, CURRENT_PLUGIN_VERSION, makeDiscoverBuilder, resolveConsoleMode };
+export { AgentPlugin, CURRENT_PLUGIN_VERSION, makeDiscoverBuilder, readConsoleOverride, resolveConsoleMode };

package/reporter.js

@@ -7,6 +7,7 @@ import { captureSettings, hashSettings } from "./utils/capture-settings.js";
 import { isPartialRun } from "./utils/is-partial-run.js";
 import { processFailure } from "./utils/process-failure.js";
 import { assertReportCapable, createReportWriter } from "./utils/report-writer.js";
+import { resolveNoColor } from "./utils/resolve-no-color.js";
 import { routeRenderedOutput } from "./utils/route-rendered-output.js";
 import { stringifyFailureValue } from "./utils/stringify-failure-value.js";
 import { mkdirSync, statSync } from "node:fs";
@@ -15,7 +16,7 @@ import { DataReader, DataStore, DetailResolver, EnvironmentDetector, ExecutorRes
 import { buildAgentReport, coerceErrorField, computeTrend, formatFatalError, isTimeoutError, probeHostMetadataFromEnv } from "@vitest-agent/sdk";
 import { Effect, Option, PubSub } from "effect";
 import { randomUUID } from "node:crypto";
-import { NodeServices } from "@effect/platform-node";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { DefaultVitestAgentReporter } from "@vitest-agent/reporter";
 
 //#region src/reporter.ts
@@ -339,6 +340,13 @@ var AgentReporter = class {
 	*/
 	reporters;
 	/**
+	* The one close of the run-event channel and the reporters, started at
+	* Vitest's close (see `closeReporters`). Undefined until then.
+	*
+	* @internal
+	*/
+	closing;
+	/**
 	* Whether the user supplied a custom `reporter` factory. A custom
 	* reporter may subscribe to the run-event channel in any console mode,
 	* so the streaming hooks publish events whenever this is true.
@@ -492,6 +500,36 @@ var AgentReporter = class {
 			await this.ensureDbPath();
 		} catch {}
 		await this.initReporters();
+		const onClose = vitest?.onClose;
+		if (typeof onClose === "function") onClose.call(vitest, () => this.closeReporters());
+	}
+	/**
+	* Close the reporters resolved at `onInit`, then end the run-event
+	* channel, once, at Vitest's close. Reporters first: a live view folds
+	* every event still queued in its subscription and commits its last
+	* frame in `close`, and `PubSub.shutdown` would drop whatever a
+	* subscriber has not taken yet. The shutdown after is harmless to a
+	* closed view and ends any other subscriber. A failing close is logged,
+	* never thrown — Vitest is shutting down.
+	*
+	* @internal
+	*/
+	closeReporters() {
+		this.closing ??= (async () => {
+			await Promise.all((this.reporters ?? []).map(async (reporter) => {
+				try {
+					await reporter.close?.();
+				} catch (err) {
+					process.stderr.write(`vitest-agent: reporter close failed: ${formatFatalError(err)}\n`);
+				}
+			}));
+			try {
+				Effect.runSync(PubSub.shutdown(this.runEvents));
+			} catch (err) {
+				process.stderr.write(`vitest-agent: run-event channel shutdown threw: ${formatFatalError(err)}\n`);
+			}
+		})();
+		return this.closing;
 	}
 	/**
 	* Resolve the reporter factory at run start.
@@ -527,16 +565,17 @@ var AgentReporter = class {
 						hasFailures: false,
 						belowTargets: false,
 						hasTargets: !!opts.coverageTargets
-					}, opts.detail)
+					}, opts.detail),
+					noColor: yield* resolveNoColor
 				};
 			});
-			const { env, executor, format, detail } = await Effect.runPromise(initProgram.pipe(Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer)));
+			const { env, executor, format, detail, noColor } = await Effect.runPromise(initProgram.pipe(Effect.provide(OutputPipelineLive(process.env)), Effect.provide(NodeServices.layer)));
 			const kit = buildReporterKit({
 				env,
 				executor,
 				format,
 				detail,
-				noColor: !!process.env.NO_COLOR,
+				noColor,
 				consoleMode: opts.consoleMode ?? "passthrough",
 				mcp: opts.mcp ?? false,
 				githubActions: opts.githubActions,
@@ -1139,7 +1178,7 @@ var AgentReporter = class {
 					executor,
 					format,
 					detail,
-					noColor: !!process.env.NO_COLOR,
+					noColor: yield* resolveNoColor,
 					consoleMode: opts.consoleMode ?? "passthrough",
 					mcp: opts.mcp ?? false,
 					githubActions: opts.githubActions,
@@ -1191,7 +1230,7 @@ var AgentReporter = class {
 			return;
 		}
 		if (dbPath !== void 0 && persistDisabled === void 0) try {
-			await ensureMigrated(dbPath, logLevel, logFile);
+			await ensureMigrated(dbPath, logLevel, logFile, process.env);
 		} catch (err) {
 			persistDisabled = formatFatalError(err);
 		}
@@ -1691,7 +1730,7 @@ var AgentReporter = class {
 				executor,
 				format,
 				detail,
-				noColor: !!process.env.NO_COLOR,
+				noColor: yield* resolveNoColor,
 				consoleMode: opts.consoleMode ?? "passthrough",
 				mcp: opts.mcp ?? false,
 				githubActions: opts.githubActions,

package/utils/discover-strategy.js

@@ -2,7 +2,9 @@ import { nodeWalkerFs } from "./walker-fs.js";
 import { findTestFiles } from "./find-test-files.js";
 import { Tag } from "./tag.js";
 import { join, sep } from "node:path";
+import { RuntimeEnv } from "@effected/env";
 import { NON_DISCOVERABLE_DIRS, SRC_DIR, TEST_DIR, TEST_FILE_GLOB_SUFFIX, TEST_HELPER_DIRS } from "@vitest-agent/sdk";
+import { Option } from "effect";
 import { configDefaults } from "vitest/config";
 
 //#region src/utils/discover-strategy.ts
@@ -80,12 +82,20 @@ var ConcreteDiscoverStrategy = class ConcreteDiscoverStrategy extends DiscoverSt
 		return new ConcreteDiscoverStrategy(newTags, newClassifyLayers, newBuildProjectLayers);
 	}
 };
-const DEFAULT_TAGS = [
+/**
+* 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). Read when a strategy is
+* constructed rather than at module load, so the environment in force when
+* `AgentPlugin.discover()` runs is the one that decides.
+*/
+const runsInCi = () => Option.isSome(RuntimeEnv.fromRecord(process.env).ci);
+const defaultTags = (inCi) => [
 	Tag.make("unit"),
 	Tag.make("int", { timeout: 6e4 }),
 	Tag.make("e2e", {
 		timeout: 12e4,
-		retry: process.env.CI ? 2 : 0
+		retry: inCi ? 2 : 0
 	})
 ];
 const E2E_RE = /\.e2e\.(test|spec)\.(ts|tsx|js|jsx)$/;
@@ -98,7 +108,7 @@ const INT_RE = /\.int\.(test|spec)\.(ts|tsx|js|jsx)$/;
 * @public
 */
 var DefaultDiscoverStrategy = class extends DiscoverStrategy {
-	tags = DEFAULT_TAGS;
+	tags = defaultTags(runsInCi());
 	get tagDefinitions() {
 		return this.tags.map((t) => t.definition);
 	}

package/utils/resolve-no-color.js

@@ -0,0 +1,13 @@
+import { TerminalEnv } from "@effected/env";
+import { Effect } from "effect";
+
+//#region src/utils/resolve-no-color.ts
+/**
+* Whether the reporter should render without colour, decided by the kit's
+* terminal rule rather than `NO_COLOR` alone: `FORCE_COLOR` beats `NO_COLOR`,
+* and `NODE_DISABLE_COLORS`, `TERM=dumb` and a non-TTY stdout all disable it.
+*/
+const resolveNoColor = TerminalEnv.colorLevel("stdout").pipe(Effect.map((level) => level === "none"));
+
+//#endregion
+export { resolveNoColor };

package/version.js

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