@vitest-agent/mcp 1.0.0

package/tools/register-agent.js

@@ -0,0 +1,135 @@
+import { publicProcedure } from "../context.js";
+import { DataReader, DataStore, deriveIdempotencyKey } from "@vitest-agent/sdk";
+import { Effect, Option, Schema } from "effect";
+
+//#region src/tools/register-agent.ts
+/**
+* `register_agent` MCP tool.
+*
+* Idempotently inserts an `agents` row in the per-project store.
+* Cross-client by design: the input takes a generic `hostKind`
+* (default-resolved from `clientInfo.name` at the MCP boundary in a
+* follow-up; the tool itself defaults to `"claude-code"` for now)
+* and the canonical UUID-typed `chatId` / `conversationId` /
+* `parentAgentId` brands.
+*
+* Returns the resolved `agentId` on success or
+* `{ ok: false, error: { code, ...details } }` for the four
+* documented error codes:
+*
+*   - `AGENT_ALREADY_REGISTERED` — idempotency hit; carries
+*     `existingAgentId` so the caller proceeds with the recovered ID.
+*   - `PARENT_AGENT_NOT_FOUND` — `parentAgentId` references an agent
+*     not in the named session.
+*   - `SESSION_NOT_FOUND` — the integer FK could not be resolved
+*     from `chatId` (host has not called the SessionStart equivalent
+*     yet).
+*   - `INVALID_AGENT_TYPE_PREFIX` — `agentType` does not start with
+*     `${hostKind}-`.
+*
+* The success-with-info `IdempotencyHit` from the SDK collapses into
+* `AGENT_ALREADY_REGISTERED` here so MCP clients see one shape per
+* outcome.
+*/
+const RegisterAgentInput = Schema.Struct({
+	chatId: Schema.String,
+	conversationId: Schema.optional(Schema.String),
+	hostKind: Schema.optional(Schema.String),
+	agentType: Schema.String,
+	parentAgentId: Schema.optional(Schema.String),
+	clientNonce: Schema.optional(Schema.String),
+	startGitBranch: Schema.optional(Schema.String),
+	startGitCommitSha: Schema.optional(Schema.String),
+	startWorktreeDir: Schema.optional(Schema.String)
+});
+const RegisterAgentSuccess = Schema.Struct({
+	ok: Schema.Literal(true).annotations({ description: "Discriminant — `true` when the agent row was inserted (or an existing one recovered)." }),
+	agentId: Schema.String.annotations({
+		title: "agents.agent_id",
+		description: "Canonical UUID for the registered agent — pass to subsequent attribution-bearing calls."
+	}),
+	conversationId: Schema.NullOr(Schema.String).annotations({ description: "Conversation UUID from the host's transcript when one was supplied; `null` otherwise." }),
+	idempotencyKey: Schema.String.annotations({ description: "26-char base32 SHA-256 of (agentType, parentAgentId|sentinel, clientNonce). Stable across retries with identical input." })
+}).annotations({ identifier: "RegisterAgentSuccess" });
+const RegisterAgentFailure = Schema.Struct({
+	ok: Schema.Literal(false).annotations({ description: "Discriminant — `false` when registration was refused." }),
+	error: Schema.Struct({
+		code: Schema.Literal("AGENT_ALREADY_REGISTERED", "PARENT_AGENT_NOT_FOUND", "SESSION_NOT_FOUND", "INVALID_AGENT_TYPE_PREFIX").annotations({ description: "Refusal reason. AGENT_ALREADY_REGISTERED carries `existingAgentId` so the caller can recover. INVALID_AGENT_TYPE_PREFIX carries `expectedPrefix`." }),
+		message: Schema.String.annotations({ description: "Human-readable refusal explanation." }),
+		existingAgentId: Schema.optional(Schema.String).annotations({ description: "Present only when `code = AGENT_ALREADY_REGISTERED`. Use this id instead of registering a new one." }),
+		expectedPrefix: Schema.optional(Schema.String).annotations({ description: "Present only when `code = INVALID_AGENT_TYPE_PREFIX`. The required `<hostKind>-` prefix." })
+	})
+}).annotations({ identifier: "RegisterAgentFailure" });
+const RegisterAgentResult = Schema.Union(RegisterAgentSuccess, RegisterAgentFailure).annotations({
+	identifier: "RegisterAgentResult",
+	title: "register_agent result",
+	description: "Discriminate on `ok`. The four failure codes are documented per their `code` literal."
+});
+const registerAgent = publicProcedure.input(Schema.standardSchemaV1(RegisterAgentInput)).mutation(async ({ ctx, input }) => {
+	const expectedPrefix = `${input.hostKind ?? "claude-code"}-`;
+	if (!input.agentType.startsWith(expectedPrefix)) return {
+		ok: false,
+		error: {
+			code: "INVALID_AGENT_TYPE_PREFIX",
+			message: `agentType "${input.agentType}" must start with "${expectedPrefix}"`,
+			expectedPrefix
+		}
+	};
+	const clientNonce = input.clientNonce ?? `${input.chatId}|${input.agentType}|${input.parentAgentId ?? "__ROOT__"}`;
+	const idempotencyKey = deriveIdempotencyKey({
+		agentType: input.agentType,
+		parentAgentId: input.parentAgentId ?? null,
+		clientNonce
+	});
+	return ctx.runtime.runPromise(Effect.gen(function* () {
+		const reader = yield* DataReader;
+		const store = yield* DataStore;
+		const sessionOpt = yield* reader.getSessionByChatId(input.chatId);
+		if (Option.isNone(sessionOpt)) return {
+			ok: false,
+			error: {
+				code: "SESSION_NOT_FOUND",
+				message: `chat ${input.chatId} has not been registered; the host must call its SessionStart equivalent first`
+			}
+		};
+		const sessionRowId = sessionOpt.value.id;
+		const result = yield* store.registerAgent({
+			sessionId: sessionRowId,
+			agentType: input.agentType,
+			parentAgentId: input.parentAgentId ?? null,
+			conversationId: input.conversationId ?? null,
+			startedAt: Math.floor(Date.now() / 1e3),
+			...input.startGitBranch !== void 0 && { startGitBranch: input.startGitBranch },
+			...input.startGitCommitSha !== void 0 && { startGitCommitSha: input.startGitCommitSha },
+			...input.startWorktreeDir !== void 0 && { startWorktreeDir: input.startWorktreeDir },
+			idempotencyKey
+		}).pipe(Effect.catchTag("RegistrationConflictError", (e) => Effect.succeed({
+			_tag: "Conflict",
+			reason: e.reason
+		})));
+		if ("_tag" in result && result._tag === "Conflict") return {
+			ok: false,
+			error: {
+				code: "PARENT_AGENT_NOT_FOUND",
+				message: result.reason
+			}
+		};
+		if ("_tag" in result && result._tag === "IdempotencyHit") return {
+			ok: false,
+			error: {
+				code: "AGENT_ALREADY_REGISTERED",
+				message: "agent already registered for (chatId, agentType, parentAgentId, clientNonce); use existingAgentId",
+				existingAgentId: result.existingAgentId
+			}
+		};
+		return {
+			ok: true,
+			agentId: result.agentId,
+			conversationId: result.conversationId,
+			idempotencyKey: result.idempotencyKey
+		};
+	}));
+});
+
+//#endregion
+export { RegisterAgentResult, registerAgent };

package/tools/run-tests.js

@@ -0,0 +1,359 @@
+import { publicProcedure } from "../context.js";
+import { AgentReport, DataReader, DataStore, buildAgentReport } from "@vitest-agent/sdk";
+import { Effect, ParseResult, Schema } from "effect";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Writable } from "node:stream";
+
+//#region src/tools/run-tests.ts
+const RunTestsOk = Schema.Struct({
+	kind: Schema.Literal("ok").annotations({ description: "Discriminant — `true` test run completed (with or without failures)." }),
+	project: Schema.optional(Schema.String),
+	report: AgentReport.annotations({ description: "Full AgentReport including pass/fail counts and per-module errors." }),
+	classifications: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}).annotations({ description: "Per-test classification labels: stable, new-failure, persistent, flaky, recovered." })
+}).annotations({ identifier: "RunTestsOk" });
+const RunTestsTimeout = Schema.Struct({
+	kind: Schema.Literal("timeout"),
+	timeoutSeconds: Schema.Number
+}).annotations({ identifier: "RunTestsTimeout" });
+const RunTestsError = Schema.Struct({
+	kind: Schema.Literal("error"),
+	message: Schema.String
+}).annotations({ identifier: "RunTestsError" });
+const TagFilter = Schema.Struct({
+	all: Schema.optional(Schema.Array(Schema.String)),
+	any: Schema.optional(Schema.Array(Schema.String)),
+	none: Schema.optional(Schema.Array(Schema.String))
+}).annotations({
+	identifier: "TagFilter",
+	description: "All three sub-filters AND together with `project` and `files`. `all` requires every listed tag on the test. `any` requires at least one. `none` excludes any test carrying a listed tag."
+});
+const RunTestsNoMatch = Schema.Struct({
+	kind: Schema.Literal("no-match").annotations({ description: "Discriminant — the resolved filter set matched zero test cases. Tests did not run; this is independent of passWithNoTests policy." }),
+	filter: Schema.Struct({
+		project: Schema.NullOr(Schema.String),
+		files: Schema.Array(Schema.String),
+		tags: Schema.NullOr(TagFilter),
+		resolvedExpression: Schema.NullOr(Schema.String)
+	})
+}).annotations({ identifier: "RunTestsNoMatch" });
+const RunTestsResult = Schema.Union(RunTestsOk, RunTestsTimeout, RunTestsError, RunTestsNoMatch).annotations({
+	identifier: "RunTestsResult",
+	title: "run_tests result",
+	description: "Discriminate on `kind`. ok carries the full AgentReport plus per-test classifications; timeout / error are the two failure modes; no-match indicates that the resolved filter set matched zero test cases."
+});
+/**
+* Compose a Vitest tag-expression string from a structured {@link TagFilter}.
+*
+* Returns `null` when every sub-filter is empty/absent. Combines the three
+* sub-filters with ` and `:
+*
+* - `all: ["int", "slow"]`   → `"int and slow"`
+* - `any: ["unit", "int"]`   → `"(unit or int)"`
+* - `none: ["slow", "flaky"]`→ `"not slow and not flaky"`
+*
+* @internal
+*/
+function composeTagExpression(tags) {
+	if (!tags) return null;
+	const parts = [];
+	const all = tags.all ?? [];
+	const any = tags.any ?? [];
+	const none = tags.none ?? [];
+	if (all.length > 0) parts.push(all.join(" and "));
+	if (any.length > 0) parts.push(any.length === 1 ? any[0] : `(${any.join(" or ")})`);
+	if (none.length > 0) parts.push(none.map((t) => `not ${t}`).join(" and "));
+	if (parts.length === 0) return null;
+	return parts.join(" and ");
+}
+const FORBIDDEN_CHARS = /[;|&`$(){}[\]<>!#]/;
+const stdoutSinkStorage = new AsyncLocalStorage();
+const stderrSinkStorage = new AsyncLocalStorage();
+let _stdioPatched = false;
+let _originalStdoutWrite;
+let _originalStderrWrite;
+function ensureStdioPatched() {
+	if (_stdioPatched) return;
+	_stdioPatched = true;
+	_originalStdoutWrite = process.stdout.write;
+	_originalStderrWrite = process.stderr.write;
+	process.stdout.write = function patchedStdoutWrite(...args) {
+		const sink = stdoutSinkStorage.getStore();
+		if (sink) return sink.write.apply(sink, args);
+		return _originalStdoutWrite.apply(this, args);
+	};
+	process.stderr.write = function patchedStderrWrite(...args) {
+		const sink = stderrSinkStorage.getStore();
+		if (sink) return sink.write.apply(sink, args);
+		return _originalStderrWrite.apply(this, args);
+	};
+}
+/**
+* Run `fn` with `process.stdout.write` and `process.stderr.write`
+* diverted to `stream.write` for code executing inside the call's
+* async context. Code in other async contexts (concurrent tRPC
+* procedure handlers, the MCP stdio transport) sees the original
+* writes unchanged.
+*
+* Vitest's own stdout/stderr redirect options only cover Vitest-internal
+* logging. User-registered reporters that call `console.log` directly
+* bypass them; this helper captures those writes into the supplied
+* sink so they don't corrupt the JSON-RPC protocol stream.
+*
+* @internal
+*/
+async function withStdioCaptured(stream, fn) {
+	ensureStdioPatched();
+	return stdoutSinkStorage.run(stream, () => stderrSinkStorage.run(stream, fn));
+}
+function sanitizeTestArgs(args) {
+	const result = [];
+	for (const arg of args) {
+		if (FORBIDDEN_CHARS.test(arg)) throw new Error(`Unsafe argument rejected: ${arg}`);
+		result.push(arg);
+	}
+	return result;
+}
+let _runTestsChain = Promise.resolve();
+function serializeRunTests(fn) {
+	const next = _runTestsChain.then(fn, fn);
+	_runTestsChain = next.catch(() => void 0);
+	return next;
+}
+/**
+* Coerce unknown Vitest unhandled errors into VitestModuleError shape.
+*
+* @internal
+*/
+function coerceErrors(errors) {
+	return errors.map((e) => {
+		if (e && typeof e === "object" && "message" in e) {
+			const err = e;
+			return {
+				message: String(err.message),
+				...err.stacks ? { stacks: err.stacks } : err.stack ? { stacks: [err.stack] } : {}
+			};
+		}
+		return { message: String(e) };
+	});
+}
+/**
+* Render the full structured `RunTestsResult` as markdown for the
+* text channel. Discriminates on `kind` then defers to the existing
+* AgentReport rendering for the `ok` case.
+*/
+function formatRunTestsMarkdown(data) {
+	if (data.kind === "timeout") return `Test run timed out after ${data.timeoutSeconds} seconds.`;
+	if (data.kind === "error") return `Test run failed: ${data.message}`;
+	if (data.kind === "no-match") return formatNoMatchMarkdown(data.filter);
+	const classMap = new Map(Object.entries(data.classifications));
+	return formatReportMarkdown(data.report, classMap);
+}
+/**
+* Render the `no-match` filter context plus a remediation pointer aimed at
+* tag introspection. Pure helper; called by {@link formatRunTestsMarkdown}.
+*
+* @internal
+*/
+function formatNoMatchMarkdown(filter) {
+	const lines = ["## No tests matched the filter", ""];
+	const parts = [];
+	if (filter.project !== null) parts.push(`project: \`${filter.project}\``);
+	if (filter.files.length > 0) parts.push(`files: ${filter.files.map((f) => `\`${f}\``).join(", ")}`);
+	if (filter.tags !== null) {
+		const t = filter.tags;
+		if (t.all && t.all.length > 0) parts.push(`tags.all: ${t.all.map((s) => `\`${s}\``).join(", ")}`);
+		if (t.any && t.any.length > 0) parts.push(`tags.any: ${t.any.map((s) => `\`${s}\``).join(", ")}`);
+		if (t.none && t.none.length > 0) parts.push(`tags.none: ${t.none.map((s) => `\`${s}\``).join(", ")}`);
+	}
+	if (filter.resolvedExpression !== null) parts.push(`resolved expression: \`${filter.resolvedExpression}\``);
+	if (parts.length === 0) lines.push("- (no filter recorded)");
+	else for (const p of parts) lines.push(`- ${p}`);
+	lines.push("");
+	lines.push("### Next steps");
+	if (filter.tags !== null) {
+		lines.push("- Confirm the tag exists: `inventory({ kind: \"tag\" })`");
+		lines.push("- List tests for a specific tag: `test({ action: \"for_tag\", tag: \"<name>\" })`");
+	}
+	if (filter.files.length > 0) lines.push("- Verify file paths exist or list tests in a file with `test({ action: \"for_file\", filePath })`");
+	if (filter.project !== null) lines.push("- Verify the project name with `inventory({ kind: \"project\" })`");
+	return lines.join("\n");
+}
+const RunTestsAsMarkdown = Schema.transformOrFail(RunTestsResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatRunTestsMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "RunTestsAsMarkdown is one-way."))
+});
+/**
+* Format an AgentReport as concise markdown suitable for MCP tool output.
+*
+* Classifications map test fullName to labels like "new-failure",
+* "persistent", "flaky", "recovered", "stable". Populated from DB
+* after the reporter writes history.
+*
+* @internal
+*/
+function formatReportMarkdown(report, classifications) {
+	const lines = [];
+	const { summary } = report;
+	const collectionFailedFiles = report.failed.filter((m) => m.errors !== void 0 && m.errors.length > 0 && !m.tests.some((t) => t.state === "failed")).map((m) => m.file);
+	const hasCollectionFailures = collectionFailedFiles.length > 0;
+	const isFailing = summary.failed > 0 || report.unhandledErrors.length > 0 || hasCollectionFailures;
+	const status = isFailing ? "❌" : "✅";
+	const headlineParts = [];
+	if (summary.failed > 0) headlineParts.push(`${summary.failed} failed`);
+	if (hasCollectionFailures) headlineParts.push(`${collectionFailedFiles.length} failed to load`);
+	headlineParts.push(`${summary.passed} passed`);
+	if (summary.skipped > 0) headlineParts.push(`${summary.skipped} skipped`);
+	lines.push(`## ${status} Vitest -- ${headlineParts.join(", ")} (${summary.duration}ms)`);
+	if (report.project) lines.push(`\nProject: ${report.project}`);
+	for (const mod of report.failed) {
+		lines.push(`\n### \u274C \`${mod.file}\``);
+		if (mod.errors) for (const err of mod.errors) {
+			lines.push(`\n- \u274C **Module failed to load**: ${err.message}`);
+			if (err.stack) lines.push(`\n  \`\`\`\n  ${err.stack}\n  \`\`\``);
+		}
+		for (const test of mod.tests) {
+			if (test.state !== "failed") continue;
+			const badge = classifications?.get(test.fullName);
+			const label = badge ? ` [${badge}]` : "";
+			lines.push(`\n- \u274C **${test.fullName}**${label}`);
+			if (test.errors) for (const err of test.errors) {
+				lines.push(`  ${err.message}`);
+				if (err.diff) {
+					const diff = err.diff.length > 1e3 ? `${err.diff.slice(0, 1e3)}\n... (truncated, ${err.diff.length} chars total)` : err.diff;
+					lines.push(`\n  \`\`\`diff\n  ${diff}\n  \`\`\``);
+				}
+			}
+		}
+	}
+	if (report.unhandledErrors.length > 0) {
+		lines.push("\n### Unhandled Errors");
+		for (const err of report.unhandledErrors) {
+			lines.push(`\n- ${err.message}`);
+			if (err.stack) lines.push(`  \`\`\`\n  ${err.stack}\n  \`\`\``);
+		}
+	}
+	if (isFailing) {
+		const newFailures = classifications ? [...classifications.values()].filter((c) => c === "new-failure").length : 0;
+		const persistent = classifications ? [...classifications.values()].filter((c) => c === "persistent").length : 0;
+		const flaky = classifications ? [...classifications.values()].filter((c) => c === "flaky").length : 0;
+		lines.push("\n### Next steps\n");
+		if (newFailures > 0) lines.push(`- ${newFailures} new failure${newFailures > 1 ? "s" : ""} since last run`);
+		if (persistent > 0) lines.push(`- ${persistent} persistent failure${persistent > 1 ? "s" : ""} (pre-existing)`);
+		if (flaky > 0) lines.push(`- ${flaky} flaky test${flaky > 1 ? "s" : ""} -- consider retrying`);
+		lines.push("- Use test_errors for detailed error analysis");
+		lines.push("- Use test_history to check failure patterns");
+		if (report.failedFiles.length > 0) lines.push(`- Re-run failed: run_tests({ files: ${JSON.stringify(report.failedFiles)} })`);
+	}
+	return lines.join("\n");
+}
+const runTests = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+	files: Schema.optional(Schema.Array(Schema.String)),
+	project: Schema.optional(Schema.String),
+	tags: Schema.optional(TagFilter),
+	passWithNoTests: Schema.optional(Schema.Boolean),
+	timeout: Schema.optional(Schema.Number),
+	_sessionContext: Schema.optional(Schema.Struct({
+		chatId: Schema.String,
+		conversationId: Schema.String,
+		mainAgentId: Schema.String
+	}))
+}))).mutation(({ ctx, input }) => serializeRunTests(async () => {
+	const files = input.files ? sanitizeTestArgs(input.files) : [];
+	const project = input.project ? sanitizeTestArgs([input.project])[0] : void 0;
+	const tagsInput = input.tags;
+	if (tagsInput) {
+		if (tagsInput.all) sanitizeTestArgs(tagsInput.all);
+		if (tagsInput.any) sanitizeTestArgs(tagsInput.any);
+		if (tagsInput.none) sanitizeTestArgs(tagsInput.none);
+	}
+	const resolvedExpression = composeTagExpression(tagsInput ?? null);
+	const hasFilter = files.length > 0 || project !== void 0 || resolvedExpression !== null;
+	const timeoutMs = (input.timeout ?? 120) * 1e3;
+	const recovered = input._sessionContext ?? null ?? ctx.sessionContext.get();
+	if (recovered !== null) {
+		process.env.VITEST_AGENT_CHAT_ID = recovered.chatId;
+		process.env.VITEST_AGENT_CONVERSATION_ID = recovered.conversationId;
+		process.env.VITEST_AGENT_AGENT_ID = recovered.mainAgentId;
+	}
+	const nullStream = new Writable({ write(_chunk, _encoding, cb) {
+		cb();
+	} });
+	const { createVitest } = await import("vitest/node");
+	let vitest;
+	try {
+		vitest = await createVitest("test", {
+			root: ctx.cwd,
+			run: true,
+			...project ? { project } : {},
+			...resolvedExpression !== null ? { tagsFilter: [resolvedExpression] } : {},
+			...input.passWithNoTests !== void 0 ? { passWithNoTests: input.passWithNoTests } : {}
+		}, {}, {
+			stdout: nullStream,
+			stderr: nullStream
+		});
+		const localVitest = vitest;
+		let timeoutHandle;
+		const result = await withStdioCaptured(nullStream, () => Promise.race([localVitest.start(files.length > 0 ? files : void 0), new Promise((_, reject) => {
+			timeoutHandle = setTimeout(() => reject(/* @__PURE__ */ new Error("VITEST_TIMEOUT")), timeoutMs);
+		})]).finally(() => {
+			if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+		}));
+		const testModules = result.testModules;
+		const unhandledErrors = coerceErrors(result.unhandledErrors);
+		if (hasFilter && result.testModules.length === 0 && unhandledErrors.length === 0) return {
+			kind: "no-match",
+			filter: {
+				project: project ?? null,
+				files,
+				tags: tagsInput ?? null,
+				resolvedExpression
+			}
+		};
+		const report = buildAgentReport(testModules, unhandledErrors, unhandledErrors.length > 0 || result.testModules.some((m) => m.state() === "failed") ? "failed" : "passed", { omitPassingTests: true });
+		let classifications;
+		try {
+			classifications = await ctx.runtime.runPromise(Effect.gen(function* () {
+				const reader = yield* DataReader;
+				const projects = project ? [project] : yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs.map((r) => r.project)));
+				const entries = [];
+				for (const p of projects) {
+					const tests = yield* reader.listTests(p, {});
+					for (const t of tests) if (t.classification != null) entries.push([t.fullName, t.classification]);
+				}
+				return new Map(entries);
+			}));
+		} catch {}
+		const chatId = ctx.currentSessionId.get();
+		if (chatId !== null) ctx.runtime.runPromise(Effect.gen(function* () {
+			yield* (yield* DataStore).associateLatestRunWithSession({
+				chatId,
+				invocationMethod: "mcp"
+			});
+		})).catch(() => void 0);
+		return {
+			kind: "ok",
+			...project !== void 0 && { project },
+			report,
+			classifications: classifications ? Object.fromEntries(classifications) : {}
+		};
+	} catch (err) {
+		if (err instanceof Error && err.message === "VITEST_TIMEOUT") return {
+			kind: "timeout",
+			timeoutSeconds: input.timeout ?? 120
+		};
+		return {
+			kind: "error",
+			message: err instanceof Error ? err.message : String(err)
+		};
+	} finally {
+		await vitest?.close();
+		nullStream.destroy();
+	}
+}));
+
+//#endregion
+export { RunTestsAsMarkdown, RunTestsResult, runTests };

package/tools/settings-list.js

@@ -0,0 +1,48 @@
+import { publicProcedure } from "../context.js";
+import { DataReader } from "@vitest-agent/sdk";
+import { Effect, ParseResult, Schema } from "effect";
+
+//#region src/tools/settings-list.ts
+/**
+* `settings_list` MCP tool — Schema-driven implementation.
+*
+* @packageDocumentation
+*/
+const SettingsRow = Schema.Struct({
+	hash: Schema.String.annotations({ description: "Stable SHA-1 of the captured Vitest settings; FK target on test_runs." }),
+	capturedAt: Schema.String.annotations({ description: "ISO-8601 timestamp the settings row was first written." })
+}).annotations({ identifier: "SettingsListRow" });
+const SettingsListResult = Schema.Struct({
+	count: Schema.Number,
+	settings: Schema.Array(SettingsRow).annotations({ description: "Distinct captured settings hashes the reporter has written, newest first." })
+}).annotations({
+	identifier: "SettingsListResult",
+	title: "settings_list result",
+	description: "Roster of distinct Vitest settings hashes the reporter has captured."
+});
+const formatSettingsListMarkdown = (data) => {
+	if (data.settings.length === 0) return "No settings found. Run tests first.";
+	const lines = [
+		"## Settings",
+		"",
+		"| Hash | Timestamp |",
+		"| --- | --- |"
+	];
+	for (const s of data.settings) lines.push(`| ${s.hash} | ${s.capturedAt} |`);
+	return lines.join("\n");
+};
+const SettingsListAsMarkdown = Schema.transformOrFail(SettingsListResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatSettingsListMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "SettingsListAsMarkdown is one-way."))
+});
+const settingsList = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
+	const settings = yield* (yield* DataReader).listSettings();
+	return {
+		count: settings.length,
+		settings
+	};
+})));
+
+//#endregion
+export { SettingsListAsMarkdown, SettingsListResult, settingsList };

package/tools/status.js

@@ -0,0 +1,74 @@
+import { publicProcedure } from "../context.js";
+import { CacheManifestEntry, DataReader } from "@vitest-agent/sdk";
+import { Effect, Option, ParseResult, Schema } from "effect";
+
+//#region src/tools/status.ts
+/**
+* `test_status` MCP tool — Schema-driven implementation.
+*
+* @packageDocumentation
+*/
+const StatusAvailable = Schema.Struct({
+	dataAvailable: Schema.Literal(true).annotations({ description: "Discriminant — `true` when at least one project entry exists in the manifest." }),
+	manifestUpdatedAt: Schema.String,
+	projectFilter: Schema.optional(Schema.String).annotations({ description: "Echo of the optional `project` filter." }),
+	entries: Schema.Array(CacheManifestEntry).annotations({ description: "Per-project last-run summary rows. Filtered by `projectFilter` when set." })
+}).annotations({ identifier: "TestStatusAvailable" });
+const StatusAbsent = Schema.Struct({
+	dataAvailable: Schema.Literal(false).annotations({ description: "Discriminant — `false` when no manifest exists or the project filter matched nothing." }),
+	projectFilter: Schema.optional(Schema.String),
+	reason: Schema.Literal("no_manifest", "project_filter_empty")
+}).annotations({ identifier: "TestStatusAbsent" });
+const TestStatusResult = Schema.Union(StatusAvailable, StatusAbsent).annotations({
+	identifier: "TestStatusResult",
+	title: "test_status result",
+	description: "Per-project last-run summary. Discriminate on `dataAvailable` for cold-start handling."
+});
+const iconForResult = (r) => {
+	if (r === "passed") return "✅";
+	if (r === "failed") return "❌";
+	if (r === "interrupted") return "⚠️";
+	return "⬜";
+};
+const formatTestStatusMarkdown = (data) => {
+	if (!data.dataAvailable) {
+		if (data.reason === "project_filter_empty") return `No test data found for project \`${data.projectFilter ?? "(unknown)"}\`. Run tests first.`;
+		return "No test data available. Run tests first.";
+	}
+	const lines = ["# Test Status", ""];
+	for (const entry of data.entries) {
+		const lastRun = entry.lastRun ? new Date(entry.lastRun).toLocaleString() : "never";
+		lines.push(`- ${iconForResult(entry.lastResult)} **${entry.project}** — last run: ${lastRun}, result: ${entry.lastResult ?? "unknown"}`);
+	}
+	lines.push("", `_Cache updated: ${data.manifestUpdatedAt}_`);
+	return lines.join("\n");
+};
+const TestStatusAsMarkdown = Schema.transformOrFail(TestStatusResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(formatTestStatusMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestStatusAsMarkdown is one-way."))
+});
+const testStatus = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+	const manifestOpt = yield* (yield* DataReader).getManifest();
+	if (Option.isNone(manifestOpt)) return {
+		dataAvailable: false,
+		reason: "no_manifest",
+		...input.project !== void 0 && { projectFilter: input.project }
+	};
+	const manifest = manifestOpt.value;
+	const entries = input.project === void 0 ? manifest.projects : manifest.projects.filter((e) => e.project === input.project);
+	if (entries.length === 0) return {
+		dataAvailable: false,
+		reason: "project_filter_empty",
+		...input.project !== void 0 && { projectFilter: input.project }
+	};
+	return {
+		dataAvailable: true,
+		manifestUpdatedAt: manifest.updatedAt,
+		...input.project !== void 0 && { projectFilter: input.project },
+		entries
+	};
+})));
+
+//#endregion
+export { TestStatusAsMarkdown, TestStatusResult, testStatus };