@savvy-web/mcp 0.5.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "0.5.0",
+	"version": "1.0.0",
 	"private": false,
 	"description": "The savvy MCP server — Silk Suite tooling and library knowledge for coding agents",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/mcp",

package/public/content/packages/cli/command-tree.md

@@ -29,9 +29,8 @@ savvy init        orchestrator → changeset · commit · lint init in one pass
 savvy check       orchestrator → runs all three checks
 savvy commit      init · check · hook(session-start · pre-commit-message ·
                   post-commit-verify · user-prompt-submit)
-savvy changeset   init · check · lint · transform · validate-file · version ·
-                  classify · analyze-branch · release-surface ·
-                  config(show · validate) · deps(detect · regen)
+savvy changeset   lint · check · transform · validate-file · version ·
+                  config(validate) · deps(detect · regen)
 savvy lint        init · check · fmt(package-json · pnpm-workspace · yaml)
 ```
 

package/server.js

@@ -3,6 +3,7 @@ import { stderrQueryLogger } from "./resources/query-log.js";
 import { effectToZodSchema } from "./schema/effect-to-zod.js";
 import { BiomeCheckAsMarkdown, BiomeCheckResult, runBiomeCheck } from "./tools/biome-check.js";
 import { ChangesetInspectAsMarkdown, ChangesetInspectResult, changesetInspect } from "./tools/changeset-inspect.js";
+import { ChangesetValidateAsMarkdown, ChangesetValidateResult, changesetValidate } from "./tools/changeset-validate.js";
 import { DocsSearchResult, DocsSearchResultAsMarkdown, runDocsSearch } from "./tools/docs-search.js";
 import { TurboInspectAsMarkdown, TurboInspectResult, turboInspect } from "./tools/turbo-inspect.js";
 import { WorkspaceInfoAsMarkdown, WorkspaceInfoResult, workspaceInfo } from "./tools/workspace-info.js";
@@ -81,10 +82,15 @@ function buildServer(ctx) {
 		return structuredResult(Schema.decodeSync(TurboInspectAsMarkdown)(data), data);
 	});
 	server.registerTool("changeset_inspect", {
-		description: "Read-only changeset analysis for the changeset-manager workflow. mode=branch diffs the current branch against its base and classifies every changed file by owning package (with packagesAffected and the unmapped paths to ask the user about). mode=config surfaces the resolved .changeset/config.json (release surfaces, versionFiles, ignore list). Prefer this over shelling out to the savvy CLI.",
+		description: "Read-only changeset analysis for the changeset-manager workflow. mode=branch diffs the current branch against its base and classifies every changed file by owning package (with packagesAffected and the unmapped paths to ask the user about). mode=config surfaces the resolved .changeset/config.json (release surfaces, versionFiles, ignore list). mode=classify maps arbitrary repo-relative paths to their owning package. Prefer this over shelling out to the savvy CLI.",
 		inputSchema: {
-			mode: z.enum(["branch", "config"]).describe("Which inspection to run."),
+			mode: z.enum([
+				"branch",
+				"config",
+				"classify"
+			]).describe("Which inspection to run."),
 			base: z.optional(z.string()).describe("Override the base branch (branch mode only)."),
+			paths: z.optional(z.array(z.string())).describe("Paths to classify (classify mode only)."),
 			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
 		},
 		outputSchema: effectToZodSchema(ChangesetInspectResult),
@@ -93,6 +99,18 @@ function buildServer(ctx) {
 		const data = await ctx.runtime.runPromise(changesetInspect(args, ctx.cwd));
 		return structuredResult(Schema.decodeSync(ChangesetInspectAsMarkdown)(data), data);
 	});
+	server.registerTool("changeset_validate", {
+		description: "Read-only validation of changeset files against the section-aware rules. Pass dir (default .changeset). Returns typed diagnostics (file, rule, line, column, message) plus ok/errorCount in structuredContent. Prefer this over shelling out to savvy changeset lint.",
+		inputSchema: {
+			dir: z.optional(z.string()).describe("Changeset directory to validate (default .changeset)."),
+			cwd: z.optional(z.string()).describe("Directory to resolve the workspace root from.")
+		},
+		outputSchema: effectToZodSchema(ChangesetValidateResult),
+		annotations: { readOnlyHint: true }
+	}, async (args) => {
+		const data = await ctx.runtime.runPromise(changesetValidate(args, ctx.cwd));
+		return structuredResult(Schema.decodeSync(ChangesetValidateAsMarkdown)(data), data);
+	});
 	server.registerTool("biome_check", {
 		description: "Run Biome over a path and get structured diagnostics back. mode=check (default; lint + format + organize-imports) or mode=lint. Set write=true to apply safe fixes (--write), unsafe=true for unsafe fixes (--write --unsafe). Prefer this over shelling out to biome; the LSP already covers files you've edited. Returns markdown in content[] and a typed object in structuredContent. NOTE: with write/unsafe this tool MUTATES files (git-reversible).",
 		inputSchema: {

package/tools/changeset-inspect.js

@@ -21,11 +21,16 @@ const ChangesetConfigResult = Schema.Struct({
 	mode: Schema.Literal("config"),
 	result: Changesets.InspectedConfigSchema
 }).annotations({ identifier: "ChangesetConfigResult" });
+/** Classify variant — arbitrary paths to owning package. */
+const ChangesetClassifyResult = Schema.Struct({
+	mode: Schema.Literal("classify"),
+	result: Schema.Array(Changesets.ClassificationSchema)
+}).annotations({ identifier: "ChangesetClassifyResult" });
 /** The `changeset_inspect` tool result — a discriminated union keyed by `mode`. */
-const ChangesetInspectResult = Schema.Union(ChangesetBranchResult, ChangesetConfigResult).annotations({
+const ChangesetInspectResult = Schema.Union(ChangesetBranchResult, ChangesetConfigResult, ChangesetClassifyResult).annotations({
 	identifier: "ChangesetInspectResult",
 	title: "changeset_inspect result",
-	description: "Read-only changeset analysis grouped by mode (branch | config)."
+	description: "Read-only changeset analysis grouped by mode (branch | config | classify)."
 });
 /**
 * Render a repo/config-derived value as an inert markdown code span. Escapes
@@ -49,7 +54,7 @@ const renderMarkdown = (data) => {
 				`## Files`
 			];
 			for (const f of r.files) {
-				const owner = f.package ? mdInline(f.package) : "<unmapped>";
+				const owner = f.package ? mdInline(f.package) : mdInline("<unmapped>");
 				lines.push(`- ${mdInline(f.status)}  ${mdInline(f.path)}  ->  ${owner}`);
 			}
 			if (r.unmappedFiles.length > 0) {
@@ -78,6 +83,15 @@ const renderMarkdown = (data) => {
 			if (r.packages.length === 0) lines.push("(none resolved)");
 			return lines.join("\n");
 		}
+		case "classify": {
+			const lines = [`# changeset classify`, ``];
+			for (const c of data.result) {
+				const owner = c.package ? mdInline(c.package) : mdInline("<unmapped>");
+				lines.push(`- ${mdInline(c.path)}  ->  ${owner}`);
+			}
+			if (data.result.length === 0) lines.push("(no paths)");
+			return lines.join("\n");
+		}
 	}
 };
 /** One-way transform: result to markdown. Encoding back is forbidden. */
@@ -101,6 +115,10 @@ const changesetInspect = (args, fallbackCwd) => Effect.gen(function* () {
 			mode: "config",
 			result: yield* (yield* Changesets.ConfigInspector).inspect(root)
 		};
+		case "classify": return {
+			mode: "classify",
+			result: yield* (yield* Changesets.ConfigInspector).classify(root, args.paths ?? [])
+		};
 	}
 });
 

package/tools/changeset-validate.js

@@ -0,0 +1,84 @@
+import { Changesets } from "@savvy-web/silk-effects";
+import { Data, Effect, ParseResult, Schema } from "effect";
+import { WorkspaceRoot } from "workspaces-effect";
+import { resolve } from "node:path";
+
+//#region src/tools/changeset-validate.ts
+/**
+* The `changeset_validate` MCP tool: structured changeset-file validation over
+* silk-effects' pure ChangesetLinter, returning typed diagnostics plus a
+* pass/fail summary. Read-only.
+*
+* @packageDocumentation
+*/
+/** A thrown failure from the pure {@link Changesets.ChangesetLinter.validate} (e.g. a missing directory). */
+var ChangesetValidateError = class extends Data.TaggedError("ChangesetValidateError") {};
+/** A single changeset lint diagnostic. Mirrors silk-effects' `LintMessage`. */
+const ChangesetLintMessage = Schema.Struct({
+	file: Schema.String,
+	rule: Schema.String,
+	line: Schema.Number,
+	column: Schema.Number,
+	message: Schema.String
+}).annotations({ identifier: "ChangesetLintMessage" });
+/** The `changeset_validate` tool result. */
+const ChangesetValidateResult = Schema.Struct({
+	dir: Schema.String,
+	ok: Schema.Boolean,
+	errorCount: Schema.Number,
+	messages: Schema.Array(ChangesetLintMessage)
+}).annotations({
+	identifier: "ChangesetValidateResult",
+	title: "changeset_validate result",
+	description: "Read-only validation of changeset files against the section-aware rules."
+});
+/**
+* Render a repo/lint-derived value as an inert markdown code span. Escapes
+* backticks and backslashes so a crafted filename or message cannot inject
+* markdown structure into the transcript that an agent reads.
+*/
+const mdInline = (value) => `\`${value.replace(/[`\\]/g, "\\$&")}\``;
+/** Render the structured result as a markdown transcript. */
+const renderMarkdown = (data) => {
+	if (data.ok) return `# changeset validate — ${mdInline(data.dir)}\n\nNo changeset issues found.`;
+	const lines = [
+		`# changeset validate — ${mdInline(data.dir)}`,
+		``,
+		`${data.errorCount} issue(s):`,
+		``
+	];
+	for (const m of data.messages) lines.push(`- ${mdInline(`${m.file}:${m.line}:${m.column}`)} ${mdInline(m.rule)} — ${m.message}`);
+	return lines.join("\n");
+};
+/** One-way transform: result to markdown. Encoding back is forbidden. */
+const ChangesetValidateAsMarkdown = Schema.transformOrFail(ChangesetValidateResult, Schema.String, {
+	strict: true,
+	decode: (data) => ParseResult.succeed(renderMarkdown(data)),
+	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "ChangesetValidateAsMarkdown is one-way: markdown cannot be parsed back."))
+});
+/**
+* Effect handler: resolve the workspace root, then validate the changeset
+* directory via the pure {@link Changesets.ChangesetLinter.validate}. The
+* synchronous call is wrapped in {@link Effect.try} so a thrown error (e.g. a
+* missing directory) surfaces as a typed {@link ChangesetValidateError} rather
+* than escaping as a defect.
+*/
+const changesetValidate = (args, fallbackCwd) => Effect.gen(function* () {
+	const dir = resolve(yield* (yield* WorkspaceRoot).find(args.cwd ?? fallbackCwd), args.dir ?? ".changeset");
+	const messages = yield* Effect.try({
+		try: () => Changesets.ChangesetLinter.validate(dir),
+		catch: (cause) => new ChangesetValidateError({
+			dir,
+			cause
+		})
+	});
+	return {
+		dir,
+		ok: messages.length === 0,
+		errorCount: messages.length,
+		messages
+	};
+});
+
+//#endregion
+export { ChangesetValidateAsMarkdown, ChangesetValidateResult, changesetValidate };