@vitest-agent/sdk 2.4.13 → 2.5.1

package/utils/detect-non-default-discover-strategy.js

@@ -0,0 +1,38 @@
+//#region src/utils/detect-non-default-discover-strategy.ts
+/**
+* Cheaply strips `//` line comments and `/* *\/` block comments from `source`.
+*
+* Not a full lexer — a marker string that happens to sit inside a string
+* literal containing comment-like syntax could slip through uncaught. That
+* false positive is acceptable: {@link detectNonDefaultDiscoverStrategy} is
+* only ever used to decide whether to fail open, and failing open is the
+* safe direction.
+*/
+function stripComments(source) {
+	return source.replace(/\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g, "").replace(/\/\/.*$/gm, "");
+}
+const DISCOVER_STRATEGY_OPTION_RE = /\bdiscoverStrategy\s*:/;
+const ADD_PROJECT_MARKER = ".addProject(";
+const EXTENDS_DEFAULT_STRATEGY_RE = /\bextends\s+DefaultDiscoverStrategy\b/;
+const IMPLEMENTS_STRATEGY_RE = /\bimplements\s+DiscoverStrategy\b/;
+/**
+* Lexically detects whether a Vitest/Vite config source text appears to
+* configure a non-default `DiscoverStrategy` — a custom `discoverStrategy`
+* option (including `discoverStrategy: false`), an `AgentPlugin.discover()`
+* `.addProject(...)` chain, or a class extending `DefaultDiscoverStrategy` /
+* implementing `DiscoverStrategy`.
+*
+* Pure and comment-tolerant (best-effort): a marker mentioned only inside a
+* comment may still register as a false positive if it isn't caught by the
+* comment-stripping pass. That is intentional — this function only ever
+* decides whether to fail open, so a false positive is harmless while a
+* false negative would produce a confidently wrong deny.
+* @public
+*/
+function detectNonDefaultDiscoverStrategy(source) {
+	const stripped = stripComments(source);
+	return DISCOVER_STRATEGY_OPTION_RE.test(stripped) || stripped.includes(ADD_PROJECT_MARKER) || EXTENDS_DEFAULT_STRATEGY_RE.test(stripped) || IMPLEMENTS_STRATEGY_RE.test(stripped);
+}
+
+//#endregion
+export { detectNonDefaultDiscoverStrategy };

package/utils/format-console.js

@@ -1,4 +1,5 @@
 import { ansi } from "./ansi.js";
+import { formatScopedCoverageNote } from "./format-scoped-coverage-note.js";
 
 //#region src/utils/format-console.ts
 /**
@@ -161,6 +162,10 @@ function formatConsoleMarkdown(report, options) {
 	if (report.coverage) {
 		const cov = report.coverage;
 		const globalThresholds = cov.thresholds.global;
+		if (cov.scoped) {
+			lines.push(formatScopedCoverageNote(cov.scopedFiles?.length ?? 0, cov.totalFiles));
+			lines.push("");
+		}
 		const filesToShow = cov.lowCoverage.slice(0, coverageConsoleLimit);
 		if (filesToShow.length > 0) {
 			lines.push(`### Coverage gaps`);

package/utils/format-scoped-coverage-note.js

@@ -0,0 +1,25 @@
+//#region src/utils/format-scoped-coverage-note.ts
+/**
+* Format the informational note shown when coverage thresholds were
+* skipped because a run only exercised a subset of the project's test
+* files (issue #160). Vitest's coverage provider enforces
+* `coverage.thresholds` against the whole-project denominator
+* regardless of how many files actually ran, so callers that detect a
+* scoped/partial run suppress the native threshold check and surface
+* this note instead so the agent understands why no pass/fail verdict
+* was rendered for coverage.
+*
+* @param testedFileCount - number of test files that actually ran
+* @param totalFileCount - total number of test files in the project, when
+*   known. Some callers (formatters working from a persisted
+*   `CoverageReport`, which tracks only the tested-file list) cannot supply
+*   this; the note degrades to `"(N test files)"` when omitted.
+* @returns the note text, e.g. `"Coverage thresholds skipped: partial run (2 of 47 test files)"`
+* @public
+*/
+function formatScopedCoverageNote(testedFileCount, totalFileCount) {
+	return `Coverage thresholds skipped: partial run (${totalFileCount !== void 0 ? `${testedFileCount} of ${totalFileCount}` : `${testedFileCount}`} test files)`;
+}
+
+//#endregion
+export { formatScopedCoverageNote };

package/utils/format-terminal.js

@@ -1,4 +1,5 @@
 import { ansi } from "./ansi.js";
+import { formatScopedCoverageNote } from "./format-scoped-coverage-note.js";
 import { relativePath } from "./format-console.js";
 import { compressLines } from "./compress-lines.js";
 
@@ -257,6 +258,9 @@ const aggregateCoverage = (reports) => {
 	let hasCoverage = false;
 	let thresholdsGlobal;
 	let targetsGlobal;
+	let scoped = false;
+	let scopedFileCount = 0;
+	let totalFiles;
 	const belowTargetByFile = /* @__PURE__ */ new Map();
 	const belowThresholdByFile = /* @__PURE__ */ new Map();
 	for (const r of reports) {
@@ -265,6 +269,11 @@ const aggregateCoverage = (reports) => {
 		hasCoverage = true;
 		thresholdsGlobal ??= cov.thresholds.global;
 		targetsGlobal ??= cov.targets?.global;
+		if (cov.scoped) {
+			scoped = true;
+			scopedFileCount = Math.max(scopedFileCount, cov.scopedFiles?.length ?? 0);
+			if (cov.totalFiles !== void 0) totalFiles = cov.totalFiles;
+		}
 		if (cov.lowCoverage) {
 			for (const f of cov.lowCoverage) if (!belowThresholdByFile.has(f.file)) belowThresholdByFile.set(f.file, f);
 		}
@@ -279,8 +288,11 @@ const aggregateCoverage = (reports) => {
 		thresholdsMet: belowThresholdCount === 0,
 		belowThresholdCount,
 		belowTargetFiles,
+		scoped,
+		scopedFileCount,
 		...thresholdsGlobal !== void 0 ? { thresholdsGlobal } : {},
-		...targetsGlobal !== void 0 ? { targetsGlobal } : {}
+		...targetsGlobal !== void 0 ? { targetsGlobal } : {},
+		...totalFiles !== void 0 ? { totalFiles } : {}
 	};
 };
 /**
@@ -294,7 +306,8 @@ const renderCoverageSection = (reports, options, ao) => {
 	const lines = [];
 	const thresholdSpec = agg.thresholdsGlobal ? formatTargetSpec(agg.thresholdsGlobal) : "";
 	const targetSpec = agg.targetsGlobal ? formatTargetSpec(agg.targetsGlobal) : "";
-	if (!agg.thresholdsMet) {
+	if (agg.scoped) lines.push(formatScopedCoverageNote(agg.scopedFileCount, agg.totalFiles));
+	else if (!agg.thresholdsMet) {
 		const cross = ansi("✗", "red", ao);
 		const fileWord = agg.belowThresholdCount === 1 ? "file" : "files";
 		lines.push(`Coverage: ${cross} ${agg.belowThresholdCount} ${fileWord} below minimum thresholds${thresholdSpec ? ` (${thresholdSpec})` : ""}`);

package/utils/validate-phase-transition.js

@@ -55,6 +55,19 @@ const validatePhaseTransition = (ctx) => {
 			humanHint: `Cannot transition from '${ctx.current_phase}' directly to 'green'. The red phase must be entered explicitly first (${ctx.current_phase}→red), then a failing test written and run, then red→green requested with a test_failed_run artifact.`
 		}
 	};
+	if (ctx.requested_phase === "refactor" && ctx.current_phase !== "green" && ctx.current_phase !== "green.fake-it") {
+		const canEnterGreen = ctx.current_phase === "red" || ctx.current_phase === "red.triangulate";
+		return {
+			accepted: false,
+			phase: ctx.current_phase,
+			denialReason: "refactor_without_passing_run",
+			remediation: {
+				suggestedTool: "tdd_phase_transition_request",
+				suggestedArgs: { requestedPhase: canEnterGreen ? "green" : "red" },
+				humanHint: canEnterGreen ? `Cannot transition from '${ctx.current_phase}' directly to 'refactor'. The green phase must be entered first (${ctx.current_phase}→green with a test_failed_run artifact), then green→refactor requested with a test_passed_run artifact.` : `Cannot transition from '${ctx.current_phase}' directly to 'refactor'. Enter red first (${ctx.current_phase}→red), write and run a failing test, request red→green with a test_failed_run artifact, then green→refactor with a test_passed_run artifact.`
+			}
+		};
+	}
 	const isTriangulateGreen = ctx.current_phase === "red.triangulate" && ctx.requested_phase === "green";
 	const expected = requiredArtifactForTransition(ctx.current_phase, ctx.requested_phase);
 	if (expected === null) return {
@@ -71,28 +84,29 @@ const validatePhaseTransition = (ctx) => {
 			humanHint: expected.humanHint
 		}
 	};
-	if (ctx.cited_artifact.test_case_id === null) return {
+	const isBatsRunLevel = ctx.cited_artifact.test_case_id === null && (ctx.cited_artifact.suite ?? "vitest") === "bats";
+	if (ctx.cited_artifact.test_case_id === null && !isBatsRunLevel) return {
 		accepted: false,
 		phase: ctx.current_phase,
 		denialReason: "missing_artifact_evidence",
 		remediation: {
 			suggestedTool: "run_tests",
 			suggestedArgs: {},
-			humanHint: "The cited artifact has no specific test (test_case_id is null), so it cannot be bound to this phase. Run a specific failing test via run_tests so the resulting artifact carries a test_case_id, then cite that artifact."
+			humanHint: "The cited artifact is run-level (test_case_id is null) and its suite is 'vitest', so it cannot be bound to this phase — only bats-suite run-level artifacts are accepted without a specific test. Run a specific failing test via run_tests so the resulting artifact carries a test_case_id, then cite that artifact."
 		}
 	};
-	if (expected.kind === "test_failed_run") {
-		if (!isTriangulateGreen && ctx.cited_artifact.test_case_created_turn_at !== null && ctx.cited_artifact.test_case_created_turn_at < ctx.phase_started_at) return {
+	if (expected.kind === "test_failed_run" || isBatsRunLevel && expected.kind === "test_passed_run") {
+		if (!isTriangulateGreen && ctx.current_phase_id !== null && ctx.cited_artifact.phase_id !== ctx.current_phase_id) return {
 			accepted: false,
 			phase: ctx.current_phase,
 			denialReason: "evidence_not_in_phase_window",
 			remediation: {
 				suggestedTool: "run_tests",
 				suggestedArgs: {},
-				humanHint: "The cited test was authored before this phase started. Write a new failing test inside the current phase."
+				humanHint: "The cited artifact was recorded in a different phase than the one currently open. Run the failing test again inside the current phase so a fresh test_failed_run artifact is bound to it."
 			}
 		};
-		if (!ctx.cited_artifact.test_case_authored_in_session) return {
+		if (!isBatsRunLevel && !ctx.cited_artifact.test_case_authored_in_session) return {
 			accepted: false,
 			phase: ctx.current_phase,
 			denialReason: "evidence_not_in_phase_window",