@master/css-mcp 2.0.0-rc.87 → 2.0.0

package/dist/manifest-query.js

@@ -1,8 +1,9 @@
-import { loadWorkspaceManifest } from "./project.js";
-import { compactConditions, compactUtility, compactVariable, summarizeManifest } from "./manifest-summary.js";
-import { flattenMasterCSSManifestVariables } from "@master/css-engine";
-//#region src/manifest-query.ts
-const MANIFEST_QUERY_VERSION = 1;
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
+import { createMCPToolingSession } from "./tooling-session.js";
+import { compactMixin, compactVariable, summarizeManifest } from "./manifest-summary.js";
+import { flattenMasterCSSManifestVariables } from "@master/css-schema/manifest";
+// src/manifest-query.ts
+const MANIFEST_QUERY_VERSION = 6;
 function includesQuery(value, query) {
 	if (!query) return true;
 	if (value === void 0 || value === null) return false;
@@ -14,116 +15,55 @@ function matchesAny(values, query) {
 function limitResults(items, limit) {
 	return items.slice(0, limit);
 }
-function utilitySearchValues(utility) {
-	return [
-		utility.id,
-		utility.name,
-		utility.key,
-		utility.subkey,
-		...utility.keys || [],
-		...utility.namespaces || [],
-		...utility.aliasGroups || [],
-		...utility.variableAliasRefs || [],
-		...utility.matchers.flatMap((matcher) => Object.values(matcher))
-	];
+function mixinSearchValues(mixin) {
+	return [mixin.name, ...(mixin.parameters ?? []).map((parameter) => parameter.name)];
 }
 async function queryManifest(context, options = {}) {
-	const manifest = await loadWorkspaceManifest(context);
+	const manifest = await loadWorkspaceManifest(context, options.context);
 	const query = (options.query || "").toLowerCase();
 	const kind = options.kind || "all";
 	const namespace = options.namespace;
 	const limit = options.limit ?? 50;
-	if (manifest.status === "error") return {
-		version: MANIFEST_QUERY_VERSION,
-		root: context.root,
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			error: manifest.error
-		},
-		inputs: {
-			query: options.query,
-			kind,
-			namespace,
-			limit
-		},
-		results: {
-			tokens: [],
-			utilities: [],
-			variants: [],
-			modes: [],
-			conditions: [],
-			aliases: []
-		},
-		diagnostics: [{
-			code: "manifest-load-error",
-			severity: "error",
-			message: manifest.error,
-			source: "Master CSS",
-			sourceKind: "manifest"
-		}],
-		summary: {
-			total: 0,
-			returned: 0,
-			status: "error"
-		}
-	};
-	const activeManifest = manifest.manifest;
+	const activeManifest = requireWorkspaceManifest(manifest);
 	const variables = flattenMasterCSSManifestVariables(activeManifest.variables).filter((variable) => !namespace || variable.namespace === namespace).filter((variable) => matchesAny([
 		variable.name,
 		variable.key,
 		variable.namespace,
-		variable.value
+		...variable.values.flatMap(({ path, value }) => [...path, value])
 	], query)).map(compactVariable);
-	const utilities = (activeManifest.utilities || []).filter((utility) => !namespace || utility.namespaces?.includes(namespace)).filter((utility) => matchesAny(utilitySearchValues(utility), query)).map(compactUtility);
-	const variants = (activeManifest.variants || []).filter((variant) => includesQuery(variant.token, query)).map((variant) => ({
-		token: variant.token,
-		branches: variant.branches.length,
-		layers: [...new Set(variant.branches.map((branch) => branch.layer).filter(Boolean))]
+	const mixins = (activeManifest.mixins || []).filter((mixin) => !namespace || mixin.name === `--${namespace}`).filter((mixin) => matchesAny(mixinSearchValues(mixin), query)).map(compactMixin);
+	const utilities = (activeManifest.utilities || []).filter((utility) => !namespace || utility.parameters?.some((parameter) => parameter.name === `--${namespace}`)).filter((utility) => matchesAny(mixinSearchValues(utility), query)).map((utility) => ({
+		...utility,
+		parameters: utility.parameters ?? []
+	}));
+	const customMedia = Object.entries(activeManifest.customMedia ?? {}).filter(([name]) => includesQuery(name, query)).map(([name, expression]) => ({
+		name,
+		expression
 	}));
-	const modes = [...activeManifest.settings?.defaultMode ? [activeManifest.settings.defaultMode] : [], ...activeManifest.settings?.modes || []].filter((mode, index, list) => list.indexOf(mode) === index).filter((mode) => includesQuery(mode, query)).map((mode) => ({
-		name: mode,
-		default: mode === activeManifest.settings?.defaultMode,
-		trigger: activeManifest.settings?.modeTrigger
+	const customContainers = Object.entries(activeManifest.customContainers ?? {}).filter(([name]) => includesQuery(name, query)).map(([name, condition]) => ({
+		name,
+		condition
 	}));
-	const conditions = [
-		...compactConditions(activeManifest.conditions),
-		...compactConditions(activeManifest.breakpointConditions),
-		...compactConditions(activeManifest.containerConditions)
-	].filter((rule) => matchesAny([rule.name, rule.id], query));
-	const aliases = (activeManifest.utilities || []).flatMap((utility) => [
-		...(utility.variableAliases || []).map(([key, name]) => ({
-			utility: utility.id,
-			key,
-			name,
-			type: "variable-alias"
-		})),
-		...(utility.variableAliasRefs || []).map((ref) => ({
-			utility: utility.id,
-			ref,
-			type: "variable-alias-ref"
-		})),
-		...(utility.aliasGroups || []).map((group) => ({
-			utility: utility.id,
-			group,
-			type: "alias-group"
-		}))
-	]).filter((alias) => matchesAny(Object.values(alias), query));
+	using tooling = createMCPToolingSession(activeManifest);
+	const families = tooling.tokenFamilies().families.map((family) => ({
+		type: "token-family",
+		...family
+	})).filter((family) => !namespace || family.namespace === namespace).filter((family) => matchesAny(Object.values(family), query));
 	const allResults = {
 		tokens: kind === "all" || kind === "token" ? variables : [],
 		utilities: kind === "all" || kind === "utility" ? utilities : [],
-		variants: kind === "all" || kind === "variant" ? variants : [],
-		modes: kind === "all" || kind === "mode" ? modes : [],
-		conditions: kind === "all" || kind === "condition" ? conditions : [],
-		aliases: kind === "all" || kind === "alias" ? aliases : []
+		mixins: kind === "all" || kind === "mixin" ? mixins : [],
+		customMedia: kind === "all" || kind === "custom-media" ? customMedia : [],
+		customContainers: kind === "all" || kind === "custom-container" ? customContainers : [],
+		families: kind === "all" || kind === "family" ? families : []
 	};
 	const limitedResults = {
 		tokens: limitResults(allResults.tokens, limit),
 		utilities: limitResults(allResults.utilities, limit),
-		variants: limitResults(allResults.variants, limit),
-		modes: limitResults(allResults.modes, limit),
-		conditions: limitResults(allResults.conditions, limit),
-		aliases: limitResults(allResults.aliases, limit)
+		mixins: limitResults(allResults.mixins, limit),
+		customMedia: limitResults(allResults.customMedia, limit),
+		customContainers: limitResults(allResults.customContainers, limit),
+		families: limitResults(allResults.families, limit)
 	};
 	const total = Object.values(allResults).reduce((count, items) => count + items.length, 0);
 	const returned = Object.values(limitedResults).reduce((count, items) => count + items.length, 0);
@@ -131,6 +71,7 @@ async function queryManifest(context, options = {}) {
 		version: MANIFEST_QUERY_VERSION,
 		root: context.root,
 		manifest: {
+			...manifestMetadata(manifest),
 			status: manifest.status,
 			entries: manifest.entries,
 			summary: summarizeManifest(activeManifest)
@@ -146,14 +87,13 @@ async function queryManifest(context, options = {}) {
 			total,
 			returned,
 			tokens: variables.length,
+			mixins: mixins.length,
 			utilities: utilities.length,
-			variants: variants.length,
-			modes: modes.length,
-			conditions: conditions.length,
-			aliases: aliases.length,
+			customMedia: customMedia.length,
+			customContainers: customContainers.length,
+			families: families.length,
 			status: "ok"
 		}
 	};
 }
-//#endregion
 export { queryManifest };

package/dist/manifest-summary.js

@@ -1,56 +1,36 @@
-import { flattenMasterCSSManifestVariables } from "@master/css-engine";
-//#region src/manifest-summary.ts
+import { flattenMasterCSSManifestVariables } from "@master/css-schema/manifest";
+// src/manifest-summary.ts
 function summarizeManifest(manifest) {
 	const variables = flattenMasterCSSManifestVariables(manifest.variables);
 	return {
-		settings: manifest.settings ?? {},
+		languageVersion: manifest.languageVersion,
+		theme: manifest.theme ?? [],
 		counts: {
 			variables: variables.length,
 			variableNamespaces: Object.keys(manifest.variables || {}).length,
+			mixins: manifest.mixins?.length ?? 0,
 			utilities: manifest.utilities?.length ?? 0,
-			variants: manifest.variants?.length ?? 0,
-			conditions: Object.keys(manifest.conditions || {}).length,
-			breakpointConditions: Object.keys(manifest.breakpointConditions || {}).length,
-			containerConditions: Object.keys(manifest.containerConditions || {}).length,
-			selectors: Object.keys(manifest.selectors || {}).length,
-			animations: Object.keys(manifest.animations || {}).length
+			customMedia: Object.keys(manifest.customMedia || {}).length,
+			customContainers: Object.keys(manifest.customContainers || {}).length
 		}
 	};
 }
 function compactVariable(variable) {
 	return {
+		...variable,
+		dependencies: [...variable.dependencies ?? []],
 		name: variable.name,
 		key: variable.key,
 		namespace: variable.namespace || "",
 		type: variable.type,
-		value: variable.value,
-		...variable.numeric ? { numeric: variable.numeric } : {},
-		...variable.modes ? { modes: Object.keys(variable.modes) } : {},
-		...variable.inline ? { inline: true } : {},
-		...variable.static ? { static: true } : {}
+		values: variable.values,
+		...variable.numeric ? { numeric: variable.numeric } : {}
 	};
 }
-function compactUtility(utility) {
+function compactMixin(mixin) {
 	return {
-		id: utility.id,
-		...utility.name ? { name: utility.name } : {},
-		...utility.key ? { key: utility.key } : {},
-		...utility.subkey ? { subkey: utility.subkey } : {},
-		...utility.keys?.length ? { keys: utility.keys } : {},
-		...utility.namespaces?.length ? { namespaces: utility.namespaces } : {},
-		layer: utility.layer,
-		matcherTypes: utility.matchers.map((matcher) => matcher.type),
-		emitType: utility.emit.type,
-		...utility.aliasGroups?.length ? { aliasGroups: utility.aliasGroups } : {},
-		...utility.variableAliasRefs?.length ? { variableAliasRefs: utility.variableAliasRefs } : {}
+		...mixin,
+		parameters: mixin.parameters ?? []
 	};
 }
-function compactConditions(conditions) {
-	return Object.entries(conditions || {}).map(([name, rule]) => ({
-		name,
-		id: rule.id,
-		nodes: rule.nodes.length
-	}));
-}
-//#endregion
-export { compactConditions, compactUtility, compactVariable, summarizeManifest };
+export { compactMixin, compactVariable, summarizeManifest };

package/dist/output-schema.js

@@ -0,0 +1,207 @@
+import { change, classDiff, completion, diagnostic, envelopeMetadata, inspection, manifestResults, metadata, range, ruleDiff, strings } from "./semantic-schema.js";
+import { extractSummary, extractedFile, formatFile, formatSummary, lintCoverage, lintFile, lintSummary, previewSummary, scanSummary, scannedFile, scanner, stylesheets } from "./source-schema.js";
+import { projectComparison, projectSnapshot } from "./project-comparison-schema.js";
+import { designSystemReport } from "./design-system-schema.js";
+import * as z from "zod/v4";
+// src/output-schema.ts
+const object = z.record(z.string(), z.json());
+const css = z.object({
+	bytes: z.number(),
+	text: z.string().optional()
+}).passthrough();
+const preview = z.object({
+	confirmToken: z.string().optional(),
+	expiresAt: z.number().optional(),
+	changes: z.array(change),
+	summary: previewSummary
+}).passthrough();
+const fields = {
+	mastercss_suggest_classes: {
+		version: z.literal(1),
+		manifest: metadata,
+		status: z.enum(["suggested", "preserved"]),
+		classes: strings,
+		css: z.string(),
+		remainingCss: z.string(),
+		notes: strings,
+		declarations: z.array(z.object({
+			property: z.string(),
+			value: z.string(),
+			important: z.boolean(),
+			className: z.string()
+		})),
+		verification: z.object({
+			declarations: z.boolean(),
+			cascade: z.literal(false),
+			browser: z.literal(false)
+		}),
+		validation: z.array(inspection.pick({
+			className: true,
+			matchStatus: true,
+			cssSyntaxStatus: true,
+			cssValueStatus: true,
+			browserSupport: true
+		}))
+	},
+	mastercss_workspace_info: {
+		root: z.string(),
+		roots: strings,
+		packages: object,
+		manifest: metadata
+	},
+	mastercss_setup_audit: {
+		root: z.string(),
+		status: z.string(),
+		packageJSON: object,
+		packages: object,
+		integrations: z.array(object),
+		manifest: metadata,
+		summary: object
+	},
+	mastercss_lint_project: {
+		root: z.string(),
+		manifest: metadata,
+		version: z.literal(5),
+		files: z.array(lintFile),
+		coverage: lintCoverage,
+		summary: lintSummary
+	},
+	mastercss_lint_content: {
+		root: z.string(),
+		manifest: metadata,
+		version: z.literal(5),
+		files: z.array(lintFile),
+		coverage: lintCoverage,
+		summary: lintSummary
+	},
+	mastercss_preview_fixes: {
+		manifest: metadata,
+		mode: z.enum(["lint-fixes", "generated-css"]),
+		preview
+	},
+	mastercss_preview_directive_format: {
+		root: z.string(),
+		manifest: metadata,
+		mode: z.enum(["content", "files"]),
+		files: z.array(formatFile),
+		summary: formatSummary
+	},
+	mastercss_apply_preview: {
+		applied: z.literal(true),
+		changes: z.array(z.object({
+			filePath: z.string(),
+			afterHash: z.string()
+		}))
+	},
+	mastercss_inspect_class: {
+		manifest: metadata,
+		...inspection.shape,
+		css: z.string()
+	},
+	mastercss_render_css: {
+		manifest: metadata,
+		classes: strings,
+		inspections: z.array(inspection),
+		invalid: strings,
+		css
+	},
+	mastercss_trace_class: {
+		manifest: metadata,
+		inspection,
+		occurrences: z.array(z.object({
+			filePath: z.string(),
+			source: z.string(),
+			statuses: strings
+		})),
+		status: z.string(),
+		css
+	},
+	mastercss_extract_classes: {
+		manifest: metadata,
+		files: z.array(extractedFile),
+		summary: extractSummary
+	},
+	mastercss_scan_project: {
+		manifest: metadata,
+		files: z.array(scannedFile),
+		scanner,
+		stylesheets,
+		css,
+		summary: scanSummary,
+		snapshot: projectSnapshot.optional(),
+		designSystem: designSystemReport.optional()
+	},
+	mastercss_inspect_directives: {
+		context: metadata,
+		manifest: object,
+		directiveEntries: z.array(z.object({
+			name: z.string(),
+			range,
+			prelude: z.string(),
+			hasBlock: z.boolean(),
+			quotedStrings: z.number()
+		}).passthrough()),
+		dependencies: strings,
+		css,
+		summary: object
+	},
+	mastercss_manifest_query: {
+		version: z.literal(6),
+		manifest: metadata,
+		results: manifestResults,
+		summary: z.object({
+			total: z.number(),
+			returned: z.number(),
+			tokens: z.number(),
+			mixins: z.number(),
+			utilities: z.number(),
+			customMedia: z.number(),
+			customContainers: z.number(),
+			families: z.number(),
+			status: z.literal("ok")
+		})
+	},
+	mastercss_css_compare: {
+		manifest: metadata,
+		classes: classDiff,
+		css: z.object({
+			changed: z.boolean(),
+			before: css,
+			after: css,
+			bytesDelta: z.number(),
+			diff: z.string()
+		}),
+		rules: ruleDiff,
+		summary: object
+	},
+	mastercss_suggest_syntax: {
+		manifest: metadata,
+		completions: z.array(completion),
+		total: z.number()
+	}
+};
+function toolOutputSchema(name) {
+	if (!fields[name]) throw new Error(`Missing output schema for ${name}`);
+	const standard = z.object(fields[name]).passthrough();
+	const payload = name === "mastercss_css_compare" ? z.union([standard, z.object({
+		version: z.literal(3),
+		mode: z.literal("project"),
+		comparison: projectComparison
+	})]) : standard;
+	return z.object({
+		version: z.literal(3),
+		metadata: envelopeMetadata,
+		diagnostics: z.array(diagnostic),
+		result: z.discriminatedUnion("status", [z.object({
+			status: z.literal("success"),
+			data: payload
+		}), z.object({
+			status: z.literal("error"),
+			error: z.object({
+				code: z.string(),
+				message: z.string()
+			})
+		})])
+	});
+}
+export { toolOutputSchema };

package/dist/preview-write-lock.js

@@ -0,0 +1,90 @@
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { setTimeout } from "node:timers/promises";
+// src/preview-write-lock.ts
+const NAME = /^(\d+)-[a-f0-9-]+\.json$/;
+function missing(error) {
+	return error?.code === "ENOENT";
+}
+async function remove(file) {
+	try {
+		await unlink(file);
+	} catch (error) {
+		if (!missing(error)) throw error;
+	}
+}
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+async function tickets(directory) {
+	const entries = [];
+	for (const id of await readdir(directory)) {
+		const register = id.endsWith(".next") ? id.slice(0, -5) : id;
+		const match = NAME.exec(register);
+		if (!match) continue;
+		const file = join(directory, register);
+		if (!alive(Number(match[1]))) {
+			await remove(file);
+			await remove(file + ".next");
+			continue;
+		}
+		if (id !== register) continue;
+		let text;
+		try {
+			text = await readFile(file, "utf8");
+		} catch (error) {
+			if (missing(error)) continue;
+			throw error;
+		}
+		const value = JSON.parse(text);
+		if (typeof value.choosing !== "boolean" || typeof value.number !== "string" || !/^\d+$/.test(value.number)) throw new Error(`Invalid MCP preview lock register: ${file}`);
+		entries.push({
+			id,
+			choosing: value.choosing,
+			number: BigInt(value.number)
+		});
+	}
+	return entries;
+}
+/** Serialize hash validation and writes, including across independently loaded servers. */
+async function withPreviewWriteLock(work, options = {}) {
+	const directory = options.directory ?? join(userInfo().homedir, ".cache", "mastercss", "mcp-preview-lock-v1");
+	const deadline = performance.now() + (options.timeout ?? 3e4);
+	const id = `${process.pid}-${randomUUID()}.json`;
+	const file = join(directory, id);
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const publish = async (value) => {
+		await writeFile(file + ".next", JSON.stringify(value), { mode: 384 });
+		await rename(file + ".next", file);
+	};
+	try {
+		await publish({
+			choosing: true,
+			number: "0"
+		});
+		const number = (await tickets(directory)).reduce((max, peer) => peer.number > max ? peer.number : max, 0n) + 1n;
+		await publish({
+			choosing: false,
+			number: String(number)
+		});
+		while (true) {
+			if (performance.now() >= deadline) throw new Error("Timed out waiting for another MCP preview apply.");
+			if (!(await tickets(directory)).some((peer) => peer.id !== id && (peer.choosing || peer.number < number || peer.number === number && peer.id < id))) return await work();
+			await setTimeout(10);
+		}
+	} finally {
+		await remove(file);
+		await remove(file + ".next");
+	}
+}
+export { withPreviewWriteLock };

package/dist/project-comparison-schema.js

@@ -0,0 +1,59 @@
+import { matchStatus, rule, strings } from "./semantic-schema.js";
+import * as z from "zod/v4";
+// src/project-comparison-schema.ts
+const asset = z.object({
+	path: z.string().min(1),
+	css: z.string()
+}).strict();
+const projectSnapshot = z.object({
+	version: z.literal(1),
+	manifest: z.object({
+		version: z.literal(6),
+		languageVersion: z.literal(18)
+	}).catchall(z.json()),
+	sources: z.array(z.object({
+		path: z.string().min(1),
+		classes: strings
+	}).strict()),
+	stylesheets: z.array(asset),
+	outputs: z.array(asset),
+	excluded: strings,
+	unresolved: strings
+}).strict();
+const assetChange = z.object({
+	path: z.string(),
+	before: z.string().nullable(),
+	after: z.string().nullable(),
+	changedDependencies: strings
+});
+const projectComparison = z.object({
+	version: z.literal(1),
+	definitions: z.array(z.object({
+		id: z.string(),
+		before: z.json().nullable(),
+		after: z.json().nullable()
+	})),
+	classes: z.array(z.object({
+		className: z.string(),
+		files: strings,
+		reasons: strings,
+		changedDependencies: strings,
+		beforeMatchStatus: matchStatus.nullable(),
+		afterMatchStatus: matchStatus.nullable(),
+		beforeRules: z.array(rule),
+		afterRules: z.array(rule)
+	})),
+	stylesheets: z.array(assetChange),
+	outputs: z.array(assetChange),
+	stylesheetOrderChanged: z.boolean(),
+	outputOrderChanged: z.boolean(),
+	files: strings,
+	coverage: z.object({
+		scope: z.literal("known-sources"),
+		browser: z.literal("not-checked"),
+		excluded: strings,
+		unresolved: strings,
+		notes: strings
+	})
+});
+export { projectComparison, projectSnapshot };