@vitest-agent/mcp 1.0.0

package/resources/indexes.js

@@ -0,0 +1,77 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/resources/indexes.ts
+async function listMarkdownPages(root) {
+	const out = [];
+	async function walk(rel) {
+		const entries = await readdir(join(root, rel), { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+			const next = rel ? `${rel}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) await walk(next);
+			else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "ATTRIBUTION.md") out.push(next.replace(/\.md$/, ""));
+		}
+	}
+	await walk("");
+	out.sort();
+	return out;
+}
+async function renderUpstreamIndex(vendorRoot) {
+	const manifestRaw = await readFile(join(vendorRoot, "manifest.json"), "utf8");
+	const manifest = JSON.parse(manifestRaw);
+	const pages = await listMarkdownPages(vendorRoot);
+	const grouped = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const slash = page.indexOf("/");
+		const section = slash === -1 ? "root" : page.slice(0, slash);
+		const list = grouped.get(section) ?? [];
+		list.push(page);
+		grouped.set(section, list);
+	}
+	const lines = [];
+	lines.push("# Vitest Documentation (Upstream Snapshot)");
+	lines.push("");
+	lines.push(`Snapshotted from [vitest-dev/vitest](https://github.com/vitest-dev/vitest) at tag \`${manifest.tag}\` (commit \`${manifest.commitSha.slice(0, 12)}\`).`);
+	lines.push("");
+	lines.push("Fetch any page by URI: `vitest://docs/<path>` (e.g., `vitest://docs/api/mock`).");
+	lines.push("");
+	const sections = [...grouped.keys()].sort();
+	for (const section of sections) {
+		lines.push(`## ${section}`);
+		lines.push("");
+		for (const page of grouped.get(section) ?? []) {
+			const display = page.startsWith(`${section}/`) ? page.slice(section.length + 1) : page;
+			lines.push(`- \`vitest://docs/${page}\` — ${display}`);
+		}
+		lines.push("");
+	}
+	return {
+		content: lines.join("\n"),
+		mimeType: "text/markdown"
+	};
+}
+async function renderPatternsIndex(patternsRoot) {
+	const metaRaw = await readFile(join(patternsRoot, "_meta.json"), "utf8");
+	const meta = JSON.parse(metaRaw);
+	const lines = [];
+	lines.push("# vitest-agent Curated Patterns");
+	lines.push("");
+	lines.push("Hand-written patterns specific to the vitest-agent project. Fetch any pattern by URI: `vitest-agent://patterns/<slug>`.");
+	lines.push("");
+	for (const pattern of meta.patterns) {
+		lines.push(`## ${pattern.title}`);
+		lines.push("");
+		lines.push(pattern.summary);
+		lines.push("");
+		lines.push(`- URI: \`vitest-agent://patterns/${pattern.slug}\``);
+		lines.push("");
+	}
+	return {
+		content: lines.join("\n"),
+		mimeType: "text/markdown"
+	};
+}
+
+//#endregion
+export { renderPatternsIndex, renderUpstreamIndex };

package/resources/manifest-schema.js

@@ -0,0 +1,46 @@
+import { Schema } from "effect";
+
+//#region src/resources/manifest-schema.ts
+const RELATIVE_PATH = /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+/**
+* MCP 2025-11-25 resource annotations. Both sub-fields are optional so a
+* partially-annotated manifest decodes cleanly during an editorial pass.
+*
+* `audience` is the set of client roles a resource is relevant to; today
+* only `assistant` is meaningful for the vitest-agent MCP server.
+* `priority` is a float in [0, 1] that lets a client rank or filter
+* results before pulling content into context. See the editorial guide
+* in `docs/superpowers/specs/2.0-resource-annotations.md` for the
+* priority bands per content type.
+*/
+const ResourceAnnotations = Schema.Struct({
+	audience: Schema.optional(Schema.Array(Schema.Literal("user", "assistant"))),
+	priority: Schema.optional(Schema.Number.pipe(Schema.between(0, 1)))
+});
+const ManifestPage = Schema.Struct({
+	path: Schema.String.pipe(Schema.pattern(RELATIVE_PATH)),
+	title: Schema.NonEmptyString,
+	description: Schema.NonEmptyString,
+	annotations: Schema.optional(ResourceAnnotations)
+});
+const UpstreamManifest = Schema.Struct({
+	tag: Schema.NonEmptyString,
+	commitSha: Schema.NonEmptyString,
+	capturedAt: Schema.NonEmptyString,
+	source: Schema.NonEmptyString,
+	pages: Schema.optional(Schema.Array(ManifestPage))
+});
+const decodeUpstreamManifest = Schema.decodeUnknown(UpstreamManifest);
+const encodeUpstreamManifest = Schema.encodeUnknown(UpstreamManifest);
+const SLUG_PATTERN = /^[A-Za-z0-9._]+(?:[/-][A-Za-z0-9._]+)*$/;
+const PatternEntry = Schema.Struct({
+	slug: Schema.String.pipe(Schema.pattern(SLUG_PATTERN)),
+	title: Schema.NonEmptyString,
+	summary: Schema.NonEmptyString,
+	annotations: Schema.optional(ResourceAnnotations)
+});
+const PatternsManifest = Schema.Struct({ patterns: Schema.Array(PatternEntry) });
+const decodePatternsManifest = Schema.decodeUnknown(PatternsManifest);
+
+//#endregion
+export { decodePatternsManifest, decodeUpstreamManifest };

package/resources/paths.js

@@ -0,0 +1,20 @@
+import { isAbsolute, normalize, resolve, sep } from "node:path";
+
+//#region src/resources/paths.ts
+/**
+* Resolves a user-provided relative path against a vendored root,
+* appending `.md` if missing and rejecting traversal attempts.
+*/
+function resolveResourcePath(root, relativePath) {
+	if (relativePath === "") return root;
+	if (relativePath.includes("\0")) throw new Error("path contains null byte");
+	if (isAbsolute(relativePath)) throw new Error("absolute path not allowed");
+	const stripped = relativePath.replace(/^\/+/, "");
+	const resolved = resolve(root, normalize(stripped.endsWith(".md") ? stripped : `${stripped}.md`));
+	const rootWithSep = root.endsWith(sep) ? root : `${root}${sep}`;
+	if (!resolved.startsWith(rootWithSep) && resolved !== root) throw new Error("path escapes vendor root");
+	return resolved;
+}
+
+//#endregion
+export { resolveResourcePath };

package/resources/patterns.js

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/resources/patterns.ts
+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+async function readPattern(patternsRoot, slug) {
+	if (!SLUG_PATTERN.test(slug)) throw new Error(`invalid slug: ${slug}`);
+	const absPath = join(patternsRoot, `${slug}.md`);
+	try {
+		return {
+			content: await readFile(absPath, "utf8"),
+			mimeType: "text/markdown"
+		};
+	} catch (err) {
+		const code = err.code;
+		if (code === "ENOENT" || code === "EISDIR") throw new Error(`pattern not found: ${slug}. See vitest-agent://patterns/ for the index.`);
+		throw err;
+	}
+}
+
+//#endregion
+export { readPattern };

package/resources/upstream-docs.js

@@ -0,0 +1,22 @@
+import { resolveResourcePath } from "./paths.js";
+import { readFile } from "node:fs/promises";
+
+//#region src/resources/upstream-docs.ts
+async function readUpstreamDoc(vendorRoot, relativePath) {
+	const absPath = resolveResourcePath(vendorRoot, relativePath);
+	let content;
+	try {
+		content = await readFile(absPath, "utf8");
+	} catch (err) {
+		const code = err.code;
+		if (code === "ENOENT" || code === "EISDIR") throw new Error(`upstream doc not found: ${relativePath}`);
+		throw err;
+	}
+	return {
+		content,
+		mimeType: "text/markdown"
+	};
+}
+
+//#endregion
+export { readUpstreamDoc };

package/router.js

@@ -0,0 +1,74 @@
+import { router } from "./context.js";
+import { acceptanceMetrics } from "./tools/acceptance-metrics.js";
+import { cacheHealth } from "./tools/cache-health.js";
+import { commitChanges } from "./tools/commit-changes.js";
+import { configure } from "./tools/configure.js";
+import { testCoverage } from "./tools/coverage.js";
+import { testErrors } from "./tools/errors.js";
+import { failureSignatureGet } from "./tools/failure-signature-get.js";
+import { fileCoverage } from "./tools/file-coverage.js";
+import { help } from "./tools/help.js";
+import { testHistory } from "./tools/history.js";
+import { hypothesis } from "./tools/hypothesis.js";
+import { inventory } from "./tools/inventory.js";
+import { note } from "./tools/note.js";
+import { testOverview } from "./tools/overview.js";
+import { ping } from "./tools/ping.js";
+import { registerAgent } from "./tools/register-agent.js";
+import { runTests } from "./tools/run-tests.js";
+import { settingsList } from "./tools/settings-list.js";
+import { testStatus } from "./tools/status.js";
+import { tddArtifactList } from "./tools/tdd-artifact.js";
+import { tddBehavior } from "./tools/tdd-behavior.js";
+import { tddGoal } from "./tools/tdd-goal.js";
+import { tddPhaseTransitionRequest } from "./tools/tdd-phase-transition-request.js";
+import { tddTask } from "./tools/tdd-task.js";
+import { test } from "./tools/test.js";
+import { testTrends } from "./tools/trends.js";
+import { triageBrief } from "./tools/triage-brief.js";
+import { turnSearch } from "./tools/turn-search.js";
+import { wrapupPrompt } from "./tools/wrapup-prompt.js";
+
+//#region src/router.ts
+/**
+* The tRPC router aggregating all MCP tool procedures.
+*
+* Pass to `createCallerFactory` in tests, or to `createCallerFactory(appRouter)`
+* followed by `startMcpServer` in the bin entry to start the MCP server.
+*
+* @public
+*/
+const appRouter = router({
+	help,
+	test_status: testStatus,
+	test_overview: testOverview,
+	test_coverage: testCoverage,
+	test_history: testHistory,
+	test_trends: testTrends,
+	test_errors: testErrors,
+	test,
+	file_coverage: fileCoverage,
+	run_tests: runTests,
+	register_agent: registerAgent,
+	cache_health: cacheHealth,
+	configure,
+	inventory,
+	settings_list: settingsList,
+	note,
+	turn_search: turnSearch,
+	failure_signature_get: failureSignatureGet,
+	tdd_task: tddTask,
+	tdd_phase_transition_request: tddPhaseTransitionRequest,
+	tdd_goal: tddGoal,
+	tdd_behavior: tddBehavior,
+	tdd_artifact_list: tddArtifactList,
+	hypothesis,
+	acceptance_metrics: acceptanceMetrics,
+	triage_brief: triageBrief,
+	wrapup_prompt: wrapupPrompt,
+	commit_changes: commitChanges,
+	ping
+});
+
+//#endregion
+export { appRouter };