@vitest-agent/plugin 1.1.1 → 1.1.2

package/index.d.ts

@@ -223,6 +223,11 @@ declare const CURRENT_PLUGIN_VERSION: string;
  */
 declare function AgentPlugin(options?: AgentPluginConstructorOptions, _layer?: Layer.Layer<EnvironmentDetector>): {
   name: "vitest-agent";
+  configResolved: (resolvedConfig: {
+    logger: {
+      warn: (msg: string, options?: unknown) => void;
+    };
+  }) => void;
   configureVitest(ctx: VitestPluginContext): Promise<void>;
   transform?: (code: string, id: string) => InjectTagsResult | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/plugin",
-	"version": "1.1.1",
+	"version": "1.1.2",
 	"private": false,
 	"description": "Vitest plugin for the vitest-agent ecosystem: owns persistence, classification, baselines, trends, and dispatches rendering to a configurable reporter.",
 	"keywords": [
@@ -54,7 +54,7 @@
 	},
 	"peerDependencies": {
 		"@vitest-agent/cli": "1.0.2",
-		"@vitest-agent/mcp": "1.2.0",
+		"@vitest-agent/mcp": "1.3.0",
 		"@vitest/coverage-istanbul": "^4.1.0",
 		"@vitest/coverage-v8": "^4.1.0",
 		"vitest": "^4.1.0"

package/plugin.js

@@ -6,6 +6,7 @@ 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 { isBenignViteSourceMapWarning } from "./utils/is-benign-vite-source-map-warning.js";
 import { stripConsoleReporters } from "./utils/strip-console-reporters.js";
 import { execSync } from "node:child_process";
 import { AgentConsoleMode, CiConsoleMode, CoverageLevel, EnvironmentDetector, EnvironmentDetectorLive, HumanConsoleMode, formatFatalError, resolveLogLevel } from "@vitest-agent/sdk";
@@ -97,7 +98,7 @@ const aggregatedReporterByVitest = /* @__PURE__ */ new WeakSet();
 *
 * @public
 */
-const CURRENT_PLUGIN_VERSION = "1.1.1";
+const CURRENT_PLUGIN_VERSION = "1.1.2";
 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);
@@ -115,6 +116,31 @@ function envToExecutor(env) {
 	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
+* untouched.
+*
+* Every Vite per-environment logger (`environment.logger`) delegates its
+* `warn` calls to the single root `resolvedConfig.logger.warn` function
+* reference (see Vite's `PartialEnvironment` constructor), so mutating that
+* one function here intercepts the warning regardless of which environment
+* (`client`, `ssr`, ...) triggered it. Wrapping happens in `configResolved`
+* (rather than returning a `customLogger` from the plugin's `config` hook)
+* because Vite's own config-resolution pipeline can construct or replace
+* the logger between `config` and `configResolved` — mutating the already-
+* resolved logger instance in place is the wiring that survives.
+*
+* @internal
+*/
+function installViteSourceMapWarningFilter(resolvedConfig) {
+	const originalWarn = resolvedConfig.logger.warn.bind(resolvedConfig.logger);
+	resolvedConfig.logger.warn = (msg, options) => {
+		if (isBenignViteSourceMapWarning(msg)) return;
+		originalWarn(msg, options);
+	};
+}
+/**
 * Vitest plugin that injects `AgentReporter` into the reporter chain.
 *
 * @param options - Plugin configuration options
@@ -130,6 +156,9 @@ function AgentPlugin(options = {}, _layer) {
 	const discoverStrategyResolved = options.discoverStrategy === false ? null : options.discoverStrategy ?? new DefaultDiscoverStrategy();
 	const pluginObj = {
 		name: "vitest-agent",
+		configResolved(resolvedConfig) {
+			installViteSourceMapWarningFilter(resolvedConfig);
+		},
 		async configureVitest(ctx) {
 			try {
 				const { vitest, project } = ctx;

package/utils/discover-projects.js

@@ -1,11 +1,65 @@
 import { toPosixPath } from "./to-posix-path.js";
 import { DefaultDiscoverStrategy } from "./discover-strategy.js";
 import { isAbsolute, join, normalize, relative } from "node:path";
+import { readdir, stat } from "node:fs/promises";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "workspaces-effect";
 
 //#region src/utils/discover-projects.ts
+const DISCOVERY_LAST_SCAN_SYMBOL = Symbol.for("vitest-agent:discovery:last-scan-at");
+function recordDiscoveryScanTimestamp() {
+	globalThis[DISCOVERY_LAST_SCAN_SYMBOL] = (/* @__PURE__ */ new Date()).toISOString();
+}
 const _cache = /* @__PURE__ */ new Map();
 /**
+* Computes a cheap signature (relative path + mtimeMs pairs, sorted) for every
+* file nested under `dirPath`. Used to detect added/removed/moved/renamed test
+* files between `discoverProjects` calls without re-walking test-file globs.
+* Returns an empty string when `dirPath` does not exist — this still produces
+* a stable, comparable signature contribution.
+*/
+async function computeDirSignature(dirPath) {
+	let entries;
+	try {
+		entries = await readdir(dirPath, {
+			withFileTypes: true,
+			recursive: true
+		});
+	} catch {
+		return "";
+	}
+	const parts = [];
+	for (const ent of entries) {
+		if (!ent.isFile()) continue;
+		const fullPath = join(ent.parentPath ?? dirPath, ent.name);
+		let mtimeMs;
+		try {
+			mtimeMs = (await stat(fullPath)).mtimeMs;
+		} catch {
+			continue;
+		}
+		const relPath = toPosixPath(relative(dirPath, fullPath));
+		parts.push(`${relPath}:${mtimeMs}`);
+	}
+	parts.sort();
+	return parts.join("|");
+}
+/**
+* Computes a cheap whole-workspace directory signature by combining each
+* package's `src/` and `__test__/` signatures (issue #100). Only entries +
+* mtimes are read — no file content — so this stays fast even for large
+* monorepos. A changed signature means a test file was added, removed,
+* moved, or renamed since the cached result was computed.
+*/
+async function computeWorkspaceSignature(packages) {
+	const parts = [];
+	for (const pkg of packages) {
+		const srcSig = await computeDirSignature(join(pkg.path, "src"));
+		const testDirSig = await computeDirSignature(join(pkg.path, "__test__"));
+		parts.push(`${pkg.path}::src=${srcSig}::__test__=${testDirSig}`);
+	}
+	return parts.join("\n");
+}
+/**
 * Scan all workspace packages and additional entries through the active strategy and return projects + tags.
 * @param options - Optional strategy, working directory, and extra project entries
 * @returns Resolved projects and tag definitions
@@ -18,12 +72,14 @@ async function discoverProjects(options) {
 	const root = findWorkspaceRootSync(cwd ?? process.cwd());
 	if (!root) throw new Error(`[vitest-agent] Could not find workspace root from ${cwd ?? process.cwd()}. Ensure a pnpm-workspace.yaml or package.json with "workspaces" exists.`);
 	const useCache = strategy === void 0 && additionalEntries.length === 0;
+	const resolvedStrategy = strategy ?? new DefaultDiscoverStrategy();
+	const packages = getWorkspacePackagesSync(root);
+	let signature;
 	if (useCache) {
+		signature = await computeWorkspaceSignature(packages);
 		const cached = _cache.get(root);
-		if (cached) return cached;
+		if (cached && cached.signature === signature) return cached.result;
 	}
-	const resolvedStrategy = strategy ?? new DefaultDiscoverStrategy();
-	const packages = getWorkspacePackagesSync(root);
 	const configs = [];
 	const workspaceNames = /* @__PURE__ */ new Set();
 	const workspacePaths = /* @__PURE__ */ new Set();
@@ -60,7 +116,11 @@ async function discoverProjects(options) {
 		projects: configs.length > 0 ? configs : void 0,
 		tags
 	};
-	if (useCache) _cache.set(root, result);
+	if (useCache && signature !== void 0) _cache.set(root, {
+		result,
+		signature
+	});
+	recordDiscoveryScanTimestamp();
 	return result;
 }
 

package/utils/is-benign-vite-source-map-warning.js

@@ -0,0 +1,21 @@
+//#region src/utils/is-benign-vite-source-map-warning.ts
+/**
+* Matches the benign Vite core warning emitted when a dependency's shipped
+* `.js` file references a `.js.map` sibling that was never published in the
+* npm tarball (the canonical example: `typescript/lib/typescript.js` /
+* `typescript.js.map`). Vite core's `loadAndTransform` logs this through
+* `environment.logger.warn` — not through per-test console output — so it
+* cannot be filtered by the console-leak path. See GitHub issue #110.
+*
+* Only matches the specific "Failed to load source map" + ENOENT `.js.map`
+* shape; every other warning (including unrelated ENOENT errors against
+* other file extensions) returns `false` so it still surfaces.
+* @public
+*/
+function isBenignViteSourceMapWarning(message) {
+	if (!message) return false;
+	return /Failed to load source map/.test(message) && /ENOENT:.*\.js\.map/.test(message);
+}
+
+//#endregion
+export { isBenignViteSourceMapWarning };