@vitest-agent/sdk 7.1.0 → 9.0.0

package/schemas/ConsoleLeaks.js

@@ -1,3 +1,4 @@
+import { FiniteNumber } from "./Common.js";
 import { Schema } from "effect";
 
 // src/schemas/ConsoleLeaks.ts
@@ -8,8 +9,8 @@ import { Schema } from "effect";
 */
 const ConsoleLeakFile = Schema.Struct({
 	file: Schema.String,
-	stdout: Schema.Number,
-	stderr: Schema.Number,
+	stdout: FiniteNumber,
+	stderr: FiniteNumber,
 	tests: Schema.optional(Schema.Array(Schema.String)),
 	sample: Schema.optional(Schema.String)
 }).annotate({ identifier: "ConsoleLeakFile" });
@@ -22,8 +23,8 @@ const ConsoleLeakFile = Schema.Struct({
 * @public
 */
 const ConsoleLeaksFromFailingTests = Schema.Struct({
-	total: Schema.Number,
-	files: Schema.Number
+	total: FiniteNumber,
+	files: FiniteNumber
 }).annotate({ identifier: "ConsoleLeaksFromFailingTests" });
 /**
 * Aggregate stray-console-output signal for a single test run. Omitted from
@@ -35,7 +36,7 @@ const ConsoleLeaksFromFailingTests = Schema.Struct({
 * @public
 */
 const ConsoleLeaks = Schema.Struct({
-	total: Schema.Number,
+	total: FiniteNumber,
 	byFile: Schema.Array(ConsoleLeakFile),
 	truncated: Schema.optional(Schema.Boolean),
 	fromFailingTests: Schema.optional(ConsoleLeaksFromFailingTests)

package/schemas/Coverage.js

@@ -1,3 +1,4 @@
+import { FiniteNumber } from "./Common.js";
 import { MetricThresholds, PatternThresholds } from "./Thresholds.js";
 import { Effect, Schema } from "effect";
 
@@ -7,10 +8,10 @@ import { Effect, Schema } from "effect";
 * @public
 */
 const CoverageTotals = Schema.Struct({
-	statements: Schema.Number,
-	branches: Schema.Number,
-	functions: Schema.Number,
-	lines: Schema.Number
+	statements: FiniteNumber,
+	branches: FiniteNumber,
+	functions: FiniteNumber,
+	lines: FiniteNumber
 }).annotate({ identifier: "CoverageTotals" });
 /**
 * Per-file coverage data including uncovered line ranges.
@@ -58,7 +59,7 @@ const CoverageReport = Schema.Struct({
 	})),
 	scoped: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
 	scopedFiles: Schema.optional(Schema.Array(Schema.String)),
-	totalFiles: Schema.optional(Schema.Number),
+	totalFiles: Schema.optional(FiniteNumber),
 	lowCoverage: Schema.Array(FileCoverageReport),
 	lowCoverageFiles: Schema.Array(Schema.String),
 	belowTarget: Schema.optional(Schema.Array(FileCoverageReport)),

package/schemas/RenderState.js

@@ -1,4 +1,5 @@
 import { ReportError, TestClassification, TestState } from "./Common.js";
+import { ConsoleLeaks } from "./ConsoleLeaks.js";
 import { MetricThresholds } from "./Thresholds.js";
 import { CoverageTotals, GlobShortfall } from "./Coverage.js";
 import { StrayOutput } from "./StrayOutput.js";
@@ -163,7 +164,13 @@ const RenderState = Schema.Struct({
 	* capture, folded from `RunFinished.strayOutput`. Absent when the run
 	* wrote nothing stray.
 	*/
-	strayOutput: Schema.optional(StrayOutput)
+	strayOutput: Schema.optional(StrayOutput),
+	/**
+	* `console.*` output Vitest captured from tests that did not fail, folded
+	* from `RunFinished.consoleLeaks`. Absent when the run logged nothing
+	* (issue #544).
+	*/
+	consoleLeaks: Schema.optional(ConsoleLeaks)
 }).annotate({ identifier: "RenderState" });
 /**
 * Initial state — what the reducer returns when no events have been

package/schemas/RunDiagnostics.js

@@ -0,0 +1,61 @@
+import { FiniteNumber } from "./Common.js";
+import { Schema } from "effect";
+
+// src/schemas/RunDiagnostics.ts
+/**
+* Which Vitest performance diagnostic a hint came from.
+* @public
+*/
+const PerformanceHintKind = Schema.Literals([
+	"environment",
+	"import",
+	"transform",
+	"isolate"
+]).annotate({ identifier: "PerformanceHintKind" });
+/**
+* One performance hint derived from Vitest's run diagnostics. `project` is
+* omitted for a hint that applies to the whole run (for example `isolate`).
+* @public
+*/
+const PerformanceHint = Schema.Struct({
+	kind: PerformanceHintKind,
+	project: Schema.optionalKey(Schema.String),
+	message: Schema.String,
+	remedy: Schema.String,
+	detail: Schema.String,
+	learnMoreUrl: Schema.String,
+	estimatedSavingMs: Schema.optionalKey(FiniteNumber),
+	share: Schema.optionalKey(FiniteNumber)
+}).annotate({ identifier: "PerformanceHint" });
+/**
+* Wall-clock timing of the plugin's post-run work, in milliseconds.
+* @public
+*/
+const PostRunTiming = Schema.Struct({
+	persistMs: FiniteNumber,
+	coverageScanMs: FiniteNumber,
+	totalMs: FiniteNumber,
+	renderMs: Schema.optionalKey(FiniteNumber),
+	vitestDurationMs: Schema.optionalKey(FiniteNumber)
+}).annotate({ identifier: "PostRunTiming" });
+/**
+* Whether the run's results were persisted to the database.
+* @public
+*/
+const PersistenceStatus = Schema.Struct({
+	ok: Schema.Boolean,
+	reason: Schema.optionalKey(Schema.String),
+	migrationFailed: Schema.optionalKey(Schema.Boolean)
+}).annotate({ identifier: "PersistenceStatus" });
+/**
+* Run-level diagnostics: performance hints, post-run timing and persistence
+* status (issue #544).
+* @public
+*/
+const RunDiagnostics = Schema.Struct({
+	performanceHints: Schema.Array(PerformanceHint),
+	postRun: Schema.optionalKey(PostRunTiming),
+	persistence: Schema.optionalKey(PersistenceStatus)
+}).annotate({ identifier: "RunDiagnostics" });
+
+export { PerformanceHint, PerformanceHintKind, PersistenceStatus, PostRunTiming, RunDiagnostics };

package/schemas/RunEvent.js

@@ -1,4 +1,5 @@
 import { ReportError, TestClassification, TestState } from "./Common.js";
+import { ConsoleLeaks } from "./ConsoleLeaks.js";
 import { MetricThresholds } from "./Thresholds.js";
 import { CoverageTotals, FileCoverageReport, GlobShortfall } from "./Coverage.js";
 import { StrayOutput } from "./StrayOutput.js";
@@ -226,7 +227,13 @@ const RunEvent = Schema.Union([
 		* capture (`AgentReport.strayOutput`). Optional: absent when the run
 		* wrote nothing stray, and in older replay data.
 		*/
-		strayOutput: Schema.optional(StrayOutput)
+		strayOutput: Schema.optional(StrayOutput),
+		/**
+		* `console.*` output Vitest captured from tests that did not fail
+		* (`AgentReport.consoleLeaks`). Optional: absent when the run logged
+		* nothing, and in older replay data (issue #544).
+		*/
+		consoleLeaks: Schema.optional(ConsoleLeaks)
 	})
 ]).annotate({ identifier: "RunEvent" });
 

package/schemas/RunReportFile.js

@@ -1,4 +1,5 @@
 import { AgentReport } from "./AgentReport.js";
+import { RunDiagnostics } from "./RunDiagnostics.js";
 import { Schema } from "effect";
 
 // src/schemas/RunReportFile.ts
@@ -47,7 +48,8 @@ const RunReportFile = Schema.Struct({
 	$schema: Schema.optionalKey(Schema.String),
 	schemaVersion: Schema.Literal(1),
 	generatedAt: IsoInstant,
-	reports: Schema.Array(AgentReport)
+	reports: Schema.Array(AgentReport),
+	runDiagnostics: Schema.optionalKey(RunDiagnostics)
 }).annotate({
 	identifier: "RunReportFile",
 	description: "The vitest-agent run report file (.vitest/vitest-agent/run.json): one AgentReport per Vitest project from the most recent run. Read reports[].summary for pass/fail counts and reports[].failed for the failing modules and their tests. schemaVersion is the envelope contract version; generatedAt is when the run finished."

package/schemas/StrayOutput.js

@@ -1,3 +1,4 @@
+import { FiniteNumber } from "./Common.js";
 import { Schema } from "effect";
 
 // src/schemas/StrayOutput.ts
@@ -27,10 +28,10 @@ const StrayOutputSample = Schema.Struct({
 * @public
 */
 const StrayOutput = Schema.Struct({
-	total: Schema.Number,
-	stdout: Schema.Number,
-	stderr: Schema.Number,
-	bytes: Schema.Number,
+	total: FiniteNumber,
+	stdout: FiniteNumber,
+	stderr: FiniteNumber,
+	bytes: FiniteNumber,
 	samples: Schema.Array(StrayOutputSample)
 }).annotate({ identifier: "StrayOutput" });
 

package/schemas/Thresholds.js

@@ -1,3 +1,4 @@
+import { FiniteNumber } from "./Common.js";
 import { Effect, Schema } from "effect";
 
 // src/schemas/Thresholds.ts
@@ -6,10 +7,10 @@ import { Effect, Schema } from "effect";
 * @public
 */
 const MetricThresholds = Schema.Struct({
-	lines: Schema.optional(Schema.Number),
-	functions: Schema.optional(Schema.Number),
-	branches: Schema.optional(Schema.Number),
-	statements: Schema.optional(Schema.Number)
+	lines: Schema.optional(FiniteNumber),
+	functions: Schema.optional(FiniteNumber),
+	branches: Schema.optional(FiniteNumber),
+	statements: Schema.optional(FiniteNumber)
 }).annotate({ identifier: "MetricThresholds" });
 /**
 * A `perFile` setting. Vitest 5 allows either a plain boolean or a

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }

package/utils/ansi.js

@@ -1,38 +1,4 @@
 // src/utils/ansi.ts
-const ANSI_CODES = {
-	reset: [0, 0],
-	bold: [1, 22],
-	dim: [2, 22],
-	red: [31, 39],
-	green: [32, 39],
-	yellow: [33, 39],
-	cyan: [36, 39]
-};
-/**
-* Wrap text with an ANSI color/style escape code.
-*
-* No-ops when `options.noColor` is true, keeping output as valid plain
-* markdown when captured by agents or piped to files.
-*
-* @privateRemarks
-* Uses raw ANSI escape sequences (`\x1b[...m`) rather than a dependency
-* like `chalk` or `picocolors` to keep the package zero-dependency. The
-* `noColor` flag respects the `NO_COLOR` environment variable convention.
-*
-* @param text - Text to wrap
-* @param color - ANSI code name: `reset`, `bold`, `dim`, `red`, `green`, `yellow`, `cyan`
-* @param options - Control color output
-* @returns Text with ANSI escape codes, or plain text if noColor
-*
-* @see {@link https://no-color.org/ | NO_COLOR convention}
-* @internal
-*/
-function ansi(text, color, options) {
-	if (options?.noColor) return text;
-	const codes = ANSI_CODES[color];
-	if (!codes) return text;
-	return `\x1b[${codes[0]}m${text}\x1b[${codes[1]}m`;
-}
 /**
 * Strip all ANSI escape codes from a string.
 *
@@ -45,4 +11,4 @@ function stripAnsi(text) {
 	return text.replace(/\x1b\[[0-9;]*m/g, "");
 }
 
-export { ansi, stripAnsi };
+export { stripAnsi };

package/utils/console-leaks.js

@@ -99,5 +99,31 @@ function collectConsoleLeakEntries(files) {
 	}
 	return entries;
 }
+const MAX_NOTE_FILES = 3;
+/**
+* The note a renderer prints for a run's console leaks: one line naming the
+* write count, the file count and the fix, then up to three files with
+* their stream split and sample, how many files it left out, and the output
+* from failing tests that the leak count excludes. Empty when the run has no
+* leak from a passing test (output from failing tests alone is not a leak).
+* @public
+*/
+const formatConsoleLeaksNote = (leaks) => {
+	if (leaks.total === 0) return [];
+	const files = leaks.byFile.length;
+	const lines = [`Console leaks: passing tests wrote ${leaks.total} console ${leaks.total === 1 ? "line" : "lines"} in ${files} ${files === 1 ? "file" : "files"}; Vitest captured them, so they are noise an agent never sees. Remove the logging or route it through a logger the tests silence.`];
+	const shown = leaks.byFile.slice(0, MAX_NOTE_FILES);
+	for (const file of shown) {
+		const streams = [file.stdout > 0 ? `${file.stdout} stdout` : "", file.stderr > 0 ? `${file.stderr} stderr` : ""].filter((part) => part.length > 0).join(", ");
+		const sample = file.sample !== void 0 ? `: ${file.sample}` : "";
+		lines.push(`  ${file.file} (${streams})${sample}`);
+	}
+	const more = leaks.byFile.length - shown.length;
+	if (more > 0) lines.push(`  (+${more} more ${more === 1 ? "file" : "files"}${leaks.truncated === true ? ", list truncated" : ""})`);
+	else if (leaks.truncated === true) lines.push("  (file list truncated)");
+	const failing = leaks.fromFailingTests;
+	if (failing !== void 0 && failing.total > 0) lines.push(`  (${failing.total} more ${failing.total === 1 ? "line" : "lines"} from failing tests in ${failing.files} ${failing.files === 1 ? "file" : "files"}, not counted as leaks)`);
+	return lines;
+};
 
-export { buildConsoleLeaks, collectConsoleLeakEntries };
+export { buildConsoleLeaks, collectConsoleLeakEntries, formatConsoleLeaksNote };

package/utils/run-diagnostics-actions.js

@@ -0,0 +1,58 @@
+// src/utils/run-diagnostics-actions.ts
+/**
+* Post-run work at or above this many milliseconds is always "slow".
+* @public
+*/
+const POST_RUN_SLOW_MS = 5e3;
+/**
+* Post-run work at or above this share of Vitest's own duration is "slow"
+* (once it also clears {@link POST_RUN_SLOW_MIN_MS}).
+* @public
+*/
+const POST_RUN_SLOW_SHARE = .1;
+/**
+* Minimum post-run milliseconds before the share rule applies.
+* @public
+*/
+const POST_RUN_SLOW_MIN_MS = 1e3;
+/**
+* Whether the plugin's post-run work was slow enough to surface.
+* @public
+*/
+function isPostRunSlow(timing) {
+	if (timing.totalMs >= 5e3) return true;
+	return timing.totalMs >= 1e3 && timing.vitestDurationMs !== void 0 && timing.totalMs >= .1 * timing.vitestDurationMs;
+}
+const fmt = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+/**
+* Map run diagnostics onto suggested actions: persistence failure first, then
+* slow post-run work, then performance hints in input order.
+* @public
+*/
+function suggestedActionsFromRunDiagnostics(d) {
+	const out = [];
+	if (d.persistence !== void 0 && !d.persistence.ok) {
+		const { reason, migrationFailed } = d.persistence;
+		out.push({
+			severity: "warn",
+			title: "Results were not saved",
+			detail: migrationFailed ? `${reason ?? "unknown error"}. Run \`vitest-agent db reset\` to recreate the database.` : reason ?? "unknown error"
+		});
+	}
+	if (d.postRun !== void 0 && isPostRunSlow(d.postRun)) {
+		const { totalMs, persistMs, coverageScanMs } = d.postRun;
+		out.push({
+			severity: "warn",
+			title: `Post-run work took ${fmt(totalMs)} (persist ${fmt(persistMs)}, coverage scan ${fmt(coverageScanMs)})`,
+			detail: "Time vitest-agent spent after Vitest finished. Set persist: false where history is not needed (e.g. CI), or narrow coverage.include."
+		});
+	}
+	for (const hint of d.performanceHints) out.push({
+		severity: "info",
+		title: hint.project !== void 0 ? `${hint.project}: ${hint.message}` : hint.message,
+		detail: `${hint.remedy} — ${hint.detail} (${hint.learnMoreUrl})`
+	});
+	return out;
+}
+
+export { POST_RUN_SLOW_MIN_MS, POST_RUN_SLOW_MS, POST_RUN_SLOW_SHARE, isPostRunSlow, suggestedActionsFromRunDiagnostics };

package/utils/vitest-config-files.js

@@ -0,0 +1,24 @@
+// src/utils/vitest-config-files.ts
+/**
+* The config filenames Vitest 5 itself loads, in the order it prefers them:
+* `vitest.config.*` before `vite.config.*`, each across
+* `ts` / `mts` / `cts` / `js` / `mjs` / `cjs`. Mirrors `configFiles` in
+* Vitest's own `constants.ts`. `vitest.workspace.*` is absent on purpose:
+* Vitest no longer reads a workspace file (projects live in the config's
+* `test.projects`).
+*
+* The single source both front ends derive their config lookups from, so the
+* CLI's `check-test-path` and the MCP `run_tests` root walk cannot drift.
+*
+* @public
+*/
+const VITEST_CONFIG_FILES = ["vitest.config", "vite.config"].flatMap((name) => [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+].map((ext) => `${name}.${ext}`));
+
+export { VITEST_CONFIG_FILES };

package/version.js

@@ -11,6 +11,6 @@
 * survives into the published artifact.
 * @public
 */
-const CURRENT_SDK_VERSION = "7.1.0";
+const CURRENT_SDK_VERSION = "9.0.0";
 
 export { CURRENT_SDK_VERSION };

package/utils/compress-lines.js

@@ -1,44 +0,0 @@
-// src/utils/compress-lines.ts
-/**
-* Compress an array of line numbers into a compact range string.
-*
-* Consecutive line numbers are collapsed into `start-end` ranges,
-* separated by commas. Duplicate values are removed and the input
-* is sorted ascending before processing.
-*
-* @param lines - Array of line numbers to compress
-* @returns Compressed range string, or empty string for empty input
-*
-* @example
-* ```typescript
-* import { compressLines } from "@vitest-agent/sdk/utils";
-*
-* compressLines([1, 2, 3, 5, 10, 11, 12]);
-* // Returns: "1-3,5,10-12"
-*
-* compressLines([42]);
-* // Returns: "42"
-*
-* compressLines([]);
-* // Returns: ""
-* ```
-*
-* @public
-*/
-function compressLines(lines) {
-	if (lines.length === 0) return "";
-	const sorted = [...new Set(lines)].sort((a, b) => a - b);
-	const ranges = [];
-	let start = sorted[0];
-	let end = sorted[0];
-	for (let i = 1; i < sorted.length; i++) if (sorted[i] === end + 1) end = sorted[i];
-	else {
-		ranges.push(start === end ? `${start}` : `${start}-${end}`);
-		start = sorted[i];
-		end = sorted[i];
-	}
-	ranges.push(start === end ? `${start}` : `${start}-${end}`);
-	return ranges.join(",");
-}
-
-export { compressLines };

package/utils/detect-pm.js

@@ -1,57 +0,0 @@
-// src/utils/detect-pm.ts
-const LOCKFILE_MAP = [
-	["pnpm-lock.yaml", "pnpm"],
-	["package-lock.json", "npm"],
-	["yarn.lock", "yarn"],
-	["bun.lock", "bun"]
-];
-const RUN_COMMANDS = {
-	pnpm: "pnpm vitest run",
-	npm: "npx vitest run",
-	yarn: "yarn vitest run",
-	bun: "bun vitest run"
-};
-/**
-* Detect the package manager used in a project by inspecting the root directory.
-*
-* @remarks
-* Detection order:
-* 1. The `packageManager` field in `package.json` (e.g., `"pnpm\@10.32.1"`)
-* 2. Lockfile presence: `pnpm-lock.yaml`, `package-lock.json`, `yarn.lock`, `bun.lock`
-*
-* Returns `null` when no package manager can be determined.
-*
-* @param root - Absolute path to the project root directory
-* @param fs - Filesystem adapter for reading files and checking existence
-* @returns The detected package manager, or `null`
-*
-* @internal
-*/
-async function detectPackageManager(root, fs) {
-	try {
-		const raw = await fs.readFile(`${root}/package.json`);
-		const pkg = JSON.parse(raw);
-		if (pkg.packageManager) {
-			const name = pkg.packageManager.split("@")[0];
-			if (name in RUN_COMMANDS) return name;
-		}
-	} catch {}
-	for (const [lockfile, pm] of LOCKFILE_MAP) if (await fs.exists(`${root}/${lockfile}`)) return pm;
-	return null;
-}
-/**
-* Return the vitest run command for the given package manager.
-*
-* Falls back to `"npx vitest run"` when `pm` is `null`.
-*
-* @param pm - Detected package manager, or `null` for unknown
-* @returns Shell command string for running vitest
-*
-* @internal
-*/
-function getRunCommand(pm) {
-	if (!pm) return "npx vitest run";
-	return RUN_COMMANDS[pm];
-}
-
-export { detectPackageManager, getRunCommand };