@master/css-mcp 2.0.0-rc.76 → 2.0.0-rc.78

package/dist/manifest-query.js

@@ -0,0 +1,159 @@
+import { loadWorkspaceManifest } from "./project.js";
+import { compactAtRules, compactUtility, compactVariable, summarizeManifest } from "./manifest-summary.js";
+import { flattenMasterCSSManifestVariables } from "@master/css-engine";
+//#region src/manifest-query.ts
+const MANIFEST_QUERY_VERSION = 1;
+function includesQuery(value, query) {
+	if (!query) return true;
+	if (value === void 0 || value === null) return false;
+	return String(value).toLowerCase().includes(query);
+}
+function matchesAny(values, query) {
+	return values.some((value) => includesQuery(value, 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))
+	];
+}
+async function queryManifest(context, options = {}) {
+	const manifest = await loadWorkspaceManifest(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: [],
+			atRules: [],
+			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 variables = flattenMasterCSSManifestVariables(activeManifest.variables).filter((variable) => !namespace || variable.namespace === namespace).filter((variable) => matchesAny([
+		variable.name,
+		variable.key,
+		variable.namespace,
+		variable.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 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 atRules = [
+		...compactAtRules(activeManifest.atRules),
+		...compactAtRules(activeManifest.breakpointAtRules),
+		...compactAtRules(activeManifest.containerAtRules)
+	].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));
+	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 : [],
+		atRules: kind === "all" || kind === "at-rule" ? atRules : [],
+		aliases: kind === "all" || kind === "alias" ? aliases : []
+	};
+	const limitedResults = {
+		tokens: limitResults(allResults.tokens, limit),
+		utilities: limitResults(allResults.utilities, limit),
+		variants: limitResults(allResults.variants, limit),
+		modes: limitResults(allResults.modes, limit),
+		atRules: limitResults(allResults.atRules, limit),
+		aliases: limitResults(allResults.aliases, 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);
+	return {
+		version: MANIFEST_QUERY_VERSION,
+		root: context.root,
+		manifest: {
+			status: manifest.status,
+			entries: manifest.entries,
+			summary: summarizeManifest(activeManifest)
+		},
+		inputs: {
+			query: options.query,
+			kind,
+			namespace,
+			limit
+		},
+		results: limitedResults,
+		summary: {
+			total,
+			returned,
+			tokens: variables.length,
+			utilities: utilities.length,
+			variants: variants.length,
+			modes: modes.length,
+			atRules: atRules.length,
+			aliases: aliases.length,
+			status: "ok"
+		}
+	};
+}
+//#endregion
+export { queryManifest };

package/dist/manifest-summary.d.ts

@@ -0,0 +1,48 @@
+import { MasterCSSManifest, MasterCSSManifestAtRules, MasterCSSManifestUtility, MasterCSSManifestVariableEntry } from "@master/css-engine";
+
+//#region src/manifest-summary.d.ts
+declare function summarizeManifest(manifest: MasterCSSManifest): {
+  settings: import("@master/css-engine").MasterCSSManifestSettings;
+  counts: {
+    variables: number;
+    variableNamespaces: number;
+    utilities: number;
+    variants: number;
+    atRules: number;
+    breakpointAtRules: number;
+    containerAtRules: number;
+    selectors: number;
+    animations: number;
+  };
+};
+declare function compactVariable(variable: MasterCSSManifestVariableEntry): {
+  static?: boolean | undefined;
+  inline?: boolean | undefined;
+  modes?: string[] | undefined;
+  numeric?: import("@master/css-engine").MasterCSSManifestVariableNumericValue | undefined;
+  name: string;
+  key: string;
+  namespace: string;
+  type: "string" | "number";
+  value: import("@master/css-engine").MasterCSSManifestVariableValue | undefined;
+};
+declare function compactUtility(utility: MasterCSSManifestUtility): {
+  variableAliasRefs?: string[] | undefined;
+  aliasGroups?: string[] | undefined;
+  layer: import("@master/css-engine").MasterCSSManifestUtilityLayerName | undefined;
+  matcherTypes: ("static" | "pattern" | "key" | "variable" | "value")[];
+  emitType: "static" | "declarations" | "template" | "property";
+  namespaces?: string[] | undefined;
+  keys?: string[] | undefined;
+  subkey?: string | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+  id: string;
+};
+declare function compactAtRules(atRules: MasterCSSManifestAtRules | undefined): {
+  name: string;
+  id: import("@master/css-engine").MasterCSSManifestAtIdentifier;
+  nodes: number;
+}[];
+//#endregion
+export { compactAtRules, compactUtility, compactVariable, summarizeManifest };

package/dist/manifest-summary.js

@@ -0,0 +1,56 @@
+import { flattenMasterCSSManifestVariables } from "@master/css-engine";
+//#region src/manifest-summary.ts
+function summarizeManifest(manifest) {
+	const variables = flattenMasterCSSManifestVariables(manifest.variables);
+	return {
+		settings: manifest.settings ?? {},
+		counts: {
+			variables: variables.length,
+			variableNamespaces: Object.keys(manifest.variables || {}).length,
+			utilities: manifest.utilities?.length ?? 0,
+			variants: manifest.variants?.length ?? 0,
+			atRules: Object.keys(manifest.atRules || {}).length,
+			breakpointAtRules: Object.keys(manifest.breakpointAtRules || {}).length,
+			containerAtRules: Object.keys(manifest.containerAtRules || {}).length,
+			selectors: Object.keys(manifest.selectors || {}).length,
+			animations: Object.keys(manifest.animations || {}).length
+		}
+	};
+}
+function compactVariable(variable) {
+	return {
+		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 } : {}
+	};
+}
+function compactUtility(utility) {
+	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 } : {}
+	};
+}
+function compactAtRules(atRules) {
+	return Object.entries(atRules || {}).map(([name, rule]) => ({
+		name,
+		id: rule.id,
+		nodes: rule.nodes.length
+	}));
+}
+//#endregion
+export { compactAtRules, compactUtility, compactVariable, summarizeManifest };

package/dist/scan.d.ts

@@ -114,7 +114,7 @@ declare function inspectClass(context: MasterCSSMCPContext, options: InspectClas
   valueToken: string | undefined;
   stateToken: string | undefined;
   important: boolean | undefined;
-  matcherTypes: ("key" | "static" | "pattern" | "variable" | "value")[];
+  matcherTypes: ("static" | "pattern" | "key" | "variable" | "value")[];
   variables: {
     key: string;
     variable: import("@master/css-language").Variable;

package/dist/scan.js

@@ -1,10 +1,10 @@
 import { loadWorkspaceManifest } from "./project.js";
 import { createRequire } from "node:module";
+import { inspectMasterCSSClass } from "@master/css-engine/inspect";
+import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
 import { resolve } from "node:path";
 import fg from "fast-glob";
 import { createMasterCSSInspectionReport } from "@master/css-diagnostics";
-import { inspectMasterCSSClass } from "@master/css-engine/inspect";
-import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
 import { parseHTML } from "@master/css-server";
 //#region src/scan.ts
 const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php}"];

package/dist/server.js

@@ -1,12 +1,19 @@
-import MasterCSSMCPContext from "./context.js";
 import { jsonResourceResult, jsonToolResult } from "./result.js";
 import { getWorkspaceInfo, loadWorkspaceManifest } from "./project.js";
 import { inspectClass, previewGeneratedCSS, renderCSS, scanProject } from "./scan.js";
+import { extractClasses, traceClass } from "./classes.js";
+import { compareCSS } from "./compare.js";
+import MasterCSSMCPContext from "./context.js";
+import { getChangeImpact, getPackageGraph, getRepoContext, getTestRouter } from "./contributor.js";
+import { inspectDirectives } from "./directives.js";
+import { previewDirectiveFormat } from "./format.js";
 import { suggestSyntax } from "./language.js";
 import { lintContent, lintProject, previewLintFixes } from "./lint.js";
-import { readFileSync } from "node:fs";
+import { auditSetup } from "./setup.js";
+import { queryManifest } from "./manifest-query.js";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";
@@ -72,11 +79,26 @@ function registerPrompts(server) {
 		role: "user",
 		content: {
 			type: "text",
-			text: "Inspect the workspace with Master CSS MCP tools, identify current stylesheet entries and class extraction coverage, then plan migration steps that preserve CSS output unless a deliberate behavior change is requested."
+			text: [
+				"Use the Master CSS MCP tools to plan an incremental migration to Master CSS before editing.",
+				"Inspect the workspace, identify the framework, package manager, current styling systems, stylesheet entries, source extraction coverage, existing theme tokens, component classes, and available validation commands.",
+				"Produce a migration plan with the recommended rendering mode, the first reviewable migration batch, CSS output risks, manual visual checks, and the formatter, lint, type-check, test, or build commands to run.",
+				"Preserve CSS output unless a deliberate behavior change is requested, keep vendor or generated CSS in place, and use write previews only for safe, scoped changes."
+			].join("\n")
 		}
 	}] }));
 }
 function registerTools(server, context) {
+	const rangeSchema = z.object({
+		start: z.object({
+			line: z.number().int().min(0),
+			character: z.number().int().min(0)
+		}),
+		end: z.object({
+			line: z.number().int().min(0),
+			character: z.number().int().min(0)
+		})
+	});
 	server.registerTool("mastercss_workspace_info", {
 		title: "Master CSS Workspace Info",
 		description: "Report workspace roots, resolved Master CSS packages, and project manifest status.",
@@ -87,6 +109,16 @@ function registerTools(server, context) {
 			openWorldHint: false
 		}
 	}, async () => jsonToolResult(await getWorkspaceInfo(context)));
+	server.registerTool("mastercss_setup_audit", {
+		title: "Audit Master CSS Setup",
+		description: "Audit package, entry stylesheet, manifest, integration, and package-resolution setup for a workspace.",
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => jsonToolResult(await auditSetup(context)));
 	server.registerTool("mastercss_inspect_class", {
 		title: "Inspect Master CSS Class",
 		description: "Inspect one Master CSS class and return semantic parts, generated rules, variables, and CSS text.",
@@ -101,6 +133,54 @@ function registerTools(server, context) {
 			openWorldHint: false
 		}
 	}, async (input) => jsonToolResult(await inspectClass(context, input)));
+	server.registerTool("mastercss_trace_class", {
+		title: "Trace Master CSS Class",
+		description: "Trace one class from project extraction through generated CSS, missing CSS classification, and engine inspection.",
+		inputSchema: {
+			className: z.string().min(1),
+			patterns: z.array(z.string()).optional(),
+			includeCss: z.boolean().optional(),
+			mode: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await traceClass(context, input)));
+	server.registerTool("mastercss_extract_classes", {
+		title: "Extract Master CSS Classes",
+		description: "Extract class positions and validation summaries from project files or an in-memory source buffer.",
+		inputSchema: {
+			content: z.string().optional(),
+			filePath: z.string().optional(),
+			patterns: z.array(z.string()).optional(),
+			includeRules: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await extractClasses(context, input)));
+	server.registerTool("mastercss_inspect_directives", {
+		title: "Inspect Master CSS Directives",
+		description: "Inspect CSS-first directives from a stylesheet entry or in-memory CSS content and report manifest/CSS effects.",
+		inputSchema: {
+			content: z.string().optional(),
+			filePath: z.string().optional(),
+			entryPath: z.string().optional(),
+			preserveNativeCSS: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await inspectDirectives(context, input)));
 	server.registerTool("mastercss_render_css", {
 		title: "Render Master CSS",
 		description: "Generate CSS from an HTML fragment or a whitespace-separated class list.",
@@ -130,6 +210,108 @@ function registerTools(server, context) {
 			openWorldHint: false
 		}
 	}, async (input) => jsonToolResult(await scanProject(context, input)));
+	server.registerTool("mastercss_repo_context", {
+		title: "Master CSS Repository Context",
+		description: "Route Master CSS repository contributor work to affected packages, required context files, risks, and validation commands.",
+		inputSchema: {
+			task: z.string().optional(),
+			paths: z.array(z.string()).optional(),
+			diff: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await getRepoContext(context, input)));
+	server.registerTool("mastercss_change_impact", {
+		title: "Master CSS Change Impact",
+		description: "Classify contributor change risk for CSS output, runtime, extraction, language, ESLint, docs, and package boundaries.",
+		inputSchema: {
+			task: z.string().optional(),
+			paths: z.array(z.string()).optional(),
+			diff: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await getChangeImpact(context, input)));
+	server.registerTool("mastercss_test_router", {
+		title: "Master CSS Test Router",
+		description: "Return focused validation commands for Master CSS repository contributor changes.",
+		inputSchema: {
+			task: z.string().optional(),
+			paths: z.array(z.string()).optional(),
+			diff: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await getTestRouter(context, input)));
+	server.registerTool("mastercss_package_graph", {
+		title: "Master CSS Package Graph",
+		description: "Report Master CSS workspace package ownership, scripts, exports, workspace dependencies, and dependents.",
+		inputSchema: {
+			packageName: z.string().optional(),
+			includeExamples: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await getPackageGraph(context, input)));
+	server.registerTool("mastercss_manifest_query", {
+		title: "Query Master CSS Manifest",
+		description: "Query active manifest tokens, utilities, variants, modes, at-rules, and aliases.",
+		inputSchema: {
+			query: z.string().optional(),
+			kind: z.enum([
+				"all",
+				"token",
+				"utility",
+				"variant",
+				"mode",
+				"at-rule",
+				"alias"
+			]).optional(),
+			namespace: z.string().optional(),
+			limit: z.number().int().min(1).max(500).optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await queryManifest(context, input)));
+	server.registerTool("mastercss_css_compare", {
+		title: "Compare Master CSS Output",
+		description: "Compare generated CSS for before/after class lists, HTML fragments, or source buffers.",
+		inputSchema: {
+			beforeClassList: z.string().optional(),
+			afterClassList: z.string().optional(),
+			beforeHtml: z.string().optional(),
+			afterHtml: z.string().optional(),
+			beforeContent: z.string().optional(),
+			afterContent: z.string().optional(),
+			filePath: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await compareCSS(context, input)));
 	server.registerTool("mastercss_lint_project", {
 		title: "Lint Master CSS Project",
 		description: "Run Master CSS class-list diagnostics and return fix proposals without writing files.",
@@ -208,6 +390,23 @@ function registerTools(server, context) {
 		}
 		return jsonToolResult(await previewLintFixes(context, input));
 	});
+	server.registerTool("mastercss_preview_directive_format", {
+		title: "Preview Master CSS Directive Format",
+		description: "Create a safe preview for formatting Master CSS directives, or format in-memory content without writing files.",
+		inputSchema: {
+			content: z.string().optional(),
+			filePath: z.string().optional(),
+			patterns: z.array(z.string()).optional(),
+			range: rangeSchema.optional(),
+			ttlMs: z.number().int().min(1e3).max(3600 * 1e3).optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (input) => jsonToolResult(await previewDirectiveFormat(context, input)));
 	server.registerTool("mastercss_apply_preview", {
 		title: "Apply Master CSS Preview",
 		description: "Apply a previously generated preview token after validating hashes and workspace containment.",

package/dist/setup.d.ts

@@ -0,0 +1,63 @@
+import MasterCSSMCPContext from "./context.js";
+
+//#region src/setup.d.ts
+type SetupDiagnosticSeverity = 'error' | 'warning' | 'info';
+interface SetupDiagnostic {
+  code: string;
+  severity: SetupDiagnosticSeverity;
+  message: string;
+  data?: unknown;
+}
+declare function auditSetup(context: MasterCSSMCPContext): Promise<{
+  version: number;
+  root: string;
+  status: string;
+  packageManager: {
+    declared: string | undefined;
+    lockfiles: {
+      name: string;
+      filePath: string;
+    }[];
+    inferred: string;
+  };
+  packageJSON: {
+    error?: string | undefined;
+    filePath: string;
+    loaded: boolean;
+  };
+  packages: {
+    declared: {
+      name: string;
+      version: string;
+    }[];
+    resolved: import("@master/css-project/workspace").MasterCSSWorkspacePackageResolution;
+  };
+  integrations: ({
+    type: "package";
+    name: string;
+    version: string;
+  } | {
+    type: "script";
+    name: string;
+    command: string;
+  })[];
+  manifest: {
+    error?: string | undefined;
+    status: "loaded" | "error";
+    entries: string[];
+    dependencies: string[];
+    warnings: string[];
+  };
+  diagnostics: SetupDiagnostic[];
+  summary: {
+    status: string;
+    entries: number;
+    declaredPackages: number;
+    integrations: number;
+    errors: number;
+    warnings: number;
+    info: number;
+  };
+}>;
+//#endregion
+export { auditSetup };