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

package/dist/document.js

@@ -1,7 +1,7 @@
 import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import { TextDocument } from "vscode-languageserver-textdocument";
-//#region src/document.ts
+// src/document.ts
 const languageByExtension = {
 	".astro": "astro",
 	".css": "css",
@@ -30,13 +30,6 @@ function getLanguageId(filePath) {
 function createMCPTextDocument(filePath, content) {
 	return TextDocument.create(pathToFileURL(filePath).href, getLanguageId(filePath), 0, content);
 }
-function toOffsetRange(document, range) {
-	if (!range) return;
-	return {
-		start: document.offsetAt(range.start),
-		end: document.offsetAt(range.end)
-	};
-}
 function applyTextEdits(content, document, edits) {
 	let result = content;
 	const offsetEdits = edits.map((edit) => ({
@@ -47,5 +40,4 @@ function applyTextEdits(content, document, edits) {
 	for (const edit of offsetEdits.sort((a, b) => b.start - a.start || b.end - a.end)) result = result.slice(0, edit.start) + edit.newText + result.slice(edit.end);
 	return result;
 }
-//#endregion
-export { applyTextEdits, createMCPTextDocument, getLanguageId, languageByExtension, toOffsetRange };
+export { applyTextEdits, createMCPTextDocument, getLanguageId, languageByExtension };

package/dist/format.js

@@ -1,8 +1,10 @@
-import { applyTextEdits, createMCPTextDocument, getLanguageId } from "./document.js";
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
 import { resolveSourceFiles } from "./scan.js";
+import { applyTextEdits, createMCPTextDocument, getLanguageId } from "./document.js";
 import { readFile } from "node:fs/promises";
-import CSSLanguageService from "@master/css-language-service";
-//#region src/format.ts
+import { createToolingSessionSync } from "@master/css-tooling/node";
+import { MasterCSSLanguageService } from "@master/css-language-service";
+// src/format.ts
 const DIRECTIVE_FORMAT_PREVIEW_VERSION = 1;
 const DEFAULT_DIRECTIVE_FORMAT_PATTERNS = ["**/*.{css,scss,less,vue,svelte,astro}"];
 function formatContent(service, filePath, content, range) {
@@ -14,69 +16,78 @@ function formatContent(service, filePath, content, range) {
 		languageId: getLanguageId(filePath),
 		edits,
 		changed: formatted !== content,
-		beforeBytes: content.length,
-		afterBytes: formatted.length,
+		beforeBytes: Buffer.byteLength(content, "utf8"),
+		afterBytes: Buffer.byteLength(formatted, "utf8"),
 		formatted
 	};
 }
 async function previewDirectiveFormat(context, options = {}) {
-	const service = new CSSLanguageService();
-	if (options.content !== void 0) {
-		const filePath = context.resolveVirtualPath(options.filePath || "master.css");
-		const formatted = formatContent(service, filePath, options.content, options.range);
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const service = new MasterCSSLanguageService(void 0, { session: createToolingSessionSync({
+		manifest: requireWorkspaceManifest(manifest),
+		nativeClassNames: manifest.nativeClassNames
+	}) });
+	try {
+		if (options.content !== void 0) {
+			const filePath = context.resolveVirtualPath(options.filePath || "master.css");
+			const formatted = formatContent(service, filePath, options.content, options.range);
+			return {
+				version: DIRECTIVE_FORMAT_PREVIEW_VERSION,
+				manifest: manifestMetadata(manifest),
+				root: context.root,
+				mode: "content",
+				files: [{
+					filePath,
+					languageId: formatted.languageId,
+					edits: formatted.edits,
+					changed: formatted.changed,
+					beforeBytes: formatted.beforeBytes,
+					afterBytes: formatted.afterBytes
+				}],
+				formatted: formatted.formatted,
+				summary: {
+					files: 1,
+					changed: formatted.changed ? 1 : 0,
+					edits: formatted.edits.length
+				}
+			};
+		}
+		const files = await resolveSourceFiles(context, options.patterns ?? DEFAULT_DIRECTIVE_FORMAT_PATTERNS);
+		const formattedFiles = await Promise.all(files.map(async (filePath) => {
+			const content = await readFile(filePath, "utf8");
+			return formatContent(service, filePath, content, options.range);
+		}));
+		const preview = await context.createPreview(formattedFiles.filter((file) => file.changed).map((file) => ({
+			filePath: file.filePath,
+			beforeText: void 0,
+			afterText: file.formatted
+		})), options.ttlMs);
 		return {
 			version: DIRECTIVE_FORMAT_PREVIEW_VERSION,
+			manifest: manifestMetadata(manifest),
 			root: context.root,
-			mode: "content",
-			files: [{
-				filePath,
-				languageId: formatted.languageId,
-				edits: formatted.edits,
-				changed: formatted.changed,
-				beforeBytes: formatted.beforeBytes,
-				afterBytes: formatted.afterBytes
-			}],
-			formatted: formatted.formatted,
+			mode: "files",
+			inputs: {
+				patterns: options.patterns ?? DEFAULT_DIRECTIVE_FORMAT_PATTERNS,
+				files
+			},
+			preview,
+			files: formattedFiles.map((file) => ({
+				filePath: file.filePath,
+				languageId: file.languageId,
+				edits: file.edits,
+				changed: file.changed,
+				beforeBytes: file.beforeBytes,
+				afterBytes: file.afterBytes
+			})),
 			summary: {
-				files: 1,
-				changed: formatted.changed ? 1 : 0,
-				edits: formatted.edits.length
+				files: formattedFiles.length,
+				changed: formattedFiles.filter((file) => file.changed).length,
+				edits: formattedFiles.reduce((count, file) => count + file.edits.length, 0)
 			}
 		};
+	} finally {
+		service.dispose();
 	}
-	const files = await resolveSourceFiles(context, options.patterns ?? DEFAULT_DIRECTIVE_FORMAT_PATTERNS);
-	const formattedFiles = await Promise.all(files.map(async (filePath) => {
-		const content = await readFile(filePath, "utf8");
-		return formatContent(service, filePath, content, options.range);
-	}));
-	const preview = await context.createPreview(formattedFiles.filter((file) => file.changed).map((file) => ({
-		filePath: file.filePath,
-		beforeText: void 0,
-		afterText: file.formatted
-	})), options.ttlMs);
-	return {
-		version: DIRECTIVE_FORMAT_PREVIEW_VERSION,
-		root: context.root,
-		mode: "files",
-		inputs: {
-			patterns: options.patterns ?? DEFAULT_DIRECTIVE_FORMAT_PATTERNS,
-			files
-		},
-		preview,
-		files: formattedFiles.map((file) => ({
-			filePath: file.filePath,
-			languageId: file.languageId,
-			edits: file.edits,
-			changed: file.changed,
-			beforeBytes: file.beforeBytes,
-			afterBytes: file.afterBytes
-		})),
-		summary: {
-			files: formattedFiles.length,
-			changed: formattedFiles.filter((file) => file.changed).length,
-			edits: formattedFiles.reduce((count, file) => count + file.edits.length, 0)
-		}
-	};
 }
-//#endregion
 export { previewDirectiveFormat };

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-import MasterCSSMCPContext, { MasterCSSMCPContextOptions } from "./context.js";
-import { MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer } from "./server.js";
-export { MasterCSSMCPContext, type MasterCSSMCPContextOptions, type MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer };
+import { createMasterCSSMCPServer, startMasterCSSMCPStdioServer } from "./server.js";
+export { createMasterCSSMCPServer, startMasterCSSMCPStdioServer };

package/dist/index.js

@@ -1,3 +1 @@
-import MasterCSSMCPContext from "./context.js";
-import { createMasterCSSMCPServer, startStdioServer } from "./server.js";
-export { MasterCSSMCPContext, createMasterCSSMCPServer, startStdioServer };
+export { createMasterCSSMCPServer, startMasterCSSMCPStdioServer } from "./server.js";

package/dist/internal/src/workspace.js

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+// ../internal/src/workspace.ts
+function readPackageJSON(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageDir(entry, packageName) {
+	let current = statSync(entry).isDirectory() ? entry : dirname(entry);
+	while (current !== dirname(current)) {
+		const packageJSONPath = join(current, "package.json");
+		if (existsSync(packageJSONPath)) {
+			const packageJSON = readPackageJSON(packageJSONPath);
+			if (packageJSON?.name === packageName) return {
+				directory: current,
+				packageJSONPath,
+				version: typeof packageJSON.version === "string" ? packageJSON.version : void 0
+			};
+		}
+		current = dirname(current);
+	}
+}
+function resolvePackage(name, resolver) {
+	const entry = resolver.resolve(name);
+	const packageRoot = findPackageDir(entry, name.startsWith("@master/css-preset/") ? "@master/css-preset" : name.startsWith("@master/css-schema/") ? "@master/css-schema" : name.startsWith("@master/css-language-server/") ? "@master/css-language-server" : name);
+	if (!packageRoot) throw new Error(`Unable to find package root for ${name} from ${entry}`);
+	return {
+		name,
+		entry,
+		directory: packageRoot.directory,
+		packageJSON: packageRoot.packageJSONPath,
+		version: packageRoot.version
+	};
+}
+function tryResolvePackage(name, resolver, errors) {
+	try {
+		return resolvePackage(name, resolver);
+	} catch (error) {
+		errors.push({
+			name,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function createWorkspaceRequire(workspaceDir) {
+	return createRequire(join(resolve(workspaceDir), "package.json"));
+}
+function createPackageRequire(resolvedPackage) {
+	return createRequire(resolvedPackage.packageJSON || join(resolvedPackage.directory, "package.json"));
+}
+function resolveMasterCSSWorkspacePackages(workspaceDir = process.cwd()) {
+	const errors = [];
+	const workspaceRequire = createWorkspaceRequire(workspaceDir);
+	const css = tryResolvePackage("@master/css", workspaceRequire, errors);
+	const result = {
+		workspaceDir: resolve(workspaceDir),
+		errors,
+		...css ? { css } : {}
+	};
+	if (css) result.presetManifest = tryResolvePackage("@master/css-preset/default-manifest.json", createPackageRequire(css), errors);
+	try {
+		result.languageServer = resolvePackage("@master/css-language-server/server", workspaceRequire);
+	} catch {}
+	return result;
+}
+export { resolveMasterCSSWorkspacePackages };

package/dist/language.js

@@ -1,28 +1,32 @@
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
 import { createMCPTextDocument } from "./document.js";
-import { loadWorkspaceManifest } from "./project.js";
-import CSSLanguageService from "@master/css-language-service";
-//#region src/language.ts
+import { createToolingSessionSync } from "@master/css-tooling/node";
+import { MasterCSSLanguageService } from "@master/css-language-service";
+// src/language.ts
 async function suggestSyntax(context, options) {
 	const filePath = context.resolveVirtualPath(options.filePath);
-	const manifest = await loadWorkspaceManifest(context);
-	const service = new CSSLanguageService(manifest.status === "loaded" ? { manifest: manifest.manifest } : void 0);
-	const document = createMCPTextDocument(filePath, options.content);
-	const completions = service.suggestSyntax(document, options.position, {
-		triggerKind: options.triggerCharacter ? 2 : 1,
-		...options.triggerCharacter ? { triggerCharacter: options.triggerCharacter } : {}
-	}) ?? [];
-	const hover = service.inspectSyntax(document, options.position);
-	const limit = options.limit ?? 50;
-	return {
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		},
-		completions: completions.slice(0, limit),
-		total: completions.length,
-		hover
-	};
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const session = createToolingSessionSync({
+		manifest: requireWorkspaceManifest(manifest),
+		nativeClassNames: manifest.nativeClassNames
+	});
+	const service = new MasterCSSLanguageService({ manifest: requireWorkspaceManifest(manifest) }, { session });
+	try {
+		const document = createMCPTextDocument(filePath, options.content);
+		const completions = service.suggestSyntax(document, options.position, {
+			triggerKind: options.triggerCharacter ? 2 : 1,
+			...options.triggerCharacter ? { triggerCharacter: options.triggerCharacter } : {}
+		}) ?? [];
+		const hover = service.inspectSyntax(document, options.position);
+		const limit = options.limit ?? 50;
+		return {
+			manifest: manifestMetadata(manifest),
+			completions: completions.slice(0, limit),
+			total: completions.length,
+			hover
+		};
+	} finally {
+		service.dispose();
+	}
 }
-//#endregion
 export { suggestSyntax };

package/dist/lint.js

@@ -1,132 +1,122 @@
-import { loadWorkspaceManifest } from "./project.js";
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
 import { resolveSourceFiles } from "./scan.js";
 import { readFile } from "node:fs/promises";
-import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
-import { fixMasterCSSContent, lintMasterCSSContent, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "@master/css-lint";
-//#region src/lint.ts
+import { createToolingSessionSync } from "@master/css-tooling/node";
+import { fixMasterCSSContent, lintMasterCSSContent, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "@master/css-tooling/lint";
+// src/lint.ts
 const DEFAULT_LINT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php,css,scss,less}"];
 const DEFAULT_IGNORE_PATTERNS = ["**/node_modules/**", "node_modules"];
-const LINT_REPORT_VERSION = 1;
-function createManifestDiagnostic(context, message) {
-	return {
-		ruleId: "manifest",
-		code: "manifest-loading-error",
-		severity: "error",
-		message,
-		range: {
-			start: 0,
-			end: 0
-		},
-		loc: {
-			start: {
-				line: 1,
-				column: 1
-			},
-			end: {
-				line: 1,
-				column: 1
-			}
-		},
-		source: "Master CSS",
-		sourceKind: "manifest",
-		data: { cwd: context.root }
-	};
-}
+const LINT_REPORT_VERSION = 5;
 async function loadLintState(context, options = {}) {
 	const rules = resolveMasterCSSLintRules(options.rules);
-	const manifest = await loadWorkspaceManifest(context);
-	const css = manifest.status === "loaded" ? createCSSWithNativeDeclarations(manifest.manifest) : void 0;
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const lintSession = createToolingSessionSync({
+		manifest: requireWorkspaceManifest(manifest),
+		nativeClassNames: manifest.nativeClassNames
+	});
 	const files = await resolveSourceFiles(context, options.patterns ?? DEFAULT_LINT_SOURCE_PATTERNS, options.patterns ? [] : DEFAULT_IGNORE_PATTERNS);
 	return {
 		rules,
 		manifest,
-		css,
+		lintSession,
 		inputs: await Promise.all(files.map(async (filePath) => ({
 			filePath,
 			content: await readFile(filePath, "utf8")
 		})))
 	};
 }
-function lintInputs(inputs, css, rules) {
+function lintInputs(inputs, rules, lintSession) {
 	return inputs.map((input) => lintMasterCSSContent({
 		content: input.content,
 		filePath: input.filePath,
-		css,
-		rules
+		rules,
+		lintSession
 	})).filter((result) => result.diagnostics.length);
 }
-function createManifestFileResult(context, diagnostic) {
+function lintCoverage(files, checkedFiles) {
+	const { files: _files, ...summary } = summarizeMasterCSSLintFiles(files);
 	return {
-		filePath: context.root,
-		languageId: "manifest",
-		sourceKind: "manifest",
-		diagnostics: [diagnostic]
+		coverage: {
+			status: checkedFiles.length ? "complete" : "no-inputs",
+			checkedFiles,
+			description: checkedFiles.length ? "Source lint ran on every path in checkedFiles with the enabled rules. The files array lists only diagnostic results; an empty files array means those inputs produced no diagnostics. manifest.entries lists stylesheet entries used to load the manifest, not linted source inputs. Browser behavior is not checked." : "No source inputs matched, so source lint did not run. Zero diagnostics does not verify any source file or browser behavior."
+		},
+		summary: {
+			...summary,
+			checkedFiles: checkedFiles.length,
+			filesWithDiagnostics: files.filter((file) => file.diagnostics.length).length
+		}
 	};
 }
 async function lintProject(context, options = {}) {
 	const state = await loadLintState(context, options);
-	const files = state.manifest.status === "error" || !state.css ? [createManifestFileResult(context, createManifestDiagnostic(context, `Failed to load Master CSS manifest: ${state.manifest.error}`))] : lintInputs(state.inputs, state.css, state.rules);
-	return {
-		version: LINT_REPORT_VERSION,
-		root: context.root,
-		manifest: {
-			status: state.manifest.status,
-			entries: state.manifest.entries,
-			diagnostics: state.manifest.status === "error" ? files[0].diagnostics : []
-		},
-		files,
-		summary: summarizeMasterCSSLintFiles(files)
-	};
+	try {
+		const files = lintInputs(state.inputs, state.rules, state.lintSession);
+		return {
+			version: LINT_REPORT_VERSION,
+			root: context.root,
+			manifest: manifestMetadata(state.manifest),
+			files,
+			diagnostics: files.flatMap((file) => file.diagnostics),
+			...lintCoverage(files, state.inputs.map((input) => input.filePath))
+		};
+	} finally {
+		state.lintSession?.dispose();
+	}
 }
 async function lintContent(context, options) {
 	const rules = resolveMasterCSSLintRules(options.rules);
 	const filePath = context.resolveVirtualPath(options.filePath);
-	const manifest = await loadWorkspaceManifest(context);
-	const files = manifest.status === "error" ? [createManifestFileResult(context, createManifestDiagnostic(context, `Failed to load Master CSS manifest: ${manifest.error}`))] : [lintMasterCSSContent({
-		content: options.content,
-		filePath,
-		css: createCSSWithNativeDeclarations(manifest.manifest),
-		rules
-	})];
-	return {
-		version: LINT_REPORT_VERSION,
-		root: context.root,
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			diagnostics: manifest.status === "error" ? files[0].diagnostics : []
-		},
-		files,
-		summary: summarizeMasterCSSLintFiles(files)
-	};
+	const manifest = await loadWorkspaceManifest(context, options.context);
+	const lintSession = createToolingSessionSync({
+		manifest: requireWorkspaceManifest(manifest),
+		nativeClassNames: manifest.nativeClassNames
+	});
+	try {
+		const files = [lintMasterCSSContent({
+			content: options.content,
+			filePath,
+			rules,
+			lintSession
+		})].filter((file) => file.diagnostics.length);
+		return {
+			version: LINT_REPORT_VERSION,
+			root: context.root,
+			manifest: manifestMetadata(manifest),
+			files,
+			diagnostics: files.flatMap((file) => file.diagnostics),
+			...lintCoverage(files, [filePath])
+		};
+	} finally {
+		lintSession?.dispose();
+	}
 }
 async function previewLintFixes(context, options = {}) {
 	const state = await loadLintState(context, options);
-	if (state.manifest.status === "error" || !state.css) return {
-		mode: "lint-fixes",
-		preview: await context.createPreview([], options.ttlMs),
-		lint: await lintProject(context, options)
-	};
-	const changes = [];
-	for (const input of state.inputs) {
-		const fixed = fixMasterCSSContent({
-			content: input.content,
-			filePath: input.filePath,
-			css: state.css,
-			rules: state.rules,
-			includeDirectiveFixes: Boolean(options.includeDirectiveFixes)
-		});
-		if (fixed !== input.content) changes.push({
-			filePath: input.filePath,
-			beforeText: input.content,
-			afterText: fixed
-		});
+	try {
+		const changes = [];
+		for (const input of state.inputs) {
+			const fixed = fixMasterCSSContent({
+				content: input.content,
+				filePath: input.filePath,
+				rules: state.rules,
+				lintSession: state.lintSession
+			});
+			if (fixed !== input.content) changes.push({
+				filePath: input.filePath,
+				beforeText: input.content,
+				afterText: fixed
+			});
+		}
+		const preview = await context.createPreview(changes, options.ttlMs);
+		return {
+			manifest: manifestMetadata(state.manifest),
+			mode: "lint-fixes",
+			preview,
+			lint: await lintProject(context, options)
+		};
+	} finally {
+		state.lintSession?.dispose();
 	}
-	return {
-		mode: "lint-fixes",
-		preview: await context.createPreview(changes, options.ttlMs),
-		lint: await lintProject(context, options)
-	};
 }
-//#endregion
 export { lintContent, lintProject, previewLintFixes };