@vizejs/musea-mcp-server 0.429.0 → 0.429.2

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as startServer } from "./src-BB93rq2Q.mjs";
+import { n as startServer } from "./src-BlrFYjvC.mjs";
 //#region src/cli.ts
 /**
 * Musea MCP Server CLI.

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as startServer, t as createMuseaServer } from "./src-BB93rq2Q.mjs";
+import { n as startServer, t as createMuseaServer } from "./src-BlrFYjvC.mjs";
 export { createMuseaServer, createMuseaServer as default, startServer };

package/dist/{src-BB93rq2Q.mjs → src-BlrFYjvC.mjs}

@@ -1433,15 +1433,176 @@ async function handleRecommendComponents(ctx, args) {
 	}] };
 }
 //#endregion
+//#region src/css-tokens.ts
+const CSS_EXTENSIONS = new Set([
+	".css",
+	".pcss",
+	".postcss"
+]);
+const VARIABLE_DECLARATION_RE = /(--[A-Za-z0-9_-]+)\s*:\s*([^;{}]+);/g;
+const CSS_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const VARIABLE_REFERENCE_RE = /^var\(\s*(--[A-Za-z0-9_-]+)\s*(?:,[^)]+)?\)$/;
+const NAMESPACE_MAPPINGS = [
+	{
+		prefix: "color",
+		category: "color",
+		type: "color"
+	},
+	{
+		prefix: "spacing",
+		category: "spacing",
+		type: "dimension"
+	},
+	{
+		prefix: "font-weight",
+		category: "typography",
+		pathPrefix: ["fontWeight"],
+		type: "fontWeight"
+	},
+	{
+		prefix: "font",
+		category: "typography",
+		pathPrefix: ["font"],
+		type: "fontFamily"
+	},
+	{
+		prefix: "text",
+		category: "typography",
+		pathPrefix: ["fontSize"],
+		type: "dimension"
+	},
+	{
+		prefix: "radius",
+		category: "radius",
+		type: "dimension"
+	},
+	{
+		prefix: "shadow",
+		category: "shadow",
+		type: "shadow"
+	}
+];
+async function isCssTokenPath(tokensPath) {
+	const stat = await fs.promises.stat(tokensPath).catch(() => null);
+	if (!stat) return false;
+	if (stat.isFile()) return CSS_EXTENSIONS.has(path.extname(tokensPath).toLowerCase());
+	if (!stat.isDirectory()) return false;
+	return (await fs.promises.readdir(tokensPath, { withFileTypes: true })).some((entry) => entry.isFile() && CSS_EXTENSIONS.has(path.extname(entry.name).toLowerCase()));
+}
+async function parseCssTokenFiles(tokensPath) {
+	const files = (await fs.promises.stat(tokensPath)).isDirectory() ? (await fs.promises.readdir(tokensPath)).filter((name) => CSS_EXTENSIONS.has(path.extname(name).toLowerCase())).sort().map((name) => path.join(tokensPath, name)) : [tokensPath];
+	return parseCssTokenSource((await Promise.all(files.map((file) => fs.promises.readFile(file, "utf8")))).join("\n"));
+}
+function parseCssTokenSource(css) {
+	const source = css.replace(CSS_COMMENT_RE, "");
+	const declarations = [];
+	let match;
+	VARIABLE_DECLARATION_RE.lastIndex = 0;
+	while ((match = VARIABLE_DECLARATION_RE.exec(source)) !== null) {
+		const value = match[2]?.trim();
+		if (match[1] && value) declarations.push({
+			variable: match[1],
+			value
+		});
+	}
+	const paths = /* @__PURE__ */ new Map();
+	const mapped = declarations.map((declaration) => {
+		const token = mapDeclaration(declaration.variable, declaration.value);
+		paths.set(declaration.variable, [token.category, ...token.path].join("."));
+		return {
+			...declaration,
+			...token
+		};
+	});
+	const categories = /* @__PURE__ */ new Map();
+	for (const declaration of mapped) {
+		const category = categories.get(declaration.category) ?? {
+			name: declaration.category,
+			tokens: Object.create(null)
+		};
+		categories.set(declaration.category, category);
+		const referenceVariable = declaration.value.match(VARIABLE_REFERENCE_RE)?.[1];
+		const reference = referenceVariable ? paths.get(referenceVariable) : void 0;
+		const token = {
+			value: reference ? `{${reference}}` : declaration.value,
+			type: declaration.type,
+			description: declaration.description,
+			$tier: reference ? "semantic" : "primitive",
+			...reference ? { $reference: reference } : {}
+		};
+		setToken(category, declaration.path, token);
+	}
+	return [...categories.values()];
+}
+function mapDeclaration(variable, value) {
+	const name = variable.slice(2);
+	const mapping = NAMESPACE_MAPPINGS.find((candidate) => name === candidate.prefix || name.startsWith(`${candidate.prefix}-`));
+	if (mapping) {
+		const rest = name === mapping.prefix ? "DEFAULT" : name.slice(mapping.prefix.length + 1);
+		const pathParts = [...mapping.pathPrefix ?? [], rest].filter(Boolean);
+		return {
+			category: mapping.category,
+			path: pathParts.length > 0 ? pathParts : ["DEFAULT"],
+			type: mapping.type,
+			description: `Tailwind theme variable ${variable}`
+		};
+	}
+	const segments = name.split("-").filter(Boolean);
+	const category = segments[0] ?? "token";
+	const rest = segments.slice(1).join("-");
+	return {
+		category,
+		path: rest ? [rest] : ["DEFAULT"],
+		type: inferType(value),
+		description: `Custom property ${variable}`
+	};
+}
+function inferType(value) {
+	if (/^(?:#|rgba?\(|hsla?\(|oklch\(|oklab\(|color-mix\(|color\()/i.test(value)) return "color";
+	if (/^-?(?:\d+\.\d+|\d+)(?:px|rem|em|vh|vw|vmin|vmax|%)$/i.test(value)) return "dimension";
+	if (/^-?(?:\d+\.\d+|\d+)$/.test(value)) return "number";
+	return "other";
+}
+function setToken(category, pathParts, token) {
+	if (pathParts.length === 1) {
+		category.tokens[pathParts[0]] = token;
+		return;
+	}
+	let current = category;
+	for (const part of pathParts.slice(0, -1)) {
+		current.subcategories ??= [];
+		let next = current.subcategories.find((subcategory) => subcategory.name === part);
+		if (!next) {
+			next = {
+				name: part,
+				tokens: Object.create(null)
+			};
+			current.subcategories.push(next);
+		}
+		current = next;
+	}
+	current.tokens[pathParts[pathParts.length - 1]] = token;
+}
+//#endregion
 //#region src/tokens.ts
 async function parseTokensFromPath(tokensPath) {
-	return normalizeCategories(loadNative().parseDesignTokensFromPath(tokensPath));
+	if (await isCssTokenPath(tokensPath)) return normalizeCategories(await parseCssTokenFiles(tokensPath));
+	return categoriesFromNativeResult(loadNative().parseDesignTokensFromPath(tokensPath));
+}
+function categoriesFromNativeResult(value) {
+	const parsed = parseJsonResult(value);
+	if (!Array.isArray(parsed)) throw new TypeError("Design token parser did not return a category array");
+	return normalizeCategories(parsed);
 }
 function generateTokensMarkdown(categories) {
-	return loadNative().generateDesignTokensMarkdown(categories);
+	return String(loadNative().generateDesignTokensMarkdown(JSON.stringify(categories)));
 }
 function flattenTokenCategories(categories) {
-	return loadNative().flattenDesignTokenCategories(categories);
+	return parseJsonResult(loadNative().flattenDesignTokenCategories(JSON.stringify(categories)));
+}
+function parseJsonResult(value) {
+	if (typeof value === "string") return JSON.parse(value);
+	return value;
 }
 function normalizeCategories(categories) {
 	for (const category of categories) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/musea-mcp-server",
-  "version": "0.429.0",
+  "version": "0.429.2",
   "description": "MCP server for building Vue.js design systems - component analysis, documentation, variant generation, and design tokens",
   "keywords": [
     "ai",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@vizejs/native": "0.429.0",
+    "@vizejs/native": "0.429.2",
     "@vue/compiler-dom": "3.5.35",
     "typescript": "6.0.3"
   },