@vizejs/musea-mcp-server 0.12.0 → 0.14.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { startServer } from "./src-DNZL-15O.js";
+import { startServer } from "./src-BY8aIu75.js";
 
 //#region src/cli.ts
 let projectRoot = process.env.MUSEA_PROJECT_ROOT || process.cwd();

package/dist/index.js

@@ -1,3 +1,3 @@
-import { createMuseaServer, src_default, startServer } from "./src-DNZL-15O.js";
+import { createMuseaServer, src_default, startServer } from "./src-BY8aIu75.js";
 
 export { createMuseaServer, src_default as default, startServer };

package/dist/{src-DNZL-15O.js → src-BY8aIu75.js}

@@ -244,6 +244,135 @@ const toolDefinitions = [
 	}
 ];
 
+//#endregion
+//#region src/tools/handler/analysis.ts
+async function handleAnalyzeComponent(ctx, binding, args) {
+	const vuePath = args?.path;
+	if (!vuePath) throw new McpError(ErrorCode.InvalidParams, "path is required");
+	if (!binding.analyzeSfc) throw new McpError(ErrorCode.InternalError, "analyzeSfc not available in native binding");
+	const absolutePath = path.resolve(ctx.projectRoot, vuePath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const analysis = binding.analyzeSfc(source, { filename: absolutePath });
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			props: analysis.props.map((p) => ({
+				name: p.name,
+				type: p.type,
+				required: p.required,
+				defaultValue: p.default_value
+			})),
+			emits: analysis.emits
+		}, null, 2)
+	}] };
+}
+async function handleGetPalette(ctx, binding, args) {
+	const artPath = args?.path;
+	if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
+	if (!binding.generateArtPalette) throw new McpError(ErrorCode.InternalError, "generateArtPalette not available in native binding");
+	const absolutePath = path.resolve(ctx.projectRoot, artPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const palette = binding.generateArtPalette(source, { filename: absolutePath });
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			title: palette.title,
+			controls: palette.controls.map((c) => ({
+				name: c.name,
+				control: c.control,
+				defaultValue: c.default_value,
+				description: c.description,
+				required: c.required,
+				options: c.options,
+				range: c.range,
+				group: c.group
+			})),
+			groups: palette.groups,
+			json: palette.json,
+			typescript: palette.typescript
+		}, null, 2)
+	}] };
+}
+
+//#endregion
+//#region src/tools/handler/registry.ts
+async function handleListComponents(ctx, args) {
+	const arts = await ctx.scanArtFiles();
+	let results = Array.from(arts.values());
+	if (args?.category) results = results.filter((a) => a.category?.toLowerCase() === args.category.toLowerCase());
+	if (args?.tag) results = results.filter((a) => a.tags.some((t) => t.toLowerCase() === args.tag.toLowerCase()));
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(results.map((r) => ({
+			path: path.relative(ctx.projectRoot, r.path),
+			title: r.title,
+			description: r.description,
+			component: r.component,
+			category: r.category,
+			tags: r.tags,
+			variantCount: r.variantCount
+		})), null, 2)
+	}] };
+}
+async function handleGetComponent(ctx, binding, args) {
+	const artPath = args?.path;
+	if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
+	const absolutePath = path.resolve(ctx.projectRoot, artPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const parsed = binding.parseArt(source, { filename: absolutePath });
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			metadata: parsed.metadata,
+			variants: parsed.variants.map((v) => ({
+				name: v.name,
+				template: v.template,
+				isDefault: v.is_default,
+				skipVrt: v.skip_vrt
+			})),
+			hasScriptSetup: parsed.has_script_setup,
+			hasScript: parsed.has_script,
+			styleCount: parsed.style_count
+		}, null, 2)
+	}] };
+}
+async function handleGetVariant(ctx, binding, args) {
+	const artPath = args?.path;
+	const variantName = args?.variant;
+	if (!artPath || !variantName) throw new McpError(ErrorCode.InvalidParams, "path and variant are required");
+	const absolutePath = path.resolve(ctx.projectRoot, artPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const parsed = binding.parseArt(source, { filename: absolutePath });
+	const variant = parsed.variants.find((v) => v.name.toLowerCase() === variantName.toLowerCase());
+	if (!variant) throw new McpError(ErrorCode.InvalidParams, `Variant "${variantName}" not found`);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			name: variant.name,
+			template: variant.template,
+			isDefault: variant.is_default,
+			skipVrt: variant.skip_vrt
+		}, null, 2)
+	}] };
+}
+async function handleSearchComponents(ctx, args) {
+	const query = (args?.query)?.toLowerCase();
+	if (!query) throw new McpError(ErrorCode.InvalidParams, "query is required");
+	const arts = await ctx.scanArtFiles();
+	const results = Array.from(arts.values()).filter((a) => a.title.toLowerCase().includes(query) || a.description?.toLowerCase().includes(query) || a.tags.some((t) => t.toLowerCase().includes(query)));
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(results.map((r) => ({
+			path: path.relative(ctx.projectRoot, r.path),
+			title: r.title,
+			description: r.description,
+			component: r.component,
+			category: r.category,
+			tags: r.tags
+		})), null, 2)
+	}] };
+}
+
 //#endregion
 //#region src/tokens.ts
 async function parseTokensFromPath(tokensPath) {
@@ -336,240 +465,131 @@ function formatCategoryName(name) {
 }
 
 //#endregion
-//#region src/tools/handler.ts
+//#region src/tools/handler/generation.ts
+async function handleGenerateVariants(ctx, binding, args) {
+	const componentRelPath = args?.componentPath;
+	if (!componentRelPath) throw new McpError(ErrorCode.InvalidParams, "componentPath is required");
+	if (!binding.analyzeSfc) throw new McpError(ErrorCode.InternalError, "analyzeSfc not available in native binding");
+	if (!binding.generateVariants) throw new McpError(ErrorCode.InternalError, "generateVariants not available in native binding");
+	const absolutePath = path.resolve(ctx.projectRoot, componentRelPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const analysis = binding.analyzeSfc(source, { filename: absolutePath });
+	const props = analysis.props.map((p) => ({
+		name: p.name,
+		prop_type: p.type,
+		required: p.required,
+		default_value: p.default_value
+	}));
+	const relPath = `./${path.basename(absolutePath)}`;
+	const result = binding.generateVariants(relPath, props, {
+		max_variants: args?.maxVariants,
+		include_default: args?.includeDefault,
+		include_boolean_toggles: args?.includeBooleanToggles,
+		include_enum_variants: args?.includeEnumVariants
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			componentName: result.component_name,
+			artFileContent: result.art_file_content,
+			variants: result.variants.map((v) => ({
+				name: v.name,
+				isDefault: v.is_default,
+				props: v.props,
+				description: v.description
+			}))
+		}, null, 2)
+	}] };
+}
+async function handleGenerateCsf(ctx, binding, args) {
+	const artPath = args?.path;
+	if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
+	const absolutePath = path.resolve(ctx.projectRoot, artPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const csf = binding.artToCsf(source, { filename: absolutePath });
+	return { content: [{
+		type: "text",
+		text: csf.code
+	}] };
+}
+async function handleGenerateDocs(ctx, binding, args) {
+	const artPath = args?.path;
+	if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
+	if (!binding.generateArtDoc) throw new McpError(ErrorCode.InternalError, "generateArtDoc not available in native binding");
+	const absolutePath = path.resolve(ctx.projectRoot, artPath);
+	const source = await fs.promises.readFile(absolutePath, "utf-8");
+	const doc = binding.generateArtDoc(source, { filename: absolutePath }, {
+		include_source: args?.includeSource,
+		include_templates: args?.includeTemplates,
+		include_metadata: true
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			markdown: doc.markdown,
+			title: doc.title,
+			category: doc.category,
+			variantCount: doc.variant_count
+		}, null, 2)
+	}] };
+}
+async function handleGenerateCatalog(ctx, binding, args) {
+	if (!binding.generateArtCatalog) throw new McpError(ErrorCode.InternalError, "generateArtCatalog not available in native binding");
+	const arts = await ctx.scanArtFiles();
+	const sources = [];
+	for (const [filePath] of arts) {
+		const source = await fs.promises.readFile(filePath, "utf-8");
+		sources.push(source);
+	}
+	const catalog = binding.generateArtCatalog(sources, {
+		include_source: args?.includeSource,
+		include_templates: args?.includeTemplates,
+		include_metadata: true
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			markdown: catalog.markdown,
+			componentCount: catalog.component_count,
+			categories: catalog.categories,
+			tags: catalog.tags
+		}, null, 2)
+	}] };
+}
+async function handleGetTokens(ctx, args) {
+	const inputPath = args?.tokensPath;
+	const format = args?.format ?? "json";
+	let resolvedPath;
+	if (inputPath) resolvedPath = path.resolve(ctx.projectRoot, inputPath);
+	else resolvedPath = await ctx.resolveTokensPath();
+	if (!resolvedPath) throw new McpError(ErrorCode.InvalidParams, "No tokens path provided and none auto-detected. Looked for: tokens/, design-tokens/, style-dictionary/ directories.");
+	const categories = await parseTokensFromPath(resolvedPath);
+	if (format === "markdown") return { content: [{
+		type: "text",
+		text: generateTokensMarkdown(categories)
+	}] };
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ categories }, null, 2)
+	}] };
+}
+
+//#endregion
+//#region src/tools/handler/index.ts
 async function handleToolCall(ctx, name, args) {
 	const binding = ctx.loadNative();
 	switch (name) {
-		case "analyze_component": {
-			const vuePath = args?.path;
-			if (!vuePath) throw new McpError(ErrorCode.InvalidParams, "path is required");
-			if (!binding.analyzeSfc) throw new McpError(ErrorCode.InternalError, "analyzeSfc not available in native binding");
-			const absolutePath = path.resolve(ctx.projectRoot, vuePath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const analysis = binding.analyzeSfc(source, { filename: absolutePath });
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					props: analysis.props.map((p) => ({
-						name: p.name,
-						type: p.type,
-						required: p.required,
-						defaultValue: p.default_value
-					})),
-					emits: analysis.emits
-				}, null, 2)
-			}] };
-		}
-		case "get_palette": {
-			const artPath = args?.path;
-			if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
-			if (!binding.generateArtPalette) throw new McpError(ErrorCode.InternalError, "generateArtPalette not available in native binding");
-			const absolutePath = path.resolve(ctx.projectRoot, artPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const palette = binding.generateArtPalette(source, { filename: absolutePath });
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					title: palette.title,
-					controls: palette.controls.map((c) => ({
-						name: c.name,
-						control: c.control,
-						defaultValue: c.default_value,
-						description: c.description,
-						required: c.required,
-						options: c.options,
-						range: c.range,
-						group: c.group
-					})),
-					groups: palette.groups,
-					json: palette.json,
-					typescript: palette.typescript
-				}, null, 2)
-			}] };
-		}
-		case "list_components": {
-			const arts = await ctx.scanArtFiles();
-			let results = Array.from(arts.values());
-			if (args?.category) results = results.filter((a) => a.category?.toLowerCase() === args.category.toLowerCase());
-			if (args?.tag) results = results.filter((a) => a.tags.some((t) => t.toLowerCase() === args.tag.toLowerCase()));
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(results.map((r) => ({
-					path: path.relative(ctx.projectRoot, r.path),
-					title: r.title,
-					description: r.description,
-					component: r.component,
-					category: r.category,
-					tags: r.tags,
-					variantCount: r.variantCount
-				})), null, 2)
-			}] };
-		}
-		case "get_component": {
-			const artPath = args?.path;
-			if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
-			const absolutePath = path.resolve(ctx.projectRoot, artPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const parsed = binding.parseArt(source, { filename: absolutePath });
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					metadata: parsed.metadata,
-					variants: parsed.variants.map((v) => ({
-						name: v.name,
-						template: v.template,
-						isDefault: v.is_default,
-						skipVrt: v.skip_vrt
-					})),
-					hasScriptSetup: parsed.has_script_setup,
-					hasScript: parsed.has_script,
-					styleCount: parsed.style_count
-				}, null, 2)
-			}] };
-		}
-		case "get_variant": {
-			const artPath = args?.path;
-			const variantName = args?.variant;
-			if (!artPath || !variantName) throw new McpError(ErrorCode.InvalidParams, "path and variant are required");
-			const absolutePath = path.resolve(ctx.projectRoot, artPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const parsed = binding.parseArt(source, { filename: absolutePath });
-			const variant = parsed.variants.find((v) => v.name.toLowerCase() === variantName.toLowerCase());
-			if (!variant) throw new McpError(ErrorCode.InvalidParams, `Variant "${variantName}" not found`);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					name: variant.name,
-					template: variant.template,
-					isDefault: variant.is_default,
-					skipVrt: variant.skip_vrt
-				}, null, 2)
-			}] };
-		}
-		case "search_components": {
-			const query = (args?.query)?.toLowerCase();
-			if (!query) throw new McpError(ErrorCode.InvalidParams, "query is required");
-			const arts = await ctx.scanArtFiles();
-			const results = Array.from(arts.values()).filter((a) => a.title.toLowerCase().includes(query) || a.description?.toLowerCase().includes(query) || a.tags.some((t) => t.toLowerCase().includes(query)));
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(results.map((r) => ({
-					path: path.relative(ctx.projectRoot, r.path),
-					title: r.title,
-					description: r.description,
-					component: r.component,
-					category: r.category,
-					tags: r.tags
-				})), null, 2)
-			}] };
-		}
-		case "generate_variants": {
-			const componentRelPath = args?.componentPath;
-			if (!componentRelPath) throw new McpError(ErrorCode.InvalidParams, "componentPath is required");
-			if (!binding.analyzeSfc) throw new McpError(ErrorCode.InternalError, "analyzeSfc not available in native binding");
-			if (!binding.generateVariants) throw new McpError(ErrorCode.InternalError, "generateVariants not available in native binding");
-			const absolutePath = path.resolve(ctx.projectRoot, componentRelPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const analysis = binding.analyzeSfc(source, { filename: absolutePath });
-			const props = analysis.props.map((p) => ({
-				name: p.name,
-				prop_type: p.type,
-				required: p.required,
-				default_value: p.default_value
-			}));
-			const relPath = `./${path.basename(absolutePath)}`;
-			const result = binding.generateVariants(relPath, props, {
-				max_variants: args?.maxVariants,
-				include_default: args?.includeDefault,
-				include_boolean_toggles: args?.includeBooleanToggles,
-				include_enum_variants: args?.includeEnumVariants
-			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					componentName: result.component_name,
-					artFileContent: result.art_file_content,
-					variants: result.variants.map((v) => ({
-						name: v.name,
-						isDefault: v.is_default,
-						props: v.props,
-						description: v.description
-					}))
-				}, null, 2)
-			}] };
-		}
-		case "generate_csf": {
-			const artPath = args?.path;
-			if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
-			const absolutePath = path.resolve(ctx.projectRoot, artPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const csf = binding.artToCsf(source, { filename: absolutePath });
-			return { content: [{
-				type: "text",
-				text: csf.code
-			}] };
-		}
-		case "generate_docs": {
-			const artPath = args?.path;
-			if (!artPath) throw new McpError(ErrorCode.InvalidParams, "path is required");
-			if (!binding.generateArtDoc) throw new McpError(ErrorCode.InternalError, "generateArtDoc not available in native binding");
-			const absolutePath = path.resolve(ctx.projectRoot, artPath);
-			const source = await fs.promises.readFile(absolutePath, "utf-8");
-			const doc = binding.generateArtDoc(source, { filename: absolutePath }, {
-				include_source: args?.includeSource,
-				include_templates: args?.includeTemplates,
-				include_metadata: true
-			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					markdown: doc.markdown,
-					title: doc.title,
-					category: doc.category,
-					variantCount: doc.variant_count
-				}, null, 2)
-			}] };
-		}
-		case "generate_catalog": {
-			if (!binding.generateArtCatalog) throw new McpError(ErrorCode.InternalError, "generateArtCatalog not available in native binding");
-			const arts = await ctx.scanArtFiles();
-			const sources = [];
-			for (const [filePath] of arts) {
-				const source = await fs.promises.readFile(filePath, "utf-8");
-				sources.push(source);
-			}
-			const catalog = binding.generateArtCatalog(sources, {
-				include_source: args?.includeSource,
-				include_templates: args?.includeTemplates,
-				include_metadata: true
-			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					markdown: catalog.markdown,
-					componentCount: catalog.component_count,
-					categories: catalog.categories,
-					tags: catalog.tags
-				}, null, 2)
-			}] };
-		}
-		case "get_tokens": {
-			const inputPath = args?.tokensPath;
-			const format = args?.format ?? "json";
-			let resolvedPath;
-			if (inputPath) resolvedPath = path.resolve(ctx.projectRoot, inputPath);
-			else resolvedPath = await ctx.resolveTokensPath();
-			if (!resolvedPath) throw new McpError(ErrorCode.InvalidParams, "No tokens path provided and none auto-detected. Looked for: tokens/, design-tokens/, style-dictionary/ directories.");
-			const categories = await parseTokensFromPath(resolvedPath);
-			if (format === "markdown") return { content: [{
-				type: "text",
-				text: generateTokensMarkdown(categories)
-			}] };
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({ categories }, null, 2)
-			}] };
-		}
+		case "analyze_component": return handleAnalyzeComponent(ctx, binding, args);
+		case "get_palette": return handleGetPalette(ctx, binding, args);
+		case "list_components": return handleListComponents(ctx, args);
+		case "get_component": return handleGetComponent(ctx, binding, args);
+		case "get_variant": return handleGetVariant(ctx, binding, args);
+		case "search_components": return handleSearchComponents(ctx, args);
+		case "generate_variants": return handleGenerateVariants(ctx, binding, args);
+		case "generate_csf": return handleGenerateCsf(ctx, binding, args);
+		case "generate_docs": return handleGenerateDocs(ctx, binding, args);
+		case "generate_catalog": return handleGenerateCatalog(ctx, binding, args);
+		case "get_tokens": return handleGetTokens(ctx, args);
 		default: throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/musea-mcp-server",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "MCP server for building Vue.js design systems - component analysis, documentation, variant generation, and design tokens",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.5.0",
-    "@vizejs/native": "0.12.0"
+    "@vizejs/native": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.14.0",