@vitest-agent/plugin 1.0.0

package/index.js

@@ -0,0 +1,31 @@
+import { ConfigValidation } from "./services/ConfigValidation.js";
+import { resolveThresholds } from "./utils/resolve-thresholds.js";
+import { ConfigValidationLive } from "./layers/ConfigValidationLive.js";
+import { CoverageAnalyzer } from "./services/CoverageAnalyzer.js";
+import { CoverageAnalyzerLive } from "./layers/CoverageAnalyzerLive.js";
+import { ReporterLive } from "./layers/ReporterLive.js";
+import { captureEnvVars } from "./utils/capture-env.js";
+import { captureSettings, hashSettings } from "./utils/capture-settings.js";
+import { processFailure } from "./utils/process-failure.js";
+import { AgentReporter } from "./reporter.js";
+import { findTestFiles } from "./utils/find-test-files.js";
+import { Tag } from "./utils/tag.js";
+import { DefaultDiscoverStrategy, DiscoverStrategy } from "./utils/discover-strategy.js";
+import { discoverProjects } from "./utils/discover-projects.js";
+import { CONSOLE_REPORTERS, stripConsoleReporters } from "./utils/strip-console-reporters.js";
+import { AgentPlugin, CURRENT_PLUGIN_VERSION } from "./plugin.js";
+import { classifyByDirectory, classifyByFilename, combineClassifiers } from "./utils/classify-helpers.js";
+import { CoverageAnalyzerTest } from "./layers/CoverageAnalyzerTest.js";
+import { ConfigValidationTest } from "./layers/ConfigValidationTest.js";
+import { CoverageLevel, resolveCoverageInput, validateCoverageConfig } from "@vitest-agent/sdk";
+
+//#region src/index.ts
+/** Preset map for coverage levels without per-file enforcement. Mirrors `AgentPlugin.COVERAGE_LEVELS`. @public */
+const COVERAGE_LEVELS = AgentPlugin.COVERAGE_LEVELS;
+/** Preset map for coverage levels with per-file enforcement. Mirrors `AgentPlugin.COVERAGE_LEVELS_PER_FILE`. @public */
+const COVERAGE_LEVELS_PER_FILE = AgentPlugin.COVERAGE_LEVELS_PER_FILE;
+/** Auto-update tolerance functions for `coverage.thresholds.autoUpdate`. Mirrors `AgentPlugin.COVERAGE_AUTOUPDATE`. @public */
+const COVERAGE_AUTOUPDATE = AgentPlugin.COVERAGE_AUTOUPDATE;
+
+//#endregion
+export { AgentPlugin, AgentReporter, CONSOLE_REPORTERS, COVERAGE_AUTOUPDATE, COVERAGE_LEVELS, COVERAGE_LEVELS_PER_FILE, CURRENT_PLUGIN_VERSION, ConfigValidation, ConfigValidationLive, ConfigValidationTest, CoverageAnalyzer, CoverageAnalyzerLive, CoverageAnalyzerTest, CoverageLevel, DefaultDiscoverStrategy, DiscoverStrategy, ReporterLive, Tag, captureEnvVars, captureSettings, classifyByDirectory, classifyByFilename, combineClassifiers, discoverProjects, findTestFiles, hashSettings, processFailure, resolveCoverageInput, resolveThresholds, stripConsoleReporters, validateCoverageConfig };

package/layers/ConfigValidationLive.js

@@ -0,0 +1,148 @@
+import { ConfigValidation } from "../services/ConfigValidation.js";
+import { resolveThresholds } from "../utils/resolve-thresholds.js";
+import { createRequire } from "node:module";
+import { validateCoverageTargetsShape } from "@vitest-agent/sdk";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/ConfigValidationLive.ts
+/**
+* Live implementation of the ConfigValidation service.
+*
+* Implements all seven validation rules from the 2.0 starter rule set.
+* Rules run inside `validate(...)` — no I/O at construction time.
+*
+* @packageDocumentation
+*/
+/** Metrics that can appear at the top level in both coverageTargets and coverage.thresholds. */
+const COVERAGE_METRICS = [
+	"lines",
+	"functions",
+	"branches",
+	"statements"
+];
+/** Supported provider package names mapped to their npm package. */
+const SUPPORTED_PROVIDERS = {
+	v8: "@vitest/coverage-v8",
+	istanbul: "@vitest/coverage-istanbul"
+};
+/**
+* Resolves the operating mode from the vitest config.
+* Full mode when coverage.enabled !== false; UI-only otherwise.
+*/
+function resolveMode(vitestConfig) {
+	return vitestConfig.coverage?.enabled === false ? "ui-only" : "full";
+}
+/**
+* Try to require-resolve a package from the workspace.
+* Returns true when the package is resolvable, false when it is not installed.
+*/
+function isPackageInstalled(packageName) {
+	try {
+		createRequire(import.meta.url).resolve(packageName);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Run the TARGET_WITHOUT_THRESHOLD and TARGET_BELOW_THRESHOLD rules.
+*
+* Both targets and thresholds run through resolveThresholds so the `100: true`
+* shorthand and glob-pattern entries are expanded into the canonical `global`
+* per-metric numeric form before comparison. Without normalization a config
+* like `coverage.thresholds: { 100: true }` would look "unset" per metric and
+* fire false-positive TARGET_WITHOUT_THRESHOLD warnings.
+*
+* One entry per affected metric.
+*/
+function runTargetThresholdRules(input, errors, warnings) {
+	const rawTargets = input.pluginOptions.coverageTargets;
+	if (!rawTargets) return;
+	const coverageCfg = input.vitestConfig.coverage;
+	const targets = resolveThresholds(rawTargets).global;
+	const thresholds = resolveThresholds(coverageCfg?.thresholds).global;
+	for (const metric of COVERAGE_METRICS) {
+		const targetValue = targets[metric];
+		const thresholdValue = thresholds[metric];
+		if (typeof targetValue !== "number") continue;
+		if (thresholdValue === void 0) warnings.push({
+			code: "TARGET_WITHOUT_THRESHOLD",
+			message: `coverageTargets.${metric} is set to ${targetValue} but coverage.thresholds.${metric} is not configured. Set coverage.thresholds.${metric} to enforce a minimum coverage floor.`
+		});
+		else if (targetValue < thresholdValue) errors.push({
+			code: "TARGET_BELOW_THRESHOLD",
+			message: `coverageTargets.${metric} (${targetValue}) is below coverage.thresholds.${metric} (${thresholdValue}). The target must be at or above the threshold for ${metric}.`
+		});
+	}
+}
+/**
+* Run the INVALID_TARGET_VALUE rule by delegating to the SDK helper.
+* Also picks up PERFILE_ON_TARGETS from the same walk.
+*/
+function runInvalidTargetValueRule(input, errors, warnings) {
+	const targets = input.pluginOptions.coverageTargets;
+	if (!targets) return;
+	const result = validateCoverageTargetsShape(targets);
+	for (const err of result.errors) errors.push({
+		code: err.code,
+		path: err.path,
+		message: err.message
+	});
+	for (const warn of result.warnings) if (warn.code === "PERFILE_ON_TARGETS") warnings.push({
+		code: "PERFILE_ON_TARGETS",
+		message: `The "perFile" key should not be set inside coverageTargets. Set coverage.thresholds.perFile instead.`
+	});
+}
+/**
+* Run the UNSUPPORTED_PROVIDER rule (Full mode only).
+*/
+function runUnsupportedProviderRule(input, errors) {
+	const provider = input.vitestConfig.coverage?.provider;
+	if (provider === void 0) return;
+	if (!Object.hasOwn(SUPPORTED_PROVIDERS, provider)) errors.push({
+		code: "UNSUPPORTED_PROVIDER",
+		message: `coverage.provider "${provider}" is not supported by vitest-agent. Supported providers: v8, istanbul.`
+	});
+}
+/**
+* Run the MISSING_PROVIDER_PACKAGE rule (Full mode only).
+*/
+function runMissingProviderPackageRule(input, errors) {
+	const provider = input.vitestConfig.coverage?.provider;
+	if (provider === void 0) return;
+	if (!Object.hasOwn(SUPPORTED_PROVIDERS, provider)) return;
+	const packageName = SUPPORTED_PROVIDERS[provider];
+	if (!isPackageInstalled(packageName)) errors.push({
+		code: "MISSING_PROVIDER_PACKAGE",
+		message: `The coverage provider "${provider}" requires the "${packageName}" package, which does not appear to be installed.`,
+		remediation: `npm install --save-dev ${packageName}`
+	});
+}
+/**
+* Core validation logic. Runs all rules and accumulates results.
+*/
+function runAllRules(input) {
+	const errors = [];
+	const warnings = [];
+	const info = [];
+	const mode = resolveMode(input.vitestConfig);
+	runTargetThresholdRules(input, errors, warnings);
+	runInvalidTargetValueRule(input, errors, warnings);
+	if (mode === "full") {
+		runUnsupportedProviderRule(input, errors);
+		runMissingProviderPackageRule(input, errors);
+	}
+	return {
+		errors,
+		warnings,
+		info
+	};
+}
+/**
+* Live implementation of the ConfigValidation service running the built-in rule registry.
+* @public
+*/
+const ConfigValidationLive = Layer.succeed(ConfigValidation, { validate: (input) => Effect.sync(() => runAllRules(input)) });
+
+//#endregion
+export { ConfigValidationLive };

package/layers/ConfigValidationTest.js

@@ -0,0 +1,16 @@
+import { ConfigValidation } from "../services/ConfigValidation.js";
+import { Effect, Layer } from "effect";
+
+//#region src/layers/ConfigValidationTest.ts
+/**
+* Test-double layer factory for ConfigValidation. Pass a pre-built `ValidationResult` to inject.
+* @public
+*/
+const ConfigValidationTest = { layer: (override) => Layer.succeed(ConfigValidation, { validate: () => Effect.succeed(override ?? {
+	errors: [],
+	warnings: [],
+	info: []
+}) }) };
+
+//#endregion
+export { ConfigValidationTest };

package/layers/CoverageAnalyzerLive.js

@@ -0,0 +1,138 @@
+import { CoverageAnalyzer } from "../services/CoverageAnalyzer.js";
+import { compressLines } from "@vitest-agent/sdk";
+import { Effect, Layer, Option } from "effect";
+
+//#region src/layers/CoverageAnalyzerLive.ts
+/**
+* Check whether any metric in `stats` falls below its corresponding threshold.
+* Only metrics that are defined in `thresholds` are checked.
+*/
+function isBelowMetricThresholds(stats, thresholds) {
+	if (thresholds.lines !== void 0 && stats.lines < thresholds.lines) return true;
+	if (thresholds.functions !== void 0 && stats.functions < thresholds.functions) return true;
+	if (thresholds.branches !== void 0 && stats.branches < thresholds.branches) return true;
+	if (thresholds.statements !== void 0 && stats.statements < thresholds.statements) return true;
+	return false;
+}
+/**
+* Runtime duck-type check for istanbul CoverageMap.
+*/
+function isIstanbulCoverageMap(value) {
+	if (value === null || typeof value !== "object") return false;
+	const obj = 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).
+*/
+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);
+}
+/**
+* Resolve the effective thresholds for a file path by checking pattern
+* overrides first, falling back to global thresholds.
+*/
+function resolveEffectiveThresholds(filePath, resolved) {
+	for (const [pattern, metrics] of resolved.patterns) if (matchGlob(filePath, pattern)) return metrics;
+	return resolved.global;
+}
+/**
+* Internal coverage processing logic. Shared by both `process` and `processScoped`.
+*
+* @param coverageMap - The value received by `onCoverage`; duck-typed at runtime
+* @param options - Coverage processing options
+* @param testedFiles - When provided, only flag threshold violations for files in this set
+* @returns Structured coverage report, or undefined if duck-typing fails
+*/
+function processCoverageInternal(coverageMap, options, testedFiles) {
+	if (!isIstanbulCoverageMap(coverageMap)) return void 0;
+	const { includeBareZero } = options;
+	const scoped = testedFiles !== void 0;
+	const summary = coverageMap.getCoverageSummary();
+	const totals = {
+		statements: summary.statements.pct,
+		branches: summary.branches.pct,
+		functions: summary.functions.pct,
+		lines: summary.lines.pct
+	};
+	const testedFileSet = testedFiles ? new Set(testedFiles) : void 0;
+	const lowCoverage = [];
+	const belowTarget = [];
+	for (const filePath of coverageMap.files()) {
+		const fileCoverage = coverageMap.fileCoverageFor(filePath);
+		const fileSummary = fileCoverage.toSummary();
+		const fileStats = {
+			statements: fileSummary.statements.pct,
+			branches: fileSummary.branches.pct,
+			functions: fileSummary.functions.pct,
+			lines: fileSummary.lines.pct
+		};
+		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, resolveEffectiveThresholds(filePath, options.thresholds));
+		if (isBareZero || isBelowThreshold) {
+			const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
+			lowCoverage.push({
+				file: filePath,
+				summary: fileStats,
+				uncoveredLines
+			});
+			continue;
+		}
+		if (options.targets) {
+			if (isBelowMetricThresholds(fileStats, resolveEffectiveThresholds(filePath, options.targets))) {
+				const uncoveredLines = compressLines(fileCoverage.getUncoveredLines());
+				belowTarget.push({
+					file: filePath,
+					summary: fileStats,
+					uncoveredLines
+				});
+			}
+		}
+	}
+	lowCoverage.sort((a, b) => a.summary.lines - b.summary.lines);
+	belowTarget.sort((a, b) => a.summary.lines - b.summary.lines);
+	return {
+		totals,
+		thresholds: {
+			global: options.thresholds.global,
+			patterns: options.thresholds.patterns
+		},
+		...options.targets ? { targets: {
+			global: options.targets.global,
+			patterns: options.targets.patterns
+		} } : {},
+		...options.baselines ? { baselines: {
+			global: options.baselines.global,
+			patterns: options.baselines.patterns
+		} } : {},
+		scoped,
+		...scoped && testedFiles ? { scopedFiles: [...testedFiles] } : {},
+		lowCoverage,
+		lowCoverageFiles: lowCoverage.map((f) => f.file),
+		...options.targets ? {
+			belowTarget,
+			belowTargetFiles: belowTarget.map((f) => f.file)
+		} : {}
+	};
+}
+/**
+* Live implementation of the CoverageAnalyzer service backed by istanbul.
+* @public
+*/
+const CoverageAnalyzerLive = Layer.succeed(CoverageAnalyzer, {
+	process: (coverage, options) => Effect.sync(() => {
+		const result = processCoverageInternal(coverage, options);
+		return result ? Option.some(result) : Option.none();
+	}),
+	processScoped: (coverage, options, testedFiles) => Effect.sync(() => {
+		const result = processCoverageInternal(coverage, options, testedFiles);
+		return result ? Option.some(result) : Option.none();
+	})
+});
+
+//#endregion
+export { CoverageAnalyzerLive };

package/layers/CoverageAnalyzerTest.js

@@ -0,0 +1,15 @@
+import { CoverageAnalyzer } from "../services/CoverageAnalyzer.js";
+import { Effect, Layer, Option } from "effect";
+
+//#region src/layers/CoverageAnalyzerTest.ts
+/**
+* Test-double layer factory for CoverageAnalyzer. Pass a pre-built `CoverageReport` to inject.
+* @public
+*/
+const CoverageAnalyzerTest = { layer: (data) => Layer.succeed(CoverageAnalyzer, {
+	process: () => Effect.succeed(data ? Option.some(data) : Option.none()),
+	processScoped: () => Effect.succeed(data ? Option.some(data) : Option.none())
+}) };
+
+//#endregion
+export { CoverageAnalyzerTest };

package/layers/ReporterLive.js

@@ -0,0 +1,21 @@
+import { CoverageAnalyzerLive } from "./CoverageAnalyzerLive.js";
+import { DataReaderLive, DataStoreLive, HistoryTrackerLive, LoggerLive, OutputPipelineLive, migration0001 } from "@vitest-agent/sdk";
+import { Layer } from "effect";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import { layer } from "@effect/sql-sqlite-node/SqliteClient";
+import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
+
+//#region src/layers/ReporterLive.ts
+/**
+* Composition layer for a single `AgentReporter` run. Wires SQLite, migrations, and all service layers.
+* @public
+*/
+const ReporterLive = (dbPath, logLevel, logFile) => {
+	const SqliteLayer = layer({ filename: dbPath });
+	const PlatformLayer = NodeContext.layer;
+	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord({ "0001_initial": migration0001 }) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
+	return Layer.mergeAll(DataStoreLive, CoverageAnalyzerLive, HistoryTrackerLive, OutputPipelineLive).pipe(Layer.provideMerge(DataReaderLive), Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
+};
+
+//#endregion
+export { ReporterLive };

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "@vitest-agent/plugin",
+	"version": "1.0.0",
+	"private": false,
+	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
+	"keywords": [
+		"vitest",
+		"vitest-plugin",
+		"agent",
+		"llm",
+		"ai",
+		"testing",
+		"sqlite",
+		"coverage",
+		"mcp"
+	],
+	"homepage": "https://github.com/spencerbeggs/vitest-agent#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/vitest-agent/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/vitest-agent.git",
+		"directory": "packages/plugin"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@effect/cluster": "^0.59.0",
+		"@effect/platform": "^0.96.2",
+		"@effect/platform-node": "^0.107.0",
+		"@effect/rpc": "^0.75.1",
+		"@effect/sql": "^0.51.1",
+		"@effect/sql-sqlite-node": "^0.52.0",
+		"@vitest-agent/reporter": "1.0.0",
+		"@vitest-agent/sdk": "1.0.0",
+		"acorn": "^8.17.0",
+		"acorn-typescript": "^1.4.13",
+		"effect": "^3.21.4",
+		"magic-string": "^0.30.21",
+		"workspaces-effect": "^1.2.0"
+	},
+	"peerDependencies": {
+		"@vitest-agent/cli": "1.0.0",
+		"@vitest-agent/mcp": "1.0.0",
+		"@vitest/coverage-istanbul": "^4.1.0",
+		"@vitest/coverage-v8": "^4.1.0",
+		"vitest": "^4.1.0"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}