@gemini-designer/mcp-server 0.1.2 → 0.1.29

package/src/tools/analyze-tokens.ts

@@ -14,11 +14,11 @@ import { sanitizeContent } from '../context/filter.js';
 import { generateWithGemini } from '../generation/gemini-client.js';
 
 const inputSchema = {
-    paths: z.array(z.string()).describe('Paths to CSS, SCSS, or design token files to analyze'),
-    format: z
-        .enum(['json', 'css-vars', 'tailwind', 'summary'])
-        .default('json')
-        .describe('Output format for the extracted tokens'),
+  paths: z.array(z.string()).describe('Paths to CSS, SCSS, or design token files to analyze'),
+  format: z
+    .enum(['json', 'css-vars', 'tailwind', 'summary'])
+    .default('json')
+    .describe('Output format for the extracted tokens'),
 };
 
 const SYSTEM_PROMPT = `You are a design system analyst. Your task is to extract and structure design tokens from CSS/SCSS files.
@@ -42,82 +42,84 @@ Output rules:
 When naming tokens, prefer semantic names (primary, surface, text, border) rather than raw hex values.`;
 
 export function registerAnalyzeTokens(server: McpServer, config: Config): void {
-    server.registerTool(
-        'analyze_tokens',
-        {
-            title: 'Analyze Design Tokens',
-            description:
-                'Extract and structure design tokens from existing CSS/SCSS files. Use before create_ui to understand existing design systems.',
-            inputSchema,
-        },
-        async (args) => {
-            const paths = args.paths as string[];
-            const format = (args.format as 'json' | 'css-vars' | 'tailwind' | 'summary') || 'json';
-
-            // Read all specified files (with safety checks)
-            const fileContents: string[] = [];
-            const errors: string[] = [];
-
-            for (const filePath of paths) {
-                try {
-                    const safePath = assertReadablePath(filePath, config);
-                    const raw = fs.readFileSync(safePath, 'utf-8');
-                    const content = sanitizeContent(raw);
-                    fileContents.push(`/* File: ${filePath} */\n${content}`);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Could not read';
-                    errors.push(`${filePath}: ${message}`);
-                }
-            }
-
-            if (fileContents.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text' as const,
-                            text: `Error: Could not read any files.\n${errors.join('\n')}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-
-            if (errors.length > 0 && config.debug) {
-                console.error('[analyze_tokens] Warnings:\n' + errors.join('\n'));
-            }
-
-            const combinedContent = fileContents.join('\n\n');
-
-            const userPrompt = `Analyze these CSS/SCSS files and extract design tokens.
+  server.registerTool(
+    'analyze_tokens',
+    {
+      title: 'Analyze Design Tokens',
+      description:
+        'Extract and structure design tokens from existing CSS/SCSS files. Use before create_ui to understand existing design systems.',
+      inputSchema,
+    },
+    async (args) => {
+      const paths = args.paths as string[];
+      const format = (args.format as 'json' | 'css-vars' | 'tailwind' | 'summary') || 'json';
+
+      // Read all specified files (with safety checks)
+      const fileContents: string[] = [];
+      const errors: string[] = [];
+
+      for (const filePath of paths) {
+        try {
+          const safePath = assertReadablePath(filePath, config);
+          const raw = fs.readFileSync(safePath, 'utf-8');
+          const content = sanitizeContent(raw);
+          fileContents.push(`/* File: ${filePath} */\n${content}`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'Could not read';
+          errors.push(`${filePath}: ${message}`);
+        }
+      }
+
+      if (fileContents.length === 0) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Error: Could not read any files.\n${errors.join('\n')}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      if (errors.length > 0 && config.debug) {
+        console.error('[analyze_tokens] Warnings:\n' + errors.join('\n'));
+      }
+
+      const combinedContent = fileContents.join('\n\n');
+
+      const userPrompt = `Analyze these CSS/SCSS files and extract design tokens.
 Format: ${format}
 
 FILES:
 ${combinedContent}`;
 
-            try {
-                const response = await generateWithGemini(config, SYSTEM_PROMPT, userPrompt, { toolName: 'analyze_tokens' });
-
-                // IMPORTANT: Return raw model output ONLY (no wrappers) so JSON / CSS output stays valid.
-                return {
-                    content: [
-                        {
-                            type: 'text' as const,
-                            text: response.trim(),
-                        },
-                    ],
-                };
-            } catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error';
-                return {
-                    content: [
-                        {
-                            type: 'text' as const,
-                            text: `Error analyzing tokens: ${message}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        }
-    );
+      try {
+        const response = await generateWithGemini(config, SYSTEM_PROMPT, userPrompt, {
+          toolName: 'analyze_tokens',
+        });
+
+        // IMPORTANT: Return raw model output ONLY (no wrappers) so JSON / CSS output stays valid.
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: response.trim(),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Error analyzing tokens: ${message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }

package/src/tools/catalog-components.ts

@@ -18,82 +18,82 @@ import { walkFiles, toPosixPath } from '../utils/walk.js';
 import { buildComponentCatalog } from '../components/catalog.js';
 
 const inputSchema = {
-    roots: z
-        .array(z.string())
-        .optional()
-        .describe('Directories to scan (defaults to ["src"]).'),
-    extensions: z
-        .array(z.string())
-        .optional()
-        .describe('File extensions to include (defaults to [".tsx", ".jsx"]).'),
-    maxFiles: z
-        .number()
-        .int()
-        .min(1)
-        .max(50_000)
-        .default(2000)
-        .describe('Safety limit to avoid scanning huge repos.'),
+  roots: z.array(z.string()).optional().describe('Directories to scan (defaults to ["src"]).'),
+  extensions: z
+    .array(z.string())
+    .optional()
+    .describe('File extensions to include (defaults to [".tsx", ".jsx"]).'),
+  maxFiles: z
+    .number()
+    .int()
+    .min(1)
+    .max(50_000)
+    .default(2000)
+    .describe('Safety limit to avoid scanning huge repos.'),
 };
 
 export function registerCatalogComponents(server: McpServer, config: Config): void {
-    server.registerTool(
-        'catalog_components',
-        {
-            title: 'Catalog Components',
-            description: 'Scan the repo and return a JSON catalog of exported components (no LLM).',
-            inputSchema,
-        },
-        async (args) => {
-            const roots = (args.roots as string[] | undefined) || ['src'];
-            const extensions = (args.extensions as string[] | undefined) || ['.tsx', '.jsx'];
-            const maxFiles = (args.maxFiles as number | undefined) || 2000;
+  server.registerTool(
+    'catalog_components',
+    {
+      title: 'Catalog Components',
+      description: 'Scan the repo and return a JSON catalog of exported components (no LLM).',
+      inputSchema,
+    },
+    async (args) => {
+      const roots = (args.roots as string[] | undefined) || ['src'];
+      const extensions = (args.extensions as string[] | undefined) || ['.tsx', '.jsx'];
+      const maxFiles = (args.maxFiles as number | undefined) || 2000;
 
-            const safeRoots: string[] = [];
-            for (const r of roots) {
-                try {
-                    safeRoots.push(assertReadableDir(r, config));
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Invalid root';
-                    return {
-                        content: [{ type: 'text' as const, text: `Error: ${message}` }],
-                        isError: true,
-                    };
-                }
-            }
+      const safeRoots: string[] = [];
+      for (const r of roots) {
+        try {
+          safeRoots.push(assertReadableDir(r, config));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'Invalid root';
+          return {
+            content: [{ type: 'text' as const, text: `Error: ${message}` }],
+            isError: true,
+          };
+        }
+      }
 
-            const allFiles: string[] = [];
-            for (const r of safeRoots) {
-                const found = walkFiles(r, { includeExtensions: extensions, maxFiles });
-                allFiles.push(...found);
-            }
+      const allFiles: string[] = [];
+      for (const r of safeRoots) {
+        const found = walkFiles(r, { includeExtensions: extensions, maxFiles });
+        allFiles.push(...found);
+      }
 
-            // Use cwd as catalog root so paths are stable for agents
-            const root = path.resolve(process.cwd());
+      // Use cwd as catalog root so paths are stable for agents
+      const root = path.resolve(process.cwd());
 
-            const catalog = await buildComponentCatalog(root, allFiles.map((f) => path.resolve(f)));
+      const catalog = await buildComponentCatalog(
+        root,
+        allFiles.map((f) => path.resolve(f))
+      );
 
-            // Ensure POSIX paths
-            catalog.components = catalog.components.map((c) => ({ ...c, file: toPosixPath(c.file) }));
-            catalog.root = toPosixPath(catalog.root);
+      // Ensure POSIX paths
+      catalog.components = catalog.components.map((c) => ({ ...c, file: toPosixPath(c.file) }));
+      catalog.root = toPosixPath(catalog.root);
 
-            // Small summary
-            const summary = {
-                totalFiles: catalog.filesScanned,
-                totalComponents: catalog.components.length,
-                byExportType: {
-                    named: catalog.components.filter((c) => c.exportType === 'named').length,
-                    default: catalog.components.filter((c) => c.exportType === 'default').length,
-                },
-            };
+      // Small summary
+      const summary = {
+        totalFiles: catalog.filesScanned,
+        totalComponents: catalog.components.length,
+        byExportType: {
+          named: catalog.components.filter((c) => c.exportType === 'named').length,
+          default: catalog.components.filter((c) => c.exportType === 'default').length,
+        },
+      };
 
-            return {
-                content: [
-                    {
-                        type: 'text' as const,
-                        text: JSON.stringify({ ...catalog, summary }, null, 2),
-                    },
-                ],
-            };
-        }
-    );
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: JSON.stringify({ ...catalog, summary }, null, 2),
+          },
+        ],
+      };
+    }
+  );
 }