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

package/dist/semantic-schema.js

@@ -0,0 +1,286 @@
+import * as z from "zod/v4";
+// src/semantic-schema.ts
+const strings = z.array(z.string());
+const range = z.object({
+	start: z.number(),
+	end: z.number()
+});
+const position = z.object({
+	line: z.number(),
+	character: z.number()
+});
+const diagnostic = z.object({
+	code: z.string().optional(),
+	phase: z.string().optional(),
+	severity: z.union([z.string(), z.number()]).optional(),
+	message: z.string(),
+	notes: strings.optional(),
+	alternatives: strings.optional(),
+	source: z.string().optional(),
+	range: z.union([range, z.object({
+		start: position,
+		end: position
+	})]).optional()
+}).passthrough();
+const matchStatus = z.enum([
+	"matched",
+	"unmatched",
+	"ambiguous",
+	"syntax-error"
+]);
+const cssStatus = z.enum([
+	"valid",
+	"invalid",
+	"unknown",
+	"not-checked"
+]);
+const browserSupport = z.enum([
+	"supported",
+	"unsupported",
+	"unknown",
+	"not-checked"
+]);
+const numeric = z.object({
+	value: z.number(),
+	unit: z.string().optional()
+});
+const variable = z.object({
+	key: z.string(),
+	name: z.string(),
+	namespace: z.string().optional(),
+	type: z.string(),
+	values: z.array(z.object({
+		path: strings,
+		value: z.string(),
+		inline: z.boolean().optional(),
+		static: z.boolean().optional()
+	})),
+	numeric: numeric.optional(),
+	dependencies: strings
+});
+const bound = z.object({
+	value: z.number(),
+	inclusive: z.boolean()
+}).nullable();
+const rule = z.object({
+	className: z.string(),
+	key: z.string(),
+	layer: z.enum([
+		"base",
+		"defaults",
+		"components",
+		"utilities"
+	]),
+	type: z.number(),
+	sortTier: z.number(),
+	text: z.string().optional(),
+	selectorText: z.string().optional(),
+	priority: z.object({
+		features: z.array(z.object({
+			domain: z.string(),
+			feature: z.string(),
+			unit: z.string(),
+			lower: bound,
+			upper: bound
+		})),
+		selector: z.number(),
+		conditions: strings.optional(),
+		sortKey: z.string().optional(),
+		valuePriority: z.number().optional(),
+		category: z.number(),
+		family: z.string().optional(),
+		coverage: z.number().optional(),
+		property: z.string().optional()
+	}),
+	nodes: z.array(z.object({ text: z.string() })).optional(),
+	variableNames: strings.optional()
+});
+const inspection = z.object({
+	className: z.string(),
+	matchStatus,
+	cssSyntaxStatus: cssStatus,
+	cssValueStatus: cssStatus,
+	browserSupport,
+	checks: z.array(z.object({
+		name: z.string(),
+		version: z.string(),
+		phase: z.string(),
+		scope: z.string()
+	})),
+	declarations: z.array(z.object({
+		property: z.string(),
+		value: z.string(),
+		status: cssStatus,
+		range: range.optional(),
+		error: z.string().optional()
+	}).passthrough()),
+	rules: z.array(rule),
+	variables: z.array(z.object({
+		key: z.string(),
+		variable
+	})),
+	diagnostics: z.array(diagnostic).optional()
+}).passthrough();
+const versions = z.object({
+	languageVersion: z.number(),
+	bindingAbiVersion: z.number(),
+	packageVersion: z.string()
+}).passthrough();
+const metadata = z.object({
+	context: z.enum(["project", "preset"]),
+	status: z.enum(["loaded", "error"]),
+	fingerprint: z.string().nullable(),
+	entries: strings,
+	dependencies: strings,
+	versions: versions.optional()
+}).passthrough();
+const envelopeMetadata = z.object({
+	versions: versions.nullable(),
+	context: z.enum(["project", "preset"]).nullable(),
+	manifestFingerprint: z.string().nullable(),
+	entries: strings,
+	dependencies: strings
+});
+const mixinSource = z.object({
+	file: z.string().optional(),
+	range,
+	loc: z.object({
+		start: z.object({
+			line: z.number(),
+			column: z.number()
+		}),
+		end: z.object({
+			line: z.number(),
+			column: z.number()
+		})
+	}).optional()
+}).optional();
+const mixinValue = z.lazy(() => z.array(z.discriminatedUnion("type", [z.object({
+	type: z.literal("text"),
+	value: z.string()
+}), z.object({
+	type: z.literal("function"),
+	name: z.string(),
+	value: mixinValue
+})])));
+const mixinNode = z.lazy(() => z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("declaration"),
+		property: z.string(),
+		value: mixinValue,
+		source: mixinSource
+	}),
+	z.object({
+		type: z.literal("rule"),
+		selector: z.string(),
+		body: z.array(mixinNode)
+	}),
+	z.object({
+		type: z.literal("condition"),
+		condition: z.string(),
+		body: z.array(mixinNode)
+	}),
+	z.object({
+		type: z.literal("apply"),
+		name: z.string(),
+		arguments: z.array(mixinValue),
+		contents: z.array(mixinNode).optional(),
+		source: mixinSource
+	}),
+	z.object({
+		type: z.literal("contents"),
+		fallback: z.array(mixinNode)
+	})
+]));
+const mixin = z.object({
+	name: z.string(),
+	parameters: z.array(z.object({
+		name: z.string(),
+		syntax: z.enum([
+			"integer",
+			"number",
+			"string",
+			"custom-ident"
+		]).optional(),
+		default: z.string().optional(),
+		source: mixinSource
+	})),
+	body: z.array(mixinNode),
+	source: mixinSource
+});
+const mediaQuery = z.lazy(() => z.union([
+	z.object({ type: z.enum(["true", "false"]) }),
+	z.object({
+		type: z.literal("feature"),
+		value: z.string()
+	}),
+	z.object({
+		type: z.literal("media-type"),
+		name: z.string()
+	}),
+	z.object({
+		type: z.literal("not"),
+		query: mediaQuery
+	}),
+	z.object({
+		type: z.enum(["and", "or"]),
+		queries: z.array(mediaQuery)
+	})
+]));
+const manifestResults = z.object({
+	tokens: z.array(variable),
+	mixins: z.array(mixin),
+	utilities: z.array(mixin.extend({ kind: z.enum([
+		"static",
+		"token",
+		"function"
+	]) })),
+	customMedia: z.array(z.object({
+		name: z.string(),
+		expression: mediaQuery
+	})),
+	customContainers: z.array(z.object({
+		name: z.string(),
+		condition: z.string()
+	})),
+	families: z.array(z.object({
+		type: z.literal("token-family"),
+		utility: z.string(),
+		prefix: z.string(),
+		namespace: z.string(),
+		argument: z.enum(["value", "key"]),
+		properties: strings
+	}))
+});
+const change = z.object({
+	filePath: z.string(),
+	beforeHash: z.string().nullable(),
+	afterHash: z.string(),
+	beforeExists: z.boolean(),
+	beforeBytes: z.number(),
+	afterBytes: z.number(),
+	afterText: z.string(),
+	diff: z.string()
+});
+const completion = z.object({
+	label: z.string(),
+	kind: z.number().optional(),
+	detail: z.string().optional(),
+	insertText: z.string().optional(),
+	sortText: z.string().optional(),
+	documentation: z.union([z.string(), z.object({
+		kind: z.string(),
+		value: z.string()
+	})]).optional()
+}).passthrough();
+const classDiff = z.object({
+	added: strings,
+	removed: strings,
+	unchanged: strings
+});
+const ruleDiff = z.object({
+	added: strings,
+	removed: strings,
+	unchanged: z.number()
+});
+export { browserSupport, change, classDiff, completion, cssStatus, diagnostic, envelopeMetadata, inspection, manifestResults, matchStatus, metadata, mixin, range, rule, ruleDiff, strings, variable, versions };

package/dist/server.d.ts

@@ -1,11 +1,12 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import MasterCSSMCPContext, { MasterCSSMCPContextOptions } from "./context.js";
-//#region src/server.d.ts
-interface MasterCSSMCPServerInstance {
-  server: McpServer;
-  context: MasterCSSMCPContext;
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+declare class MasterCSSMCPServer {
+  #private;
+  constructor(server: McpServer, context: MasterCSSMCPContext);
+  connect(transport: Parameters<McpServer['connect']>[0]): Promise<void>;
+  dispose(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
 }
-declare function createMasterCSSMCPServer(options?: MasterCSSMCPContextOptions): MasterCSSMCPServerInstance;
-declare function startStdioServer(options?: MasterCSSMCPContextOptions): Promise<McpServer>;
-//#endregion
-export { MasterCSSMCPServerInstance, createMasterCSSMCPServer, startStdioServer };
+declare function createMasterCSSMCPServer(options?: MasterCSSMCPContextOptions): MasterCSSMCPServer;
+declare function startMasterCSSMCPStdioServer(options?: MasterCSSMCPContextOptions): Promise<MasterCSSMCPServer>;
+export { createMasterCSSMCPServer, startMasterCSSMCPStdioServer };