@master/css-mcp 2.0.0-rc.77 → 2.0.0-rc.79

package/dist/directives.js

@@ -0,0 +1,158 @@
+import { createMCPTextDocument } from "./document.js";
+import { getErrorMessage } from "./result.js";
+import { summarizeManifest } from "./manifest-summary.js";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { collectCSSDirectiveRanges } from "@master/css-lexer";
+import { compileCSSManifest, compileCSSManifestFile } from "@master/css-compiler";
+//#region src/directives.ts
+const DIRECTIVE_INSPECTION_VERSION = 1;
+function createDirectiveEntries(content, filePath) {
+	const document = createMCPTextDocument(filePath, content);
+	return collectCSSDirectiveRanges(content).map((directive) => ({
+		name: directive.name,
+		range: {
+			start: directive.start,
+			end: directive.end
+		},
+		loc: {
+			start: document.positionAt(directive.start),
+			end: document.positionAt(directive.end)
+		},
+		prelude: content.slice(directive.preludeRange.start, directive.preludeRange.end).trim(),
+		hasBlock: Boolean(directive.blockRange),
+		quotedStrings: directive.quotedStringRanges.length
+	}));
+}
+function countObjectKeys(value) {
+	return value && typeof value === "object" ? Object.keys(value).length : 0;
+}
+function summarizeManifestInput(input) {
+	const manifestInput = input && typeof input === "object" ? input : {};
+	return {
+		keys: Object.keys(manifestInput),
+		counts: {
+			settings: countObjectKeys(manifestInput.settings),
+			variables: countObjectKeys(manifestInput.variables),
+			utilities: Array.isArray(manifestInput.utilities) ? manifestInput.utilities.length : countObjectKeys(manifestInput.utilities),
+			variants: Array.isArray(manifestInput.variants) ? manifestInput.variants.length : countObjectKeys(manifestInput.variants),
+			atRules: countObjectKeys(manifestInput.atRules),
+			selectors: countObjectKeys(manifestInput.selectors),
+			animations: countObjectKeys(manifestInput.animations)
+		}
+	};
+}
+function summarizeCompileResult(result) {
+	const styleDefinitions = result.directives.styleDefinitions ?? [];
+	return {
+		manifest: summarizeManifest(result.manifest),
+		directives: {
+			manifestInput: summarizeManifestInput(result.directives.manifestInput),
+			classNames: result.classNames,
+			nativeClassNames: result.nativeClassNames,
+			styleDefinitions: styleDefinitions.length,
+			extractionPolicy: result.extractionPolicy
+		},
+		css: {
+			bytes: result.css.length,
+			nativeBytes: result.nativeCSS.length,
+			generatedBytes: result.generatedCSS.length
+		},
+		dependencies: result.dependencies,
+		warnings: result.warnings
+	};
+}
+async function compileDirectives(context, options) {
+	if (options.entryPath) {
+		const filePath = await context.resolveExistingFile(options.entryPath);
+		const [content, result] = await Promise.all([readFile(filePath, "utf8"), Promise.resolve(compileCSSManifestFile(filePath, {
+			root: context.root,
+			preserveNativeCSS: options.preserveNativeCSS
+		}))]);
+		return {
+			filePath,
+			content,
+			result
+		};
+	}
+	if (options.content === void 0) throw new Error("Either entryPath or content is required.");
+	const filePath = context.resolveVirtualPath(options.filePath || "master.css");
+	const result = compileCSSManifest(options.content, {
+		root: context.root,
+		from: filePath,
+		preserveNativeCSS: options.preserveNativeCSS
+	});
+	return {
+		filePath,
+		content: options.content,
+		result
+	};
+}
+async function inspectDirectives(context, options) {
+	try {
+		const compiled = await compileDirectives(context, options);
+		const inspection = summarizeCompileResult(compiled.result);
+		const directiveEntries = createDirectiveEntries(compiled.content, compiled.filePath);
+		return {
+			version: DIRECTIVE_INSPECTION_VERSION,
+			root: context.root,
+			status: inspection.warnings.length ? "warning" : "ok",
+			input: {
+				filePath: compiled.filePath,
+				name: basename(compiled.filePath),
+				mode: options.entryPath ? "entry" : "content"
+			},
+			directiveEntries,
+			...inspection,
+			diagnostics: inspection.warnings.map((warning) => ({
+				code: "compiler-warning",
+				severity: "warning",
+				message: warning,
+				source: "Master CSS",
+				sourceKind: "directive",
+				filePath: compiled.filePath
+			})),
+			summary: {
+				status: inspection.warnings.length ? "warning" : "ok",
+				directives: directiveEntries.length,
+				classNames: inspection.directives.classNames.length,
+				nativeClassNames: inspection.directives.nativeClassNames.length,
+				dependencies: inspection.dependencies.length,
+				warnings: inspection.warnings.length,
+				cssBytes: inspection.css.bytes
+			}
+		};
+	} catch (error) {
+		const filePath = options.entryPath || options.filePath || "master.css";
+		return {
+			version: DIRECTIVE_INSPECTION_VERSION,
+			root: context.root,
+			status: "error",
+			input: {
+				filePath,
+				mode: options.entryPath ? "entry" : "content"
+			},
+			directiveEntries: options.content ? createDirectiveEntries(options.content, context.resolveVirtualPath(options.filePath || "master.css")) : [],
+			diagnostics: [{
+				code: "directive-inspection-error",
+				severity: "error",
+				message: getErrorMessage(error),
+				source: "Master CSS",
+				sourceKind: "directive",
+				filePath
+			}],
+			summary: {
+				status: "error",
+				directives: 0,
+				classNames: 0,
+				nativeClassNames: 0,
+				dependencies: 0,
+				warnings: 0,
+				errors: 1,
+				cssBytes: 0
+			}
+		};
+	}
+}
+//#endregion
+export { inspectDirectives };

package/dist/document.d.ts

@@ -0,0 +1,25 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+//#region src/document.d.ts
+interface Position {
+  line: number;
+  character: number;
+}
+interface Range {
+  start: Position;
+  end: Position;
+}
+interface TextEdit {
+  range: Range;
+  newText: string;
+}
+declare const languageByExtension: Record<string, string>;
+declare function getLanguageId(filePath: string): string;
+declare function createMCPTextDocument(filePath: string, content: string): TextDocument;
+declare function toOffsetRange(document: TextDocument, range?: Range): {
+  start: number;
+  end: number;
+} | undefined;
+declare function applyTextEdits(content: string, document: TextDocument, edits: TextEdit[]): string;
+//#endregion
+export { Position, Range, TextEdit, applyTextEdits, createMCPTextDocument, getLanguageId, languageByExtension, toOffsetRange };

package/dist/document.js

@@ -0,0 +1,51 @@
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { TextDocument } from "vscode-languageserver-textdocument";
+//#region src/document.ts
+const languageByExtension = {
+	".astro": "astro",
+	".css": "css",
+	".htm": "html",
+	".html": "html",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".less": "less",
+	".md": "markdown",
+	".mdx": "mdx",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".mts": "typescript",
+	".cts": "typescript",
+	".php": "php",
+	".pug": "pug",
+	".scss": "scss",
+	".svelte": "svelte",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".vue": "vue"
+};
+function getLanguageId(filePath) {
+	return languageByExtension[extname(filePath).toLowerCase()] || "html";
+}
+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) => ({
+		start: document.offsetAt(edit.range.start),
+		end: document.offsetAt(edit.range.end),
+		newText: edit.newText
+	}));
+	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 };

package/dist/format.d.ts

@@ -0,0 +1,57 @@
+import MasterCSSMCPContext from "./context.js";
+import { Range, TextEdit } from "./document.js";
+
+//#region src/format.d.ts
+interface PreviewDirectiveFormatOptions {
+  content?: string;
+  filePath?: string;
+  patterns?: string[];
+  range?: Range;
+  ttlMs?: number;
+}
+declare function previewDirectiveFormat(context: MasterCSSMCPContext, options?: PreviewDirectiveFormatOptions): Promise<{
+  version: number;
+  root: string;
+  mode: string;
+  files: {
+    filePath: string;
+    languageId: string;
+    edits: TextEdit[];
+    changed: boolean;
+    beforeBytes: number;
+    afterBytes: number;
+  }[];
+  formatted: string;
+  summary: {
+    files: number;
+    changed: number;
+    edits: number;
+  };
+  inputs?: undefined;
+  preview?: undefined;
+} | {
+  version: number;
+  root: string;
+  mode: string;
+  inputs: {
+    patterns: string[];
+    files: string[];
+  };
+  preview: import("./context.js").PreviewResult;
+  files: {
+    filePath: string;
+    languageId: string;
+    edits: TextEdit[];
+    changed: boolean;
+    beforeBytes: number;
+    afterBytes: number;
+  }[];
+  summary: {
+    files: number;
+    changed: number;
+    edits: number;
+  };
+  formatted?: undefined;
+}>;
+//#endregion
+export { PreviewDirectiveFormatOptions, previewDirectiveFormat };

package/dist/format.js

@@ -0,0 +1,81 @@
+import { applyTextEdits, createMCPTextDocument, getLanguageId } from "./document.js";
+import { resolveSourceFiles } from "./scan.js";
+import { readFile } from "node:fs/promises";
+import CSSLanguageService from "@master/css-language-service";
+//#region 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) {
+	const document = createMCPTextDocument(filePath, content);
+	const edits = service.formatDirectives(document, range) ?? [];
+	const formatted = applyTextEdits(content, document, edits);
+	return {
+		filePath,
+		languageId: getLanguageId(filePath),
+		edits,
+		changed: formatted !== content,
+		beforeBytes: content.length,
+		afterBytes: formatted.length,
+		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);
+		return {
+			version: DIRECTIVE_FORMAT_PREVIEW_VERSION,
+			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) => {
+		return formatContent(service, filePath, await readFile(filePath, "utf8"), 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,3 @@
-import { MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer } from "./server.js";
 import MasterCSSMCPContext, { MasterCSSMCPContextOptions } from "./context.js";
+import { MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer } from "./server.js";
 export { MasterCSSMCPContext, type MasterCSSMCPContextOptions, type MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer };

package/dist/language.js

@@ -1,30 +1,12 @@
+import { createMCPTextDocument } from "./document.js";
 import { loadWorkspaceManifest } from "./project.js";
-import { extname } from "node:path";
-import { pathToFileURL } from "node:url";
 import CSSLanguageService from "@master/css-language-service";
-import { TextDocument } from "vscode-languageserver-textdocument";
 //#region src/language.ts
-const languageByExtension = {
-	".astro": "astro",
-	".css": "css",
-	".htm": "html",
-	".html": "html",
-	".js": "javascript",
-	".jsx": "javascriptreact",
-	".less": "less",
-	".md": "markdown",
-	".mdx": "mdx",
-	".scss": "scss",
-	".svelte": "svelte",
-	".ts": "typescript",
-	".tsx": "typescriptreact",
-	".vue": "vue"
-};
 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 = TextDocument.create(pathToFileURL(filePath).href, languageByExtension[extname(filePath).toLowerCase()] || "html", 0, options.content);
+	const document = createMCPTextDocument(filePath, options.content);
 	const completions = service.suggestSyntax(document, options.position, {
 		triggerKind: options.triggerCharacter ? 2 : 1,
 		...options.triggerCharacter ? { triggerCharacter: options.triggerCharacter } : {}

package/dist/manifest-query.d.ts

@@ -0,0 +1,149 @@
+import MasterCSSMCPContext from "./context.js";
+
+//#region src/manifest-query.d.ts
+type ManifestQueryKind = 'all' | 'token' | 'utility' | 'variant' | 'mode' | 'at-rule' | 'alias';
+interface ManifestQueryOptions {
+  query?: string;
+  kind?: ManifestQueryKind;
+  namespace?: string;
+  limit?: number;
+}
+declare function queryManifest(context: MasterCSSMCPContext, options?: ManifestQueryOptions): Promise<{
+  version: number;
+  root: string;
+  manifest: {
+    status: "error";
+    entries: string[];
+    error: string;
+    summary?: undefined;
+  };
+  inputs: {
+    query: string | undefined;
+    kind: ManifestQueryKind;
+    namespace: string | undefined;
+    limit: number;
+  };
+  results: {
+    tokens: never[];
+    utilities: never[];
+    variants: never[];
+    modes: never[];
+    atRules: never[];
+    aliases: never[];
+  };
+  diagnostics: {
+    code: string;
+    severity: "error";
+    message: string;
+    source: string;
+    sourceKind: string;
+  }[];
+  summary: {
+    total: number;
+    returned: number;
+    status: string;
+    tokens?: undefined;
+    utilities?: undefined;
+    variants?: undefined;
+    modes?: undefined;
+    atRules?: undefined;
+    aliases?: undefined;
+  };
+} | {
+  version: number;
+  root: string;
+  manifest: {
+    status: "loaded";
+    entries: string[];
+    summary: {
+      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;
+      };
+    };
+    error?: undefined;
+  };
+  inputs: {
+    query: string | undefined;
+    kind: ManifestQueryKind;
+    namespace: string | undefined;
+    limit: number;
+  };
+  results: {
+    tokens: {
+      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;
+    }[];
+    utilities: {
+      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;
+    }[];
+    variants: {
+      token: import("@master/css-engine").MasterCSSManifestVariantToken;
+      branches: number;
+      layers: (import("@master/css-engine").MasterCSSManifestUtilityLayerName | undefined)[];
+    }[];
+    modes: {
+      name: string;
+      default: boolean;
+      trigger: import("@master/css-engine").MasterCSSManifestModeTrigger | undefined;
+    }[];
+    atRules: {
+      name: string;
+      id: import("@master/css-engine").MasterCSSManifestAtIdentifier;
+      nodes: number;
+    }[];
+    aliases: ({
+      utility: string;
+      key: string;
+      name: string;
+      type: "variable-alias";
+    } | {
+      utility: string;
+      ref: string;
+      type: "variable-alias-ref";
+    } | {
+      utility: string;
+      group: string;
+      type: "alias-group";
+    })[];
+  };
+  summary: {
+    total: number;
+    returned: number;
+    tokens: number;
+    utilities: number;
+    variants: number;
+    modes: number;
+    atRules: number;
+    aliases: number;
+    status: string;
+  };
+  diagnostics?: undefined;
+}>;
+//#endregion
+export { ManifestQueryKind, ManifestQueryOptions, queryManifest };