@vitest-agent/plugin 1.0.0

package/plugin.js

@@ -0,0 +1,329 @@
+import { ConfigValidation } from "./services/ConfigValidation.js";
+import { resolveThresholds } from "./utils/resolve-thresholds.js";
+import { ConfigValidationLive } from "./layers/ConfigValidationLive.js";
+import { AgentReporter } from "./reporter.js";
+import { buildModuleInfo } from "./utils/build-module-info.js";
+import { DefaultDiscoverStrategy } from "./utils/discover-strategy.js";
+import { discoverProjects } from "./utils/discover-projects.js";
+import { injectTags } from "./utils/inject-tags.js";
+import { stripConsoleReporters } from "./utils/strip-console-reporters.js";
+import { execSync } from "node:child_process";
+import { CURRENT_REPORTER_VERSION } from "@vitest-agent/reporter";
+import { CURRENT_SDK_VERSION, CoverageLevel, EnvironmentDetector, EnvironmentDetectorLive, formatFatalError, resolveLogLevel } from "@vitest-agent/sdk";
+import { Effect } from "effect";
+
+//#region src/plugin.ts
+/**
+* Resolve which {@link ConsoleMode} value applies to the active executor.
+* Looks up `console.{executor}` in the user-supplied matrix, falls back to
+* the per-slot default.
+*
+* Per-slot defaults:
+* - `human` → `passthrough` (Vitest's own reporters do the visible work).
+*   Users opt into `stream` for the progressively-drawn, animated
+*   agent-shaped live renderer by setting the `human` slot to `"stream"`;
+*   the default reporter owns the live Ink mount end to end (T6 contract
+*   — users do not import or wire the live renderer themselves).
+* - `agent` → `agent` (markdown-flavored final-frame string).
+* - `ci` → `passthrough` (Vitest's reporters produce log-friendly output;
+*   the dedicated `ci-annotations` reporter is opt-in until the GHA
+*   annotations writer ships).
+*
+* @internal
+*/
+function resolveConsoleMode(options, executor, _env) {
+	const console = options.console;
+	if (executor === "human") return console?.human ?? "passthrough";
+	if (executor === "agent") return console?.agent ?? "agent";
+	return console?.ci ?? "passthrough";
+}
+/**
+* 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
+* (stream, agent, ci-annotations) need exclusive stdout access.
+*
+* @internal
+*/
+function ownsStdout(mode) {
+	return mode !== "passthrough";
+}
+/**
+* Map the resolved {@link ConsoleMode} to the legacy {@link OutputFormat}
+* the existing reporter factories switch on. The new event-sourced renderer
+* does not consult this — it dispatches directly on `kit.config.consoleMode`
+* — but the bundled markdown/terminal/silent/ci-annotations reporters still
+* need a format value to pick which formatter to invoke.
+*
+* @internal
+*/
+function resolveFormat(mode) {
+	switch (mode) {
+		case "stream":
+		case "agent": return "terminal";
+		case "ci-annotations": return "ci-annotations";
+		case "silent": return "silent";
+		case "passthrough": return "vitest-bypass";
+	}
+}
+/**
+* Set to the Vitest object reference once we've pushed an aggregating
+* reporter for that Vitest instance. The flag is module-scoped (rather
+* than closure-scoped on the plugin) because Vitest can construct the
+* plugin more than once per `vitest run` invocation (e.g., once per
+* project). Keying the guard on the Vitest reference itself ensures we
+* push exactly one reporter per actual Vitest run, regardless of how
+* many times the plugin or `configureVitest` fires.
+*
+* The terminal/markdown formatters render all projects in one block
+* (Projects header, per-project rows, one Total at the bottom), so we
+* want exactly ONE reporter instance handling the whole run rather than
+* N reporters each rendering their own slice.
+*
+* @internal
+*/
+const aggregatedReporterByVitest = /* @__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
+* the drift-check code path can read it without a circular import.
+*
+* @public
+*/
+const CURRENT_PLUGIN_VERSION = "1.0.0";
+/**
+* Cross-package version drift warning state. Module-scoped so multi-project
+* Vitest configs construct one plugin per project but only emit the
+* warning once per Node process. See the root CLAUDE.md
+* "Cross-package version drift" section.
+*
+* @internal
+*/
+let _hasWarnedDrift = false;
+/**
+* Compare CURRENT_PLUGIN_VERSION against each runtime peer the plugin
+* orchestrates and write one stderr line per mismatch. The check is
+* observation-only — never throws, never exits. Suppressed after the
+* first call in the same process so multi-project Vitest configs do
+* not duplicate the warning.
+*
+* The `"0.0.0"` fallback (from process.env.__PACKAGE_VERSION__ ??
+* "0.0.0" in the constant source) marks a dev build where rslib-builder
+* has not substituted the literal — typically when this module is
+* loaded directly from source rather than from dist. Skip the check
+* in that case; the asymmetry between source-loaded plugin and
+* dist-loaded peers would fire a spurious warning on every dev test
+* run otherwise.
+*
+* @internal
+*/
+function checkVersionDrift(pluginVersion) {
+	if (_hasWarnedDrift) return;
+	if (pluginVersion === "0.0.0") return;
+	const peers = [["@vitest-agent/sdk", CURRENT_SDK_VERSION], ["@vitest-agent/reporter", CURRENT_REPORTER_VERSION]];
+	let warned = false;
+	for (const [peerName, peerVersion] of peers) if (peerVersion !== pluginVersion) {
+		process.stderr.write(`[@vitest-agent/plugin] version drift: @vitest-agent/plugin@${pluginVersion} with ${peerName}@${peerVersion}. Reinstall @vitest-agent/* packages so versions match.\n`);
+		warned = true;
+	}
+	if (warned) _hasWarnedDrift = true;
+}
+const TEST_FILE_SUFFIX_RE = /\.(?:test|spec)\.(?:ts|tsx|js|jsx)$/;
+const TEST_FILE_DIR_RE = /\/(?:src|__test__)\//;
+const isTestFile = (id) => TEST_FILE_SUFFIX_RE.test(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";
+}
+/**
+* Vitest plugin that injects `AgentReporter` into the reporter chain.
+*
+* @param options - Plugin configuration options
+* @param _layer - Internal: override the EnvironmentDetector layer (for testing)
+* @returns Vitest plugin object with `configureVitest` hook
+*
+* @public
+*/
+function AgentPlugin(options = {}, _layer) {
+	checkVersionDrift(CURRENT_PLUGIN_VERSION);
+	const layer = _layer ?? EnvironmentDetectorLive;
+	const logLevel = resolveLogLevel();
+	const log = logLevel !== void 0 && logLevel._tag !== "None" ? (...args) => process.stderr.write(`[vitest-agent:plugin] ${args.map(String).join(" ")}\n`) : (..._args) => {};
+	const discoverStrategyResolved = options.discoverStrategy === false ? null : options.discoverStrategy ?? new DefaultDiscoverStrategy();
+	const pluginObj = {
+		name: "vitest-agent",
+		async configureVitest(ctx) {
+			try {
+				const { vitest, project } = ctx;
+				log("configureVitest called | project:", project?.name ?? "(root)");
+				const env = await Effect.runPromise(Effect.provide(Effect.flatMap(EnvironmentDetector, (d) => d.detect()), layer));
+				const executor = envToExecutor(env);
+				const consoleMode = resolveConsoleMode(options, executor, env);
+				const format = resolveFormat(consoleMode);
+				const mcp = executor === "agent";
+				log("env:", env, "| executor:", executor, "| consoleMode:", consoleMode, "| format:", format, "| mcp (auto):", mcp);
+				if (ownsStdout(consoleMode)) {
+					log("stripping console reporters (consoleMode owns stdout)");
+					const stripped = stripConsoleReporters(vitest.config.reporters);
+					vitest.config.reporters = stripped;
+					const coverageCfg = vitest.config.coverage;
+					if (coverageCfg) {
+						log("suppressing native coverage text reporter");
+						coverageCfg.reporter = [];
+					}
+				}
+				const githubActions = env === "ci-github" && consoleMode !== "silent";
+				log("githubActions (auto):", githubActions);
+				const validation = await Effect.runPromise(Effect.provide(Effect.flatMap(ConfigValidation, (cv) => cv.validate({
+					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`);
+				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);
+				}
+				const coverageConfig = vitest.config.coverage;
+				const coverageThresholds = coverageConfig?.thresholds ? resolveThresholds(coverageConfig.thresholds) : void 0;
+				const rawTargets = options.coverageTargets;
+				const coverageTargets = rawTargets ? resolveThresholds(rawTargets) : void 0;
+				const coverageMode = coverageConfig?.enabled === false ? "ui-only" : "full";
+				const transport = options.transport ?? { kind: "local" };
+				log("transport.kind:", transport.kind);
+				const passWithNoTestsRaw = vitest.config.passWithNoTests;
+				const passWithNoTests = typeof passWithNoTestsRaw === "boolean" ? passWithNoTestsRaw : void 0;
+				log("passWithNoTests (resolved):", passWithNoTests);
+				if (aggregatedReporterByVitest.has(vitest)) {
+					log("aggregate reporter already pushed for this Vitest run; skipping push for project:", project?.name ?? "(root)");
+					return;
+				}
+				const reporter = new AgentReporter({
+					...coverageThresholds !== void 0 ? { coverageThresholds } : {},
+					...coverageTargets !== void 0 ? { coverageTargets } : {},
+					coverageMode,
+					format,
+					consoleMode,
+					mcp,
+					githubActions,
+					transport,
+					...passWithNoTests !== void 0 ? { passWithNoTests } : {},
+					...options.reporter !== void 0 && { reporter: options.reporter },
+					...options.onRunEvent !== void 0 ? { onRunEvent: options.onRunEvent } : {}
+				});
+				vitest.config.reporters.push(reporter);
+				aggregatedReporterByVitest.add(vitest);
+				log("reporters after push:", vitest.config.reporters.length);
+			} catch (err) {
+				process.stderr.write(`vitest-agent: ${formatFatalError(err)}\n`);
+				throw err;
+			}
+		}
+	};
+	if (discoverStrategyResolved) pluginObj.transform = (code, id) => {
+		const cleanId = id.split("?")[0] ?? id;
+		if (!isTestFile(cleanId)) return null;
+		const module = buildModuleInfo(cleanId);
+		const tags = discoverStrategyResolved.classify({ module });
+		if (tags.length === 0) return null;
+		const rewritten = injectTags(code, [...tags]);
+		if (rewritten === null) return null;
+		return rewritten;
+	};
+	return pluginObj;
+}
+const PRESET_METRICS = (level) => ({
+	lines: level.lines,
+	functions: level.functions,
+	branches: level.branches,
+	statements: level.statements
+});
+const buildPreset = (thresholdsLevel, targetsLevel, perFile) => Object.freeze({
+	thresholds: Object.freeze({
+		...PRESET_METRICS(thresholdsLevel),
+		...perFile ? { perFile: true } : {}
+	}),
+	coverageTargets: Object.freeze(PRESET_METRICS(targetsLevel))
+});
+/**
+* Create a concrete {@link DiscoverBuilder} for the given strategy and
+* accumulated additional entries. Calling `.then()` triggers `discoverProjects`
+* with all accumulated options.
+*
+* Process-level cache rule (spec §3.3): caching fires only when no explicit
+* `strategy` is provided AND `additionalEntries` is empty. Any `.addProject()`
+* chain or explicit strategy bypasses the cache.
+*
+* @internal
+*/
+function makeDiscoverBuilder(options) {
+	return {
+		addProject(input) {
+			return makeDiscoverBuilder({
+				...options,
+				additionalEntries: [...options.additionalEntries ?? [], {
+					name: input.name,
+					path: input.path
+				}]
+			});
+		},
+		then(onFulfilled, onRejected) {
+			return discoverProjects(options).then(onFulfilled, onRejected);
+		}
+	};
+}
+(function(_AgentPlugin) {
+	_AgentPlugin.COVERAGE_LEVELS = Object.freeze({
+		none: buildPreset(CoverageLevel.none, CoverageLevel.basic, false),
+		basic: buildPreset(CoverageLevel.basic, CoverageLevel.standard, false),
+		standard: buildPreset(CoverageLevel.standard, CoverageLevel.strict, false),
+		strict: buildPreset(CoverageLevel.strict, CoverageLevel.full, false),
+		full: buildPreset(CoverageLevel.full, CoverageLevel.full, false)
+	});
+	_AgentPlugin.COVERAGE_LEVELS_PER_FILE = Object.freeze({
+		none: buildPreset(CoverageLevel.none, CoverageLevel.basic, true),
+		basic: buildPreset(CoverageLevel.basic, CoverageLevel.standard, true),
+		standard: buildPreset(CoverageLevel.standard, CoverageLevel.strict, true),
+		strict: buildPreset(CoverageLevel.strict, CoverageLevel.full, true),
+		full: buildPreset(CoverageLevel.full, CoverageLevel.full, true)
+	});
+	_AgentPlugin.COVERAGE_AUTOUPDATE = Object.freeze({
+		standard: (n) => Math.floor(n),
+		strict: (n) => Math.ceil(n),
+		lenient: (n) => Math.max(0, Math.floor(n - 2))
+	});
+	function discover(strategy) {
+		if (strategy === void 0) return makeDiscoverBuilder({});
+		if (typeof strategy.buildProject === "function") return makeDiscoverBuilder({ strategy });
+		const opts = strategy;
+		return makeDiscoverBuilder({
+			...opts.strategy !== void 0 ? { strategy: opts.strategy } : {},
+			...opts.cwd !== void 0 ? { cwd: opts.cwd } : {}
+		});
+	}
+	_AgentPlugin.discover = discover;
+	function runScript(command) {
+		try {
+			execSync(command, { stdio: "pipe" });
+		} catch (error) {
+			const execError = error;
+			if (execError.stderr?.length) process.stderr.write(execError.stderr);
+			if (execError.stdout?.length) process.stdout.write(execError.stdout);
+			throw error;
+		}
+	}
+	_AgentPlugin.runScript = runScript;
+})(AgentPlugin || (AgentPlugin = {}));
+
+//#endregion
+export { AgentPlugin, CURRENT_PLUGIN_VERSION };