@master/css-mcp 2.0.0-rc.88 → 2.0.1

package/dist/project.js

@@ -1,42 +1,101 @@
+import { resolveMasterCSSWorkspacePackages } from "./internal/src/workspace.js";
 import { getErrorMessage } from "./result.js";
-import { loadProjectManifest } from "@master/css-project/manifest";
-import { findCSSManifestEntryFiles } from "@master/css-project/entries";
-import { resolveMasterCSSWorkspacePackages } from "@master/css-project/workspace";
-//#region src/project.ts
-async function loadWorkspaceManifest(context) {
+import { createHash } from "node:crypto";
+import { getToolingBindingInfo } from "@master/css-tooling/node";
+import { discoverManifestEntries, loadProjectManifest } from "@master/css-compiler/project";
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
+// src/project.ts
+const defaultManifest = defaultManifestJSON;
+function manifestFingerprint(manifest) {
+	return createHash("sha256").update(JSON.stringify(manifest)).digest("hex");
+}
+async function loadWorkspaceManifest(context, requested = "project", explicitEntries) {
+	let entries = [];
+	const nativeClassNames = [];
+	let versions;
 	try {
-		const result = await loadProjectManifest(context.root);
+		versions = getToolingBindingInfo();
+		if (requested === "project") {
+			entries = explicitEntries ?? await discoverManifestEntries({ root: context.root });
+			if (!entries.length) return {
+				status: "error",
+				reason: "entry-not-found",
+				entries,
+				nativeClassNames,
+				dependencies: [],
+				warnings: [],
+				diagnostics: [],
+				context: requested,
+				versions,
+				fingerprint: null,
+				error: "No project CSS entry was found. Add a project entry or explicitly select context: \"preset\"."
+			};
+		}
+		const result = requested === "preset" ? {
+			manifest: defaultManifest,
+			nativeClassNames,
+			entries: [],
+			dependencies: [],
+			diagnostics: []
+		} : await loadProjectManifest({
+			root: context.root,
+			entries,
+			baseManifest: {
+				version: 6,
+				languageVersion: 18
+			}
+		});
 		return {
 			status: "loaded",
+			context: requested,
+			versions,
+			fingerprint: manifestFingerprint(result.manifest),
 			manifest: result.manifest,
+			nativeClassNames: result.nativeClassNames,
 			entries: result.entries,
 			dependencies: result.dependencies ?? [],
-			warnings: result.warnings ?? []
+			diagnostics: result.diagnostics,
+			warnings: result.diagnostics.map((diagnostic) => diagnostic.message)
 		};
 	} catch (error) {
 		return {
 			status: "error",
-			entries: [],
+			reason: "entry-load-failed",
+			context: requested,
+			versions,
+			fingerprint: null,
+			entries,
+			nativeClassNames,
 			dependencies: [],
 			warnings: [],
+			diagnostics: error && typeof error === "object" && "diagnostics" in error && Array.isArray(error.diagnostics) ? error.diagnostics : error && typeof error === "object" && "diagnostic" in error ? [error.diagnostic] : [],
 			error: getErrorMessage(error)
 		};
 	}
 }
+function requireWorkspaceManifest(result) {
+	if (result.status === "loaded") return result.manifest;
+	throw Object.assign(new Error(result.error), {
+		code: result.reason === "entry-not-found" ? "PROJECT_ENTRY_NOT_FOUND" : "PROJECT_MANIFEST_LOAD_FAILED",
+		context: result.context,
+		manifest: manifestMetadata(result),
+		diagnostics: result.diagnostics
+	});
+}
+function manifestMetadata(result) {
+	const { manifest: _manifest, nativeClassNames: _nativeClassNames, ...metadata } = {
+		manifest: void 0,
+		...result
+	};
+	return metadata;
+}
 async function getWorkspaceInfo(context) {
-	const [manifest, entries] = await Promise.all([loadWorkspaceManifest(context), findCSSManifestEntryFiles(context.root).catch(() => [])]);
+	const manifest = await loadWorkspaceManifest(context);
 	return {
 		root: context.root,
 		roots: context.roots,
 		packages: resolveMasterCSSWorkspacePackages(context.root),
-		manifest: {
-			status: manifest.status,
-			entries: manifest.status === "loaded" ? manifest.entries : entries,
-			dependencies: manifest.dependencies,
-			warnings: manifest.warnings,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		}
+		manifest: manifestMetadata(manifest)
 	};
 }
-//#endregion
-export { getWorkspaceInfo, loadWorkspaceManifest };
+export { getWorkspaceInfo, loadWorkspaceManifest, manifestFingerprint, manifestMetadata, requireWorkspaceManifest };

package/dist/result.js

@@ -1,22 +1,81 @@
-//#region src/result.ts
+const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+function normalizeResult(value) {
+	const payload = record(value);
+	const manifest = record(payload.manifest);
+	const context = record(payload.context);
+	const semantic = context.context ? context : manifest.context ? manifest : typeof payload.context === "string" ? payload : {};
+	const diagnostics = Array.isArray(payload.diagnostics) ? payload.diagnostics : [];
+	const failed = payload.status === "error";
+	const error = record(payload.error);
+	return {
+		version: 3,
+		metadata: {
+			versions: semantic.versions ?? null,
+			context: semantic.context ?? (typeof payload.context === "string" ? payload.context : null),
+			manifestFingerprint: semantic.fingerprint ?? null,
+			entries: semantic.entries ?? [],
+			dependencies: semantic.dependencies ?? []
+		},
+		diagnostics,
+		result: failed ? {
+			status: "error",
+			error: {
+				code: error.code ?? "TOOL_EXECUTION_FAILED",
+				message: error.message ?? "Tool execution failed"
+			}
+		} : {
+			status: "success",
+			data: value
+		}
+	};
+}
 function toJSONText(value) {
 	return JSON.stringify(value, null, 2);
 }
 function jsonToolResult(value) {
-	return { content: [{
-		type: "text",
-		text: toJSONText(value)
-	}] };
+	const text = toJSONText(normalizeResult(value));
+	const structuredContent = JSON.parse(text);
+	return {
+		structuredContent,
+		content: [{
+			type: "text",
+			text
+		}],
+		...record(structuredContent.result).status === "error" ? { isError: true } : {}
+	};
 }
 function jsonResourceResult(uri, value) {
 	return { contents: [{
 		uri: String(uri),
 		mimeType: "application/json",
-		text: toJSONText(value)
+		text: toJSONText(normalizeResult(value))
 	}] };
 }
 function getErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-//#endregion
-export { getErrorMessage, jsonResourceResult, jsonToolResult, toJSONText };
+async function executeTool(operation) {
+	try {
+		return jsonToolResult(await operation());
+	} catch (error) {
+		const detail = record(error);
+		const code = typeof detail.code === "string" ? detail.code : "TOOL_EXECUTION_FAILED";
+		const message = getErrorMessage(error);
+		return jsonToolResult({
+			status: "error",
+			error: {
+				code,
+				message
+			},
+			context: detail.context,
+			manifest: detail.manifest,
+			diagnostics: [{
+				code,
+				phase: "compiler",
+				severity: "error",
+				message
+			}, ...Array.isArray(detail.diagnostics) ? detail.diagnostics : []]
+		});
+	}
+}
+export { executeTool, getErrorMessage, jsonResourceResult, jsonToolResult, toJSONText };

package/dist/scan.js

@@ -1,115 +1,136 @@
-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 { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
+import { compactClassInspection, createMCPToolingSession } from "./tooling-session.js";
+import { extname, resolve } from "node:path";
+import { createToolingSessionSync } from "@master/css-tooling/node";
+import { SourcePolicy } from "@master/css-tooling/scanner/node";
 import fg from "fast-glob";
-import { createMasterCSSInspectionReport } from "@master/css-diagnostics";
-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}"];
+import { renderClassNamesSync } from "@master/css/node";
+import { captureMasterCSSProject, createMasterCSSInspectionReport } from "@master/css-compiler/diagnostics";
+// src/scan.ts
+const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,mjs,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php}"];
 const DEFAULT_IGNORE_PATTERNS = ["**/node_modules/**", "node_modules"];
-const defaultManifest = createRequire(import.meta.url)("@master/css-preset/default-manifest.json");
 async function resolveSourceFiles(context, patterns = DEFAULT_SOURCE_PATTERNS, ignore = DEFAULT_IGNORE_PATTERNS) {
 	context.validateGlobPatterns(patterns);
 	const sources = await fg(patterns, {
 		cwd: context.root,
 		ignore,
-		onlyFiles: true
+		onlyFiles: true,
+		followSymbolicLinks: false
 	});
-	return Promise.all(sources.map((source) => context.resolveExistingFile(source)));
+	const policy = new SourcePolicy(context.root, { exclude: ignore });
+	return Promise.all(sources.filter((source) => policy.accepts(source, patterns !== DEFAULT_SOURCE_PATTERNS)).map((source) => context.resolveExistingFile(source)));
 }
 async function scanProject(context, options = {}) {
-	const [report, manifest] = await Promise.all([createMasterCSSInspectionReport({
+	if (options.designSystem && options.context === "preset") throw new Error("designSystem inspection requires project context; omit context or select \"project\".");
+	if (options.routeStylesheets?.length && !options.designSystem) throw new Error("routeStylesheets requires designSystem.");
+	let routeStylesheets;
+	if (options.routeStylesheets?.length) {
+		context.validateGlobPatterns(options.routeStylesheets);
+		const sources = await fg(options.routeStylesheets, {
+			cwd: context.root,
+			ignore: DEFAULT_IGNORE_PATTERNS,
+			onlyFiles: true,
+			followSymbolicLinks: false
+		});
+		if (sources.some((source) => !source.endsWith(".css"))) throw new Error("routeStylesheets must match .css files only.");
+		routeStylesheets = await Promise.all(sources.sort().map((source) => context.resolveExistingFile(source)));
+	}
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const inspectionOptions = {
+		manifest: requireWorkspaceManifest(manifest),
 		cwd: context.root,
 		patterns: options.patterns,
 		classes: options.classes,
 		includeCss: options.includeCss,
+		designSystem: options.designSystem,
+		routeStylesheets,
 		resolveExistingFile: (filePath) => context.resolveExistingFile(filePath),
 		validatePatterns: (patterns) => context.validateGlobPatterns(patterns)
-	}), loadWorkspaceManifest(context)]);
+	};
+	if (options.includeSnapshot) {
+		const { report, snapshot } = await captureMasterCSSProject(inspectionOptions);
+		return {
+			...report,
+			root: context.root,
+			manifest: manifestMetadata(manifest),
+			snapshot
+		};
+	}
 	return {
-		...report,
+		...await createMasterCSSInspectionReport(inspectionOptions),
 		root: context.root,
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			dependencies: manifest.dependencies,
-			warnings: manifest.warnings,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		}
+		manifest: manifestMetadata(manifest)
 	};
 }
 async function renderCSS(context, options) {
-	const manifest = await loadWorkspaceManifest(context);
-	const css = createCSSWithNativeDeclarations(manifest.status === "loaded" ? manifest.manifest : defaultManifest);
-	const classes = options.html ? parseHTML(options.html).classes : (options.classList ?? "").split(/\s+/).map((className) => className.trim()).filter(Boolean);
-	const invalid = [];
-	for (const className of classes) {
-		const rules = css.generate(className);
-		if (rules.length) for (const rule of rules) rule.layer.insert(rule);
-		else invalid.push(className);
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	let classes;
+	if (options.html) {
+		const tooling = createToolingSessionSync({
+			manifest: requireWorkspaceManifest(manifest),
+			nativeClassNames: manifest.nativeClassNames
+		});
+		try {
+			classes = [...tooling.extractSource({ files: [{
+				source: "index.html",
+				content: options.html,
+				kind: "html"
+			}] }).files[0]?.candidates ?? []];
+		} finally {
+			tooling.dispose();
+		}
+	} else classes = (options.classList ?? "").split(/\s+/).map((className) => className.trim()).filter(Boolean);
+	const rendered = renderClassNamesSync(classes, { manifest: requireWorkspaceManifest(manifest) });
+	const tooling = createMCPToolingSession(requireWorkspaceManifest(manifest), manifest.nativeClassNames);
+	let inspections;
+	try {
+		inspections = classes.map((className) => compactClassInspection(tooling, className, true));
+	} finally {
+		tooling.dispose();
 	}
 	return {
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		},
+		manifest: manifestMetadata(manifest),
 		classes,
-		invalid,
+		inspections,
+		diagnostics: inspections.flatMap((inspection) => inspection.diagnostics ?? []),
+		invalid: rendered.invalidClassNames,
 		css: {
-			bytes: css.text.length,
-			text: css.text
+			bytes: Buffer.byteLength(rendered.cssText, "utf8"),
+			text: rendered.cssText
 		}
 	};
 }
 async function inspectClass(context, options) {
-	const manifest = await loadWorkspaceManifest(context);
-	const inspection = inspectMasterCSSClass(createCSSWithNativeDeclarations(manifest.status === "loaded" ? manifest.manifest : defaultManifest), options.className, options.mode);
-	const rules = inspection.rules.map((rule) => ({
-		className: rule.name,
-		layer: rule.layerName,
-		type: rule.type,
-		text: rule.text
-	}));
-	return {
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		},
-		className: options.className,
-		mode: options.mode,
-		valid: rules.length > 0,
-		base: inspection.base,
-		suffix: inspection.suffix,
-		key: inspection.key,
-		value: inspection.value,
-		keyToken: inspection.keyToken,
-		valueToken: inspection.valueToken,
-		stateToken: inspection.stateToken,
-		important: inspection.important,
-		matcherTypes: inspection.matcherTypes,
-		variables: inspection.variableEntries.map(({ key, variable }) => ({
-			key,
-			variable
-		})),
-		rules,
-		css: rules.map((rule) => rule.text).join("")
-	};
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const session = createMCPToolingSession(requireWorkspaceManifest(manifest), manifest.nativeClassNames);
+	try {
+		const inspection = session.inspectClassName(options.className);
+		const compact = compactClassInspection(session, options.className, true, inspection);
+		return {
+			manifest: manifestMetadata(manifest),
+			...compact,
+			css: inspection.rules.map((rule) => rule.text).join("")
+		};
+	} finally {
+		session.dispose?.();
+	}
 }
 async function previewGeneratedCSS(context, options) {
+	if (extname(options.outputPath).toLowerCase() !== ".css") throw new Error("outputPath must name a .css file.");
 	const report = await scanProject(context, {
 		patterns: options.patterns,
 		classes: options.classes,
-		includeCss: true
+		includeCss: true,
+		context: options.context
 	});
 	const preview = await context.createPreview([{
 		filePath: resolve(context.root, options.outputPath),
 		afterText: report.css.text ?? ""
 	}], options.ttlMs);
 	return {
+		manifest: report.manifest,
+		diagnostics: report.diagnostics,
+		inspections: report.inspections,
 		mode: "generated-css",
 		outputPath: await context.resolveWritableFile(options.outputPath),
 		preview,
@@ -122,5 +143,4 @@ async function previewGeneratedCSS(context, options) {
 		}
 	};
 }
-//#endregion
 export { inspectClass, previewGeneratedCSS, renderCSS, resolveSourceFiles, scanProject };