@codai/axiom-mcp 1.0.23 → 2.0.0

package/dist/index.js

@@ -0,0 +1,904 @@
+import { createRequire } from "node:module";
+import { ApplyResultSchema, AxiomError, CheckReportSchema, DigestRefSchema, ErrorCodeSchema, JournalPhaseSchema, JournalSchema, ManifestBodySchema, ManifestBundleSchema, PlanSchema, ProfileSchema } from "@codai/axiom-schema";
+import { z } from "zod";
+import { realpath } from "node:fs";
+import { access, constants, mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { loadProfile, runChecks } from "@codai/axiom-checks";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { appliedPath, apply, rollback } from "@codai/axiom-apply";
+import { compilePlan, diffManifests, verifyBundle } from "@codai/axiom-plan";
+//#region src/jsonschema.ts
+const SCHEMA_KINDS = [
+	"Plan",
+	"Manifest",
+	"ManifestBundle",
+	"CheckReport",
+	"ApplyResult",
+	"Profile",
+	"Journal"
+];
+const BY_KIND = {
+	Plan: PlanSchema,
+	Manifest: ManifestBodySchema,
+	ManifestBundle: ManifestBundleSchema,
+	CheckReport: CheckReportSchema,
+	ApplyResult: ApplyResultSchema,
+	Profile: ProfileSchema,
+	Journal: JournalSchema
+};
+function isSchemaKind(v) {
+	return typeof v === "string" && SCHEMA_KINDS.includes(v);
+}
+/** Draft 2020-12 JSON Schema, byte-identical to `packages/schema/schemas/<kind>.schema.json`. */
+function jsonSchemaFor(kind) {
+	const json = z.toJSONSchema(BY_KIND[kind], {
+		target: "draft-2020-12",
+		io: "input",
+		unrepresentable: "any"
+	});
+	return {
+		$id: `https://axiom.dev/schemas/v2/${kind}.schema.json`,
+		title: kind,
+		...json
+	};
+}
+/** Compact JSON Schema for tool input/output (spec/tools.json). */
+function toolJsonSchema(schema) {
+	return z.toJSONSchema(schema, {
+		target: "draft-2020-12",
+		io: "input",
+		unrepresentable: "any"
+	});
+}
+//#endregion
+//#region src/log.ts
+/**
+* stderr-only JSON-lines logger. stdout belongs to the MCP transport; nothing in
+* this package may write there except the transport itself (and CLI verbs).
+*/
+const LOG_LEVELS = [
+	"error",
+	"warn",
+	"info",
+	"debug"
+];
+function isLogLevel(v) {
+	return typeof v === "string" && LOG_LEVELS.includes(v);
+}
+const RANK = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+function createLogger(opts = {}) {
+	const level = opts.level ?? "warn";
+	const write = opts.write ?? ((line) => void process.stderr.write(line));
+	const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+	const emit = (lvl, msg, fields) => {
+		if (RANK[lvl] > RANK[level]) return;
+		write(`${JSON.stringify({
+			level: lvl,
+			ts: now(),
+			msg,
+			...fields
+		})}\n`);
+	};
+	return {
+		level,
+		error: (m, f) => emit("error", m, f),
+		warn: (m, f) => emit("warn", m, f),
+		info: (m, f) => emit("info", m, f),
+		debug: (m, f) => emit("debug", m, f)
+	};
+}
+const silentLogger = createLogger({ write: () => {} });
+//#endregion
+//#region src/roots.ts
+const realpathNative = promisify(realpath.native);
+const IS_WIN32 = process.platform === "win32";
+async function realDir(p, code) {
+	let real;
+	try {
+		real = await realpathNative(p);
+	} catch (cause) {
+		throw new AxiomError(code, `root does not exist: ${p}`, {
+			cause,
+			details: { root: p }
+		});
+	}
+	if (IS_WIN32 && real.startsWith("\\\\?\\")) real = real.slice(4);
+	if (!(await stat(real)).isDirectory()) throw new AxiomError(code, `root is not a directory: ${p}`, { details: { root: p } });
+	return real;
+}
+function norm(p) {
+	const n = path.normalize(p).replace(/[\\/]+$/, "");
+	return IS_WIN32 ? n.toLowerCase() : n;
+}
+/** True iff `child` equals `parent` or lies inside it (case-insensitive on win32). */
+function isSameOrInside(parent, child) {
+	const p = norm(parent);
+	const c = norm(child);
+	if (p === c) return true;
+	return c.startsWith(p.endsWith(path.sep) ? p : p + path.sep);
+}
+/** Build the policy from `--root <abs>` arguments. Each must exist and be a directory. */
+async function createRootsPolicy(rootArgs) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const r of rootArgs) {
+		if (!path.isAbsolute(r)) throw new AxiomError("ERR_ROOT_NOT_DIR", `--root must be absolute: ${r}`, { details: { root: r } });
+		roots.add(await realDir(r, "ERR_ROOT_NOT_DIR"));
+	}
+	return Object.freeze({ roots: Object.freeze(roots) });
+}
+/**
+* Resolve a tool's `root` argument against the allowlist. No env fallback, no cwd:
+* none requested + one root → that root; none + many → ERR_ROOT_REQUIRED;
+* requested → realpath, must equal or be inside an allowlisted root → else ERR_ROOT_NOT_ALLOWED.
+*/
+async function resolveRoot(policy, requested) {
+	if (requested === void 0 || requested === "") {
+		if (policy.roots.size === 1) {
+			const only = [...policy.roots][0];
+			return {
+				rootReal: only,
+				effectiveRoot: only
+			};
+		}
+		throw new AxiomError("ERR_ROOT_REQUIRED", policy.roots.size === 0 ? "server has no allowlisted roots (start with --root <dir>)" : "root is required when more than one root is allowlisted", { details: { roots: [...policy.roots] } });
+	}
+	if (!path.isAbsolute(requested)) throw new AxiomError("ERR_ROOT_NOT_ALLOWED", `root must be absolute: ${requested}`, { details: { root: requested } });
+	const real = await realDir(requested, "ERR_ROOT_NOT_ALLOWED");
+	for (const allowed of policy.roots) if (isSameOrInside(allowed, real)) return {
+		rootReal: real,
+		effectiveRoot: allowed
+	};
+	throw new AxiomError("ERR_ROOT_NOT_ALLOWED", `root is outside the allowlist: ${requested}`, { details: {
+		root: requested,
+		real,
+		roots: [...policy.roots]
+	} });
+}
+//#endregion
+//#region src/store.ts
+/** `<root>/.axiom/manifests/<hex>.json` and `<root>/.axiom/reports/<hex>.json`. */
+function manifestsDir(root) {
+	return path.join(root, ".axiom", "manifests");
+}
+function reportsDir(root) {
+	return path.join(root, ".axiom", "reports");
+}
+function hexOf(ref) {
+	return ref.slice(7);
+}
+function toDigestRef(shaOrRef) {
+	const ref = shaOrRef.startsWith("sha256:") ? shaOrRef : `sha256:${shaOrRef}`;
+	const parsed = DigestRefSchema.safeParse(ref);
+	if (!parsed.success) throw new AxiomError("ERR_NOT_FOUND", `not a sha256 digest: ${shaOrRef}`);
+	return parsed.data;
+}
+async function writeJsonAtomic(file, value) {
+	await mkdir(path.dirname(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	await writeFile(tmp, JSON.stringify(value), "utf8");
+	await rename(tmp, file);
+}
+async function readJsonOrUndefined(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		throw err;
+	}
+}
+async function saveManifest(root, bundle) {
+	const file = path.join(manifestsDir(root), `${hexOf(bundle.manifestDigest)}.json`);
+	await writeJsonAtomic(file, bundle);
+	return file;
+}
+async function saveReport(root, report) {
+	const file = path.join(reportsDir(root), `${hexOf(report.manifestDigest)}.json`);
+	await writeJsonAtomic(file, report);
+	return file;
+}
+/** Search every root (allowlisted + seen) for a stored bundle. */
+async function loadManifest(roots, ref) {
+	for (const root of roots) {
+		const raw = await readJsonOrUndefined(path.join(manifestsDir(root), `${hexOf(ref)}.json`));
+		if (raw !== void 0) return ManifestBundleSchema.parse(raw);
+	}
+}
+async function loadReport(roots, ref) {
+	for (const root of roots) {
+		const raw = await readJsonOrUndefined(path.join(reportsDir(root), `${hexOf(ref)}.json`));
+		if (raw !== void 0) return CheckReportSchema.parse(raw);
+	}
+}
+async function loadApplied(roots, ref) {
+	for (const root of roots) {
+		const raw = await readJsonOrUndefined(appliedPath(root, ref));
+		if (raw !== void 0) return ApplyResultSchema.parse(raw);
+	}
+}
+async function listStored(roots, sub) {
+	const out = [];
+	for (const root of roots) {
+		let names;
+		try {
+			names = await readdir(path.join(root, ".axiom", sub));
+		} catch {
+			continue;
+		}
+		for (const n of names) {
+			const m = /^([0-9a-f]{64})\.json$/.exec(n);
+			if (m?.[1] !== void 0) out.push({
+				root,
+				sha: m[1]
+			});
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/tools.ts
+/** Hard cap on any single `bundle`/`plan` argument, measured as UTF-8 JSON bytes (§(f) payload size). */
+const BUNDLE_BYTES_MAX = 4194304;
+/** Findings/errors echoed in the text summary. */
+const SUMMARY_LIST_MAX = 20;
+const READ = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: false
+};
+/** Writes only under `<root>/.axiom/` (CAS blobs, stored manifests) — never the working tree. */
+const ACT = {
+	readOnlyHint: false,
+	destructiveHint: false,
+	idempotentHint: true,
+	openWorldHint: false
+};
+const WRITE = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	idempotentHint: true,
+	openWorldHint: false
+};
+function riskClassOf(a) {
+	if (a.readOnlyHint) return "READ";
+	return a.destructiveHint ? "SENSITIVE" : "ACT";
+}
+function defineTool(def) {
+	return {
+		...def,
+		riskClass: riskClassOf(def.annotations)
+	};
+}
+const LooseObject = z.record(z.string(), z.unknown());
+const RootArg = z.string().optional().describe("Absolute repository root; must equal or lie inside an allowlisted --root");
+const ProfileArg = z.string().optional().describe("Profile name (builtin default|strict|permissive, or <root>/.axiom/profiles/<name>.json)");
+/** Reject oversized payloads before any deeper parsing. */
+function guardPayloadSize(label, value) {
+	const bytes = Buffer.byteLength(JSON.stringify(value) ?? "", "utf8");
+	if (bytes > 4194304) throw new AxiomError("ERR_BUNDLE_TOO_LARGE", `${label} is ${bytes} bytes; max ${BUNDLE_BYTES_MAX}`, { details: {
+		bytes,
+		max: BUNDLE_BYTES_MAX
+	} });
+}
+function parseBundle(raw) {
+	guardPayloadSize("bundle", raw);
+	const parsed = ManifestBundleSchema.safeParse(raw);
+	if (!parsed.success) throw new AxiomError("ERR_INVALID_MANIFEST", "bundle does not match ManifestBundleSchema", { details: { issues: parsed.error.issues.slice(0, 20).map((i) => ({
+		path: i.path.map(String).join("."),
+		message: i.message
+	})) } });
+	return parsed.data;
+}
+async function profileFor(ctx, bundle, name, rootReal) {
+	const searchDirs = rootReal === void 0 ? [] : [path.join(rootReal, ".axiom", "profiles")];
+	const profileName = name ?? bundle.manifest.profile;
+	ctx.log.debug("profile", {
+		name: profileName,
+		searchDirs
+	});
+	return loadProfile(profileName, { searchDirs });
+}
+async function checkBundle(ctx, bundle, profileName, rootReal) {
+	const opts = {
+		bundle,
+		profile: await profileFor(ctx, bundle, profileName, rootReal),
+		checks: bundle.manifest.checks,
+		...ctx.guards
+	};
+	if (rootReal !== void 0) {
+		opts.root = rootReal;
+		opts.casDir = path.join(rootReal, ".axiom", "cas");
+	}
+	const report = await runChecks(opts);
+	if (rootReal !== void 0) {
+		await saveReport(rootReal, report);
+		ctx.seenRoots.add(rootReal);
+	}
+	return report;
+}
+/** Optional root: explicit → allowlist check; absent → the single root if there is one, else none. */
+async function optionalRoot(ctx, requested) {
+	if (requested !== void 0 && requested !== "") return (await resolveRoot(ctx.policy, requested)).rootReal;
+	if (ctx.policy.roots.size === 1) return (await resolveRoot(ctx.policy)).rootReal;
+}
+function countBy(items, key) {
+	const out = {};
+	for (const it of items) out[key(it)] = (out[key(it)] ?? 0) + 1;
+	return out;
+}
+const IssueSchema = z.object({
+	path: z.string(),
+	message: z.string(),
+	code: z.string().optional()
+});
+const PlanValidateOutput = z.object({
+	ok: z.boolean(),
+	planDigest: DigestRefSchema.optional(),
+	errors: z.array(IssueSchema)
+});
+const ManifestVerifyOutput = z.object({
+	ok: z.boolean(),
+	manifestDigest: DigestRefSchema.optional(),
+	canonical: z.boolean(),
+	signed: z.boolean(),
+	missing: z.array(z.string()),
+	errors: z.array(z.object({
+		code: ErrorCodeSchema,
+		message: z.string(),
+		path: z.string().optional()
+	}))
+});
+const RollbackOutput = z.object({
+	manifestDigest: DigestRefSchema,
+	status: z.literal("rolled-back"),
+	phase: JournalPhaseSchema,
+	steps: z.int().nonnegative(),
+	root: z.string()
+});
+const ManifestDiffOutput = z.object({
+	added: z.array(z.string()),
+	removed: z.array(z.string()),
+	changed: z.array(z.object({
+		path: z.string(),
+		from: z.string().nullable(),
+		to: z.string().nullable()
+	}))
+});
+const RootsListOutput = z.object({ roots: z.array(z.object({
+	path: z.string(),
+	writable: z.boolean(),
+	hasGit: z.boolean()
+})) });
+const Pos = z.object({
+	line: z.int().positive(),
+	column: z.int().positive()
+});
+const AxmParseOutput = z.object({
+	plan: PlanSchema.optional(),
+	diagnostics: z.array(z.object({
+		severity: z.enum(["error", "warning"]),
+		code: ErrorCodeSchema,
+		message: z.string(),
+		range: z.object({
+			start: Pos,
+			end: Pos
+		})
+	}))
+});
+const BundleOrRef = z.union([DigestRefSchema, LooseObject]).describe("A ManifestBundle object, or `sha256:<hex>` of a bundle stored under <root>/.axiom/manifests");
+const TOOL_DEFS = [
+	defineTool({
+		name: "axiom_plan_validate",
+		title: "Validate a Plan",
+		description: "Validate a Plan against PlanSchema and, when all sources are inline, compute its planDigest. Read-only; touches no files.",
+		inputSchema: { plan: LooseObject.describe("Plan document (apiVersion axiom.dev/v2, kind Plan)") },
+		outputSchema: PlanValidateOutput,
+		annotations: READ,
+		async handler(_ctx, { plan }) {
+			guardPayloadSize("plan", plan);
+			const parsed = PlanSchema.safeParse(plan);
+			if (!parsed.success) return {
+				ok: false,
+				errors: parsed.error.issues.map((i) => {
+					const code = i.params?.code;
+					const out = {
+						path: i.path.map(String).join("."),
+						message: i.message
+					};
+					if (typeof code === "string") out.code = code;
+					return out;
+				})
+			};
+			try {
+				const { bundle } = await compilePlan(parsed.data, { store: "inline" });
+				return {
+					ok: true,
+					planDigest: bundle.manifest.planDigest,
+					errors: []
+				};
+			} catch (err) {
+				if (err instanceof AxiomError && err.code === "ERR_BLOB_MISSING") return {
+					ok: true,
+					errors: []
+				};
+				throw err;
+			}
+		},
+		summarize: (o) => ({
+			ok: o.ok,
+			planDigest: o.planDigest,
+			errors: o.errors.slice(0, 20)
+		})
+	}),
+	defineTool({
+		name: "axiom_plan_compile",
+		title: "Compile a Plan into a ManifestBundle",
+		description: "Compile a Plan into a content-addressed ManifestBundle (sorted artifacts, sha256 digests, in-toto planDigest). `store: cas` writes blobs under <root>/.axiom/cas instead of inlining them. When a root is given the bundle is stored under <root>/.axiom/manifests/<hex>.json so later tools can reference it by digest.",
+		inputSchema: {
+			plan: LooseObject.describe("Plan document"),
+			store: z.enum(["inline", "cas"]).optional().describe("Blob transport; default inline"),
+			root: RootArg
+		},
+		outputSchema: ManifestBundleSchema,
+		annotations: ACT,
+		async handler(ctx, { plan, store, root }) {
+			guardPayloadSize("plan", plan);
+			const rootReal = root !== void 0 || store === "cas" ? (await resolveRoot(ctx.policy, root)).rootReal : void 0;
+			const opts = { store: store ?? "inline" };
+			if (rootReal !== void 0) opts.root = rootReal;
+			const { bundle } = await compilePlan(plan, opts);
+			if (rootReal !== void 0) {
+				await saveManifest(rootReal, bundle);
+				ctx.seenRoots.add(rootReal);
+			}
+			ctx.log.info("compiled", {
+				manifestDigest: bundle.manifestDigest,
+				artifacts: bundle.manifest.artifacts.length
+			});
+			return bundle;
+		},
+		summarize: (b) => ({
+			manifestDigest: b.manifestDigest,
+			planDigest: b.manifest.planDigest,
+			name: b.manifest.name,
+			profile: b.manifest.profile,
+			artifacts: b.manifest.artifacts.length,
+			blobs: Object.keys(b.blobs).length
+		})
+	}),
+	defineTool({
+		name: "axiom_manifest_verify",
+		title: "Verify a ManifestBundle",
+		description: "Structural and content-address verification: schema, recomputed manifestDigest, every inline blob hashes to its key, attestation subject matches. Never writes.",
+		inputSchema: { bundle: LooseObject.describe("ManifestBundle") },
+		outputSchema: ManifestVerifyOutput,
+		annotations: READ,
+		async handler(_ctx, { bundle }) {
+			guardPayloadSize("bundle", bundle);
+			const r = verifyBundle(bundle);
+			const out = {
+				ok: r.ok,
+				canonical: r.canonical,
+				signed: r.signed,
+				missing: r.missing,
+				errors: r.errors
+			};
+			if (r.manifestDigest !== void 0) out.manifestDigest = r.manifestDigest;
+			return out;
+		},
+		summarize: (o) => ({
+			ok: o.ok,
+			manifestDigest: o.manifestDigest,
+			canonical: o.canonical,
+			missing: o.missing.length,
+			errors: o.errors.slice(0, 20)
+		})
+	}),
+	defineTool({
+		name: "axiom_check",
+		title: "Run policy checks on a bundle",
+		description: "Evaluate the profile's predicates (plus the manifest's own checks) against the bundle. Repo facts are read from the root when one is available and the profile allows it. Verdict `error` means a provider could not run — never a silent pass.",
+		inputSchema: {
+			bundle: LooseObject.describe("ManifestBundle"),
+			profile: ProfileArg,
+			root: RootArg
+		},
+		outputSchema: CheckReportSchema,
+		annotations: READ,
+		async handler(ctx, { bundle, profile, root }) {
+			return checkBundle(ctx, parseBundle(bundle), profile, await optionalRoot(ctx, root));
+		},
+		summarize: summarizeReport
+	}),
+	defineTool({
+		name: "axiom_apply_dry_run",
+		title: "Dry-run apply (stage + diff, no writes to the tree)",
+		description: "Stage the bundle under <root>/.axiom/staging, run pre-apply checks and produce a unified diff against the current tree. Nothing outside .axiom/ is touched. Echo the returned manifestDigest as `confirmDigest` to axiom_apply.",
+		inputSchema: {
+			bundle: LooseObject.describe("ManifestBundle"),
+			root: RootArg,
+			profile: ProfileArg
+		},
+		outputSchema: ApplyResultSchema,
+		annotations: READ,
+		async handler(ctx, { bundle, root, profile }) {
+			const parsed = parseBundle(bundle);
+			const { rootReal } = await resolveRoot(ctx.policy, root);
+			return await apply({
+				bundle: parsed,
+				root: rootReal,
+				mode: "dry-run",
+				preChecks: () => checkBundle(ctx, parsed, profile, rootReal)
+			});
+		},
+		summarize: summarizeApply
+	}),
+	defineTool({
+		name: "axiom_apply",
+		title: "Apply a bundle to the filesystem (two-phase commit)",
+		description: "Transactionally write the bundle into the root: pre-image verification, staging, journal, atomic renames, scoped rollback on failure. Requires `confirmDigest === bundle.manifestDigest` (echo the digest you saw in dry-run). Idempotent: re-applying an applied digest is a no-op.",
+		inputSchema: {
+			bundle: LooseObject.describe("ManifestBundle"),
+			root: RootArg,
+			profile: ProfileArg,
+			confirmDigest: z.string().optional().describe("Must equal bundle.manifestDigest"),
+			mode: z.enum(["fs", "pr"]).optional().describe("fs (default) writes files; pr additionally creates a git branch and commits exactly the touched paths (no push, no PR creation)"),
+			branch: z.string().optional().describe("pr mode: branch name (default axiom/<name>/<digest12>)"),
+			commitMessage: z.string().optional().describe("pr mode: commit message (passed to git on stdin)")
+		},
+		outputSchema: ApplyResultSchema,
+		annotations: WRITE,
+		async handler(ctx, { bundle, root, profile, confirmDigest, mode, branch, commitMessage }) {
+			const parsed = parseBundle(bundle);
+			if (confirmDigest !== parsed.manifestDigest) throw new AxiomError("ERR_CONFIRM_DIGEST_MISMATCH", "confirmDigest must equal bundle.manifestDigest", { details: {
+				confirmDigest: confirmDigest ?? null,
+				manifestDigest: parsed.manifestDigest
+			} });
+			const { rootReal } = await resolveRoot(ctx.policy, root);
+			const result = await apply({
+				bundle: parsed,
+				root: rootReal,
+				mode: mode ?? "fs",
+				confirmDigest,
+				...branch === void 0 ? {} : { branch },
+				...commitMessage === void 0 ? {} : { commitMessage },
+				preChecks: () => checkBundle(ctx, parsed, profile, rootReal)
+			});
+			if (result.status === "applied" || result.status === "noop") {
+				await saveManifest(rootReal, parsed);
+				ctx.seenRoots.add(rootReal);
+			}
+			ctx.log.info("apply", {
+				manifestDigest: parsed.manifestDigest,
+				status: result.status,
+				root: rootReal
+			});
+			return result;
+		},
+		summarize: summarizeApply
+	}),
+	defineTool({
+		name: "axiom_rollback",
+		title: "Roll back an applied manifest",
+		description: "Replay the journal of a committed/committing manifest in reverse: restore backups, remove created files, drop the applied marker.",
+		inputSchema: {
+			root: RootArg,
+			manifestDigest: z.string().describe("`sha256:<hex>` (or bare hex) of the manifest to roll back")
+		},
+		outputSchema: RollbackOutput,
+		annotations: WRITE,
+		async handler(ctx, { root, manifestDigest }) {
+			const ref = toDigestRef(manifestDigest);
+			const { rootReal } = await resolveRoot(ctx.policy, root);
+			const journal = await rollback(rootReal, ref);
+			ctx.log.info("rollback", {
+				manifestDigest: ref,
+				root: rootReal,
+				phase: journal.phase
+			});
+			return {
+				manifestDigest: ref,
+				status: "rolled-back",
+				phase: journal.phase,
+				steps: journal.steps.length,
+				root: rootReal
+			};
+		},
+		summarize: (o) => o
+	}),
+	defineTool({
+		name: "axiom_manifest_diff",
+		title: "Diff two manifests",
+		description: "Compare two manifests by artifact path and digest. Each side is a ManifestBundle or a `sha256:<hex>` reference to a bundle stored under an allowlisted root.",
+		inputSchema: {
+			a: BundleOrRef,
+			b: BundleOrRef
+		},
+		outputSchema: ManifestDiffOutput,
+		annotations: READ,
+		async handler(ctx, { a, b }) {
+			const [ba, bb] = await Promise.all([resolveBundleOrRef(ctx, a, "a"), resolveBundleOrRef(ctx, b, "b")]);
+			return diffManifests(ba.manifest, bb.manifest);
+		},
+		summarize: (d) => ({
+			added: d.added.length,
+			removed: d.removed.length,
+			changed: d.changed.length,
+			sample: {
+				added: d.added.slice(0, 20),
+				removed: d.removed.slice(0, 20),
+				changed: d.changed.slice(0, 20)
+			}
+		})
+	}),
+	defineTool({
+		name: "axiom_axm_parse",
+		title: "Parse .axm source into a Plan",
+		description: "Parse .axm v2 text into a Plan with 1-based {line, column} diagnostics; `plan` is present only when error-free. Read-only.",
+		inputSchema: { source: z.string().describe(".axm source text") },
+		outputSchema: AxmParseOutput,
+		annotations: READ,
+		async handler(_ctx, { source }) {
+			guardPayloadSize("source", source);
+			const { parseAxm } = await import("./axm-lazy-WdJHPy6W.js");
+			const r = parseAxm(source);
+			return r.plan === void 0 ? { diagnostics: r.diagnostics } : r;
+		},
+		summarize: (o) => ({
+			ok: o.plan !== void 0,
+			name: o.plan?.name,
+			diagnostics: o.diagnostics.slice(0, 20)
+		})
+	}),
+	defineTool({
+		name: "axiom_roots_list",
+		title: "List allowlisted roots",
+		description: "The frozen set of roots this server may read and write, as given by --root at startup.",
+		inputSchema: {},
+		outputSchema: RootsListOutput,
+		annotations: READ,
+		async handler(ctx) {
+			const roots = [];
+			for (const p of ctx.policy.roots) {
+				const [writable, hasGit] = await Promise.all([access(p, constants.W_OK).then(() => true, () => false), stat(path.join(p, ".git")).then(() => true, () => false)]);
+				roots.push({
+					path: p,
+					writable,
+					hasGit
+				});
+			}
+			return { roots };
+		},
+		summarize: (o) => o
+	})
+];
+async function resolveBundleOrRef(ctx, v, label) {
+	if (typeof v === "string") {
+		const ref = toDigestRef(v);
+		const found = await loadManifest(/* @__PURE__ */ new Set([...ctx.policy.roots, ...ctx.seenRoots]), ref);
+		if (found === void 0) throw new AxiomError("ERR_NOT_FOUND", `${label}: no stored manifest for ${ref}`, { details: { ref } });
+		return found;
+	}
+	return parseBundle(v);
+}
+function summarizeReport(r) {
+	return {
+		manifestDigest: r.manifestDigest,
+		profile: r.profile,
+		verdict: r.verdict,
+		counts: countBy(r.findings, (f) => f.severity),
+		findings: r.findings.slice(0, 20).map((f) => ({
+			id: f.id,
+			severity: f.severity,
+			message: f.message,
+			path: f.path
+		})),
+		providers: r.providers,
+		durationMs: r.durationMs
+	};
+}
+function summarizeApply(r) {
+	return {
+		manifestDigest: r.manifestDigest,
+		mode: r.mode,
+		status: r.status,
+		root: r.root,
+		files: countBy(r.files, (f) => f.status),
+		diffBytes: r.diff === void 0 ? void 0 : Buffer.byteLength(r.diff, "utf8"),
+		journal: r.journal,
+		error: r.error,
+		sample: r.files.slice(0, 20).map((f) => ({
+			path: f.path,
+			op: f.op,
+			status: f.status
+		}))
+	};
+}
+function toolByName(name) {
+	return TOOL_DEFS.find((t) => t.name === name);
+}
+//#endregion
+//#region src/server.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const SERVER_NAME = "axiom";
+const SERVER_VERSION = pkg.version;
+function toStructuredError(err) {
+	if (err instanceof AxiomError) return err.toJSON();
+	if (err instanceof z.ZodError) return {
+		code: "ERR_INVALID_PLAN",
+		message: "input does not match schema",
+		details: { issues: err.issues.slice(0, 20).map((i) => ({
+			path: i.path.join("."),
+			message: i.message
+		})) }
+	};
+	return {
+		code: "ERR_INTERNAL",
+		message: err instanceof Error ? err.message : String(err)
+	};
+}
+function errorResult(err) {
+	const structured = toStructuredError(err);
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: JSON.stringify(structured)
+		}],
+		structuredContent: structured
+	};
+}
+/** Wrap a tool handler: never throws; AxiomError → isError result with the closed code. */
+function wrapHandler(def, ctx) {
+	return async (input) => {
+		try {
+			const output = await def.handler(ctx, input);
+			const structured = def.outputSchema.parse(output);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(def.summarize(structured))
+				}],
+				structuredContent: structured
+			};
+		} catch (err) {
+			ctx.log.warn("tool failed", {
+				tool: def.name,
+				error: toStructuredError(err)
+			});
+			return errorResult(err);
+		}
+	};
+}
+function json(uri, value) {
+	return { contents: [{
+		uri,
+		mimeType: "application/json",
+		text: JSON.stringify(value, null, 2)
+	}] };
+}
+function notFound(uri) {
+	throw new AxiomError("ERR_NOT_FOUND", `resource not found: ${uri}`);
+}
+function createServer(policy, opts = {}) {
+	const log = opts.log ?? silentLogger;
+	const ctx = {
+		policy,
+		log,
+		seenRoots: /* @__PURE__ */ new Set()
+	};
+	if (opts.guards !== void 0) ctx.guards = opts.guards;
+	const server = new McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	}, { capabilities: {
+		tools: {},
+		resources: {}
+	} });
+	for (const def of opts.tools ?? TOOL_DEFS) server.registerTool(def.name, {
+		title: def.title,
+		description: def.description,
+		inputSchema: def.inputSchema,
+		outputSchema: def.outputSchema,
+		annotations: {
+			title: def.title,
+			...def.annotations
+		}
+	}, wrapHandler(def, ctx));
+	const allRoots = () => /* @__PURE__ */ new Set([...policy.roots, ...ctx.seenRoots]);
+	const listOf = (sub, scheme) => async () => {
+		return { resources: (await listStored(allRoots(), sub)).map((i) => ({
+			uri: `axiom://${scheme}/${i.sha}`,
+			name: i.sha,
+			mimeType: "application/json"
+		})) };
+	};
+	server.registerResource("manifest", new ResourceTemplate("axiom://manifest/{sha}", { list: listOf("manifests", "manifest") }), {
+		title: "Stored ManifestBundle",
+		mimeType: "application/json"
+	}, async (uri, { sha }) => {
+		const found = await loadManifest(allRoots(), toDigestRef(String(sha)));
+		return found === void 0 ? notFound(uri.href) : json(uri.href, found);
+	});
+	server.registerResource("report", new ResourceTemplate("axiom://report/{sha}", { list: listOf("reports", "report") }), {
+		title: "Last CheckReport for a manifest",
+		mimeType: "application/json"
+	}, async (uri, { sha }) => {
+		const found = await loadReport(allRoots(), toDigestRef(String(sha)));
+		return found === void 0 ? notFound(uri.href) : json(uri.href, found);
+	});
+	server.registerResource("applied", new ResourceTemplate("axiom://applied/{sha}", { list: listOf("applied", "applied") }), {
+		title: "ApplyResult of an applied manifest",
+		mimeType: "application/json"
+	}, async (uri, { sha }) => {
+		const found = await loadApplied(allRoots(), toDigestRef(String(sha)));
+		return found === void 0 ? notFound(uri.href) : json(uri.href, found);
+	});
+	server.registerResource("profile", new ResourceTemplate("axiom://profile/{name}", { list: async () => ({ resources: [
+		"default",
+		"strict",
+		"permissive"
+	].map((n) => ({
+		uri: `axiom://profile/${n}`,
+		name: n,
+		mimeType: "application/json"
+	})) }) }), {
+		title: "Resolved check profile",
+		mimeType: "application/json"
+	}, async (uri, { name }) => {
+		const searchDirs = [...policy.roots].map((r) => `${r}/.axiom/profiles`);
+		return json(uri.href, await loadProfile(String(name), { searchDirs }));
+	});
+	server.registerResource("schema", new ResourceTemplate("axiom://schema/{kind}", {
+		list: async () => ({ resources: SCHEMA_KINDS.map((k) => ({
+			uri: `axiom://schema/${k}`,
+			name: k,
+			mimeType: "application/schema+json"
+		})) }),
+		complete: { kind: (v) => SCHEMA_KINDS.filter((k) => k.toLowerCase().startsWith(v.toLowerCase())) }
+	}), {
+		title: "JSON Schema (draft 2020-12)",
+		mimeType: "application/schema+json"
+	}, async (uri, { kind }) => {
+		const k = String(kind);
+		if (!isSchemaKind(k)) notFound(uri.href);
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "application/schema+json",
+			text: JSON.stringify(jsonSchemaFor(k), null, 2)
+		}] };
+	});
+	log.info("server created", {
+		name: SERVER_NAME,
+		version: SERVER_VERSION,
+		roots: [...policy.roots]
+	});
+	return server;
+}
+//#endregion
+//#region src/spec.ts
+function buildToolsSpec() {
+	return TOOL_DEFS.map((t) => ({
+		name: t.name,
+		description: t.description,
+		riskClass: t.riskClass,
+		annotations: t.annotations,
+		inputSchema: toolJsonSchema(z.object(t.inputSchema)),
+		outputSchema: toolJsonSchema(t.outputSchema)
+	}));
+}
+/** Stable text form (2-space JSON + trailing newline) used both by the generator and the parity test. */
+function renderToolsSpec() {
+	return `${JSON.stringify(buildToolsSpec(), null, 2)}\n`;
+}
+//#endregion
+export { BUNDLE_BYTES_MAX, LOG_LEVELS, SCHEMA_KINDS, SERVER_NAME, SERVER_VERSION, SUMMARY_LIST_MAX, TOOL_DEFS, buildToolsSpec, createLogger, createRootsPolicy, createServer, isLogLevel, isSameOrInside, isSchemaKind, jsonSchemaFor, renderToolsSpec, resolveRoot, riskClassOf, toStructuredError, toolByName };
+
+//# sourceMappingURL=index.js.map