@gemini-designer/mcp-server 0.1.2 → 0.1.29

package/src/tools/sync-design-tokens.ts

@@ -17,41 +17,59 @@ import { assertReadablePath, assertWritablePath } from '../context/guards.js';
 import { sanitizeContent } from '../context/filter.js';
 import { writeFile } from '../output/file-writer.js';
 import {
-    parseCssVars,
-    tokensToCssVars,
-    tokensToTailwindTheme,
-    tokensToTokensStudio,
-    tokensToStyleDictionary,
-    type Token,
+  parseCssVars,
+  tokensToCssVars,
+  tokensToTailwindTheme,
+  tokensToTokensStudio,
+  tokensToStyleDictionary,
+  type TokenType,
+  type Token,
 } from '../tokens/sync.js';
 import { generateWithGemini } from '../generation/gemini-client.js';
 
+const TOKEN_TYPES: ReadonlySet<TokenType> = new Set([
+  'color',
+  'dimension',
+  'fontFamily',
+  'fontWeight',
+  'number',
+  'string',
+  'shadow',
+  'duration',
+  'easing',
+]);
+
+function coerceTokenType(value: unknown): TokenType {
+  if (typeof value === 'string' && TOKEN_TYPES.has(value as TokenType)) return value as TokenType;
+  return 'string';
+}
+
 const inputSchema = {
-    sourcePath: z.string().optional().describe('Path to a token source file (CSS vars or JSON).'),
-    sourceContent: z.string().optional().describe('Inline token content (if not using sourcePath).'),
-    sourceType: z
-        .enum(['css-vars', 'tokens-json', 'style-dictionary'])
-        .default('css-vars')
-        .describe('How to interpret the source.'),
-    targets: z
-        .array(z.enum(['css-vars', 'tailwind', 'tokens-studio', 'style-dictionary']))
-        .default(['css-vars', 'tailwind', 'tokens-studio'])
-        .describe('Target formats to generate.'),
-    aiNormalize: z
-        .boolean()
-        .default(false)
-        .describe('If true, use the model to improve token naming & grouping (uses tokens).'),
-    writeToFile: z.boolean().default(false).describe('If true, write generated outputs to files.'),
-    outputPaths: z
-        .object({
-            cssVars: z.string().optional(),
-            tailwind: z.string().optional(),
-            tokensStudio: z.string().optional(),
-            styleDictionary: z.string().optional(),
-        })
-        .optional()
-        .describe('Where to write outputs if writeToFile=true.'),
-    backup: z.boolean().default(true).describe('Create .bak backups for overwritten files.'),
+  sourcePath: z.string().optional().describe('Path to a token source file (CSS vars or JSON).'),
+  sourceContent: z.string().optional().describe('Inline token content (if not using sourcePath).'),
+  sourceType: z
+    .enum(['css-vars', 'tokens-json', 'style-dictionary'])
+    .default('css-vars')
+    .describe('How to interpret the source.'),
+  targets: z
+    .array(z.enum(['css-vars', 'tailwind', 'tokens-studio', 'style-dictionary']))
+    .default(['css-vars', 'tailwind', 'tokens-studio'])
+    .describe('Target formats to generate.'),
+  aiNormalize: z
+    .boolean()
+    .default(false)
+    .describe('If true, use the model to improve token naming & grouping (uses tokens).'),
+  writeToFile: z.boolean().default(false).describe('If true, write generated outputs to files.'),
+  outputPaths: z
+    .object({
+      cssVars: z.string().optional(),
+      tailwind: z.string().optional(),
+      tokensStudio: z.string().optional(),
+      styleDictionary: z.string().optional(),
+    })
+    .optional()
+    .describe('Where to write outputs if writeToFile=true.'),
+  backup: z.boolean().default(true).describe('Create .bak backups for overwritten files.'),
 };
 
 const NORMALIZE_SYSTEM_PROMPT = `You are a design systems engineer. You will normalize and improve a design token set.
@@ -67,190 +85,194 @@ Output rules:
 `;
 
 function cleanJsonArray(response: string): string {
-    let out = response.trim();
-    const fenced = out.match(/```(?:json)?\n([\s\S]*?)```/);
-    if (fenced) out = fenced[1].trim();
-    return out;
+  let out = response.trim();
+  const fenced = out.match(/```(?:json)?\n([\s\S]*?)```/);
+  if (fenced) out = fenced[1].trim();
+  return out;
 }
 
 export function registerSyncDesignTokens(server: McpServer, config: Config): void {
-    server.registerTool(
-        'sync_design_tokens',
-        {
-            title: 'Sync Design Tokens',
-            description:
-                'Convert tokens between CSS vars, Tailwind theme, Tokens Studio JSON, and Style Dictionary. Optionally writes outputs to files.',
-            inputSchema,
-        },
-        async (args) => {
-            const sourcePath = args.sourcePath as string | undefined;
-            const sourceContent = args.sourceContent as string | undefined;
-            const sourceType = (args.sourceType as 'css-vars' | 'tokens-json' | 'style-dictionary') || 'css-vars';
-            const targets = (args.targets as Array<'css-vars' | 'tailwind' | 'tokens-studio' | 'style-dictionary'>) || [
-                'css-vars',
-                'tailwind',
-                'tokens-studio',
-            ];
-            const aiNormalize = args.aiNormalize === true;
-            const writeToFile = args.writeToFile === true;
-            const outputPaths = args.outputPaths as
-                | {
-                      cssVars?: string;
-                      tailwind?: string;
-                      tokensStudio?: string;
-                      styleDictionary?: string;
-                  }
-                | undefined;
-            const backup = args.backup !== false;
+  server.registerTool(
+    'sync_design_tokens',
+    {
+      title: 'Sync Design Tokens',
+      description:
+        'Convert tokens between CSS vars, Tailwind theme, Tokens Studio JSON, and Style Dictionary. Optionally writes outputs to files.',
+      inputSchema,
+    },
+    async (args) => {
+      const sourcePath = args.sourcePath as string | undefined;
+      const sourceContent = args.sourceContent as string | undefined;
+      const sourceType =
+        (args.sourceType as 'css-vars' | 'tokens-json' | 'style-dictionary') || 'css-vars';
+      const targets = (args.targets as Array<
+        'css-vars' | 'tailwind' | 'tokens-studio' | 'style-dictionary'
+      >) || ['css-vars', 'tailwind', 'tokens-studio'];
+      const aiNormalize = args.aiNormalize === true;
+      const writeToFile = args.writeToFile === true;
+      const outputPaths = args.outputPaths as
+        | {
+            cssVars?: string;
+            tailwind?: string;
+            tokensStudio?: string;
+            styleDictionary?: string;
+          }
+        | undefined;
+      const backup = args.backup !== false;
 
-            if (!sourcePath && !sourceContent) {
-                return {
-                    content: [{ type: 'text' as const, text: 'Error: Provide either sourcePath or sourceContent.' }],
-                    isError: true,
-                };
-            }
+      if (!sourcePath && !sourceContent) {
+        return {
+          content: [
+            { type: 'text' as const, text: 'Error: Provide either sourcePath or sourceContent.' },
+          ],
+          isError: true,
+        };
+      }
 
-            let raw: string;
-            let safeSourcePath: string | undefined;
-            try {
-                if (sourcePath) {
-                    safeSourcePath = assertReadablePath(sourcePath, config);
-                    raw = fs.readFileSync(safeSourcePath, 'utf-8');
-                } else {
-                    raw = sourceContent as string;
-                }
-            } catch (error) {
-                const message = error instanceof Error ? error.message : 'Could not read source';
-                return {
-                    content: [{ type: 'text' as const, text: `Error: ${message}` }],
-                    isError: true,
-                };
-            }
+      let raw: string;
+      let safeSourcePath: string | undefined;
+      try {
+        if (sourcePath) {
+          safeSourcePath = assertReadablePath(sourcePath, config);
+          raw = fs.readFileSync(safeSourcePath, 'utf-8');
+        } else {
+          raw = sourceContent as string;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Could not read source';
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
 
-            raw = sanitizeContent(raw);
+      raw = sanitizeContent(raw);
 
-            let tokens: Token[] = [];
-            const warnings: string[] = [];
+      let tokens: Token[] = [];
+      const warnings: string[] = [];
 
-            try {
-                if (sourceType === 'css-vars') {
-                    const parsed = parseCssVars(raw, safeSourcePath);
-                    tokens = parsed.tokens;
-                    warnings.push(...parsed.warnings);
-                } else {
-                    // Very lightweight: accept either Tokens Studio or Style Dictionary style
-                    const json = JSON.parse(raw);
-                    const collected: Token[] = [];
+      try {
+        if (sourceType === 'css-vars') {
+          const parsed = parseCssVars(raw, safeSourcePath);
+          tokens = parsed.tokens;
+          warnings.push(...parsed.warnings);
+        } else {
+          // Very lightweight: accept either Tokens Studio or Style Dictionary style
+          const json = JSON.parse(raw);
+          const collected: Token[] = [];
 
-                    const walk = (obj: any, prefix: string[]) => {
-                        if (!obj || typeof obj !== 'object') return;
-                        if (typeof obj.value === 'string' && typeof obj.type === 'string') {
-                            collected.push({
-                                name: [...prefix].join('.'),
-                                value: obj.value,
-                                type: obj.type,
-                                description: typeof obj.description === 'string' ? obj.description : undefined,
-                                source: { file: safeSourcePath ? safeSourcePath.split('/').pop() : undefined },
-                            });
-                            return;
-                        }
-                        for (const [k, v] of Object.entries(obj)) {
-                            walk(v, [...prefix, k]);
-                        }
-                    };
+          const walk = (obj: unknown, prefix: string[]) => {
+            if (!obj || typeof obj !== 'object') return;
 
-                    walk(json, []);
-                    tokens = collected;
-                    if (tokens.length === 0) warnings.push('No tokens found in JSON (expected nested {value,type} nodes).');
-                }
-            } catch (error) {
-                const message = error instanceof Error ? error.message : 'Failed to parse tokens';
-                return {
-                    content: [{ type: 'text' as const, text: `Error: ${message}` }],
-                    isError: true,
-                };
+            const rec = obj as Record<string, unknown>;
+            if (typeof rec.value === 'string' && typeof rec.type === 'string') {
+              collected.push({
+                name: [...prefix].join('.'),
+                value: rec.value,
+                type: coerceTokenType(rec.type),
+                description: typeof rec.description === 'string' ? rec.description : undefined,
+                source: { file: safeSourcePath ? safeSourcePath.split('/').pop() : undefined },
+              });
+              return;
+            }
+            for (const [k, v] of Object.entries(rec)) {
+              walk(v, [...prefix, k]);
             }
+          };
+
+          walk(json, []);
+          tokens = collected;
+          if (tokens.length === 0)
+            warnings.push('No tokens found in JSON (expected nested {value,type} nodes).');
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Failed to parse tokens';
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
 
-            // Optional AI normalization
-            if (aiNormalize && tokens.length > 0) {
-                const userPrompt = `Normalize these tokens. Remember: never change values.
+      // Optional AI normalization
+      if (aiNormalize && tokens.length > 0) {
+        const userPrompt = `Normalize these tokens. Remember: never change values.
 
 TOKENS (JSON array):
 ${JSON.stringify(tokens, null, 2)}`;
-                try {
-                    const resp = await generateWithGemini(config, NORMALIZE_SYSTEM_PROMPT, userPrompt, {
-                        toolName: 'sync_design_tokens',
-                    });
-                    const cleaned = cleanJsonArray(resp);
-                    const normalized = JSON.parse(cleaned);
-                    if (Array.isArray(normalized)) {
-                        tokens = normalized as Token[];
-                    } else {
-                        warnings.push('AI normalization returned non-array output; keeping original tokens.');
-                    }
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'AI normalization failed';
-                    warnings.push(`AI normalization failed: ${message}`);
-                }
-            }
+        try {
+          const resp = await generateWithGemini(config, NORMALIZE_SYSTEM_PROMPT, userPrompt, {
+            toolName: 'sync_design_tokens',
+          });
+          const cleaned = cleanJsonArray(resp);
+          const normalized = JSON.parse(cleaned);
+          if (Array.isArray(normalized)) {
+            tokens = normalized as Token[];
+          } else {
+            warnings.push('AI normalization returned non-array output; keeping original tokens.');
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'AI normalization failed';
+          warnings.push(`AI normalization failed: ${message}`);
+        }
+      }
 
-            const outputs: Record<string, string> = {};
-            for (const t of targets) {
-                if (t === 'css-vars') outputs.cssVars = tokensToCssVars(tokens);
-                if (t === 'tailwind') outputs.tailwind = tokensToTailwindTheme(tokens);
-                if (t === 'tokens-studio') outputs.tokensStudio = tokensToTokensStudio(tokens);
-                if (t === 'style-dictionary') outputs.styleDictionary = tokensToStyleDictionary(tokens);
-            }
+      const outputs: Record<string, string> = {};
+      for (const t of targets) {
+        if (t === 'css-vars') outputs.cssVars = tokensToCssVars(tokens);
+        if (t === 'tailwind') outputs.tailwind = tokensToTailwindTheme(tokens);
+        if (t === 'tokens-studio') outputs.tokensStudio = tokensToTokensStudio(tokens);
+        if (t === 'style-dictionary') outputs.styleDictionary = tokensToStyleDictionary(tokens);
+      }
 
-            // Optional writing
-            const written: Array<{ path: string; backupPath?: string }> = [];
-            if (writeToFile) {
-                const mapping = [
-                    { outKey: 'cssVars', pathKey: 'cssVars' },
-                    { outKey: 'tailwind', pathKey: 'tailwind' },
-                    { outKey: 'tokensStudio', pathKey: 'tokensStudio' },
-                    { outKey: 'styleDictionary', pathKey: 'styleDictionary' },
-                ] as const;
+      // Optional writing
+      const written: Array<{ path: string; backupPath?: string }> = [];
+      if (writeToFile) {
+        const mapping = [
+          { outKey: 'cssVars', pathKey: 'cssVars' },
+          { outKey: 'tailwind', pathKey: 'tailwind' },
+          { outKey: 'tokensStudio', pathKey: 'tokensStudio' },
+          { outKey: 'styleDictionary', pathKey: 'styleDictionary' },
+        ] as const;
 
-                for (const m of mapping) {
-                    const content = outputs[m.outKey];
-                    const outPath = outputPaths?.[m.pathKey];
-                    if (!content || !outPath) continue;
-                    try {
-                        const safeOut = assertWritablePath(outPath, config);
-                        const result = await writeFile(safeOut, content, { format: false, backup });
-                        if (!result.success) {
-                            return {
-                                content: [
-                                    {
-                                        type: 'text' as const,
-                                        text: `Error: Failed writing ${outPath}: ${result.error || 'Unknown error'}`,
-                                    },
-                                ],
-                                isError: true,
-                            };
-                        }
-                        written.push({ path: result.filePath, backupPath: result.backupPath || undefined });
-                    } catch (error) {
-                        const message = error instanceof Error ? error.message : 'Write failed';
-                        return {
-                            content: [{ type: 'text' as const, text: `Error: ${message}` }],
-                            isError: true,
-                        };
-                    }
-                }
+        for (const m of mapping) {
+          const content = outputs[m.outKey];
+          const outPath = outputPaths?.[m.pathKey];
+          if (!content || !outPath) continue;
+          try {
+            const safeOut = assertWritablePath(outPath, config);
+            const result = await writeFile(safeOut, content, { format: false, backup });
+            if (!result.success) {
+              return {
+                content: [
+                  {
+                    type: 'text' as const,
+                    text: `Error: Failed writing ${outPath}: ${result.error || 'Unknown error'}`,
+                  },
+                ],
+                isError: true,
+              };
             }
-
-            const response = {
-                tokens,
-                outputs,
-                warnings,
-                written,
-            };
-
+            written.push({ path: result.filePath, backupPath: result.backupPath || undefined });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : 'Write failed';
             return {
-                content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+              content: [{ type: 'text' as const, text: `Error: ${message}` }],
+              isError: true,
             };
+          }
         }
-    );
+      }
+
+      const response = {
+        tokens,
+        outputs,
+        warnings,
+        written,
+      };
+
+      return {
+        content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+      };
+    }
+  );
 }

package/src/utils/walk.ts

@@ -10,66 +10,68 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 
 export interface WalkOptions {
-    includeExtensions?: string[];
-    excludeDirNames?: string[];
-    maxFiles?: number;
+  includeExtensions?: string[];
+  excludeDirNames?: string[];
+  maxFiles?: number;
 }
 
 const DEFAULT_EXCLUDE_DIRS = [
-    'node_modules',
-    '.git',
-    '.next',
-    '.nuxt',
-    'dist',
-    'build',
-    '.turbo',
-    '.cache',
-    'coverage',
+  'node_modules',
+  '.git',
+  '.next',
+  '.nuxt',
+  'dist',
+  'build',
+  '.turbo',
+  '.cache',
+  'coverage',
 ];
 
 export function walkFiles(rootDir: string, options: WalkOptions = {}): string[] {
-    const includeExtensions = (options.includeExtensions || []).map((e) => e.toLowerCase());
-    const exclude = new Set((options.excludeDirNames || DEFAULT_EXCLUDE_DIRS).map((d) => d.toLowerCase()));
-    const maxFiles = typeof options.maxFiles === 'number' ? options.maxFiles : 10_000;
+  const includeExtensions = (options.includeExtensions || []).map((e) => e.toLowerCase());
+  const exclude = new Set(
+    (options.excludeDirNames || DEFAULT_EXCLUDE_DIRS).map((d) => d.toLowerCase())
+  );
+  const maxFiles = typeof options.maxFiles === 'number' ? options.maxFiles : 10_000;
 
-    const results: string[] = [];
-    const queue: string[] = [rootDir];
+  const results: string[] = [];
+  const queue: string[] = [rootDir];
 
-    while (queue.length > 0) {
-        const current = queue.pop()!;
-        let entries: fs.Dirent[];
-        try {
-            entries = fs.readdirSync(current, { withFileTypes: true });
-        } catch {
-            continue;
-        }
+  while (queue.length > 0) {
+    const current = queue.pop()!;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
 
-        for (const ent of entries) {
-            if (results.length >= maxFiles) return results;
-            const abs = path.join(current, ent.name);
+    for (const ent of entries) {
+      if (results.length >= maxFiles) return results;
+      const abs = path.join(current, ent.name);
 
-            if (ent.isDirectory()) {
-                if (exclude.has(ent.name.toLowerCase())) continue;
-                queue.push(abs);
-                continue;
-            }
+      if (ent.isDirectory()) {
+        if (exclude.has(ent.name.toLowerCase())) continue;
+        queue.push(abs);
+        continue;
+      }
 
-            if (!ent.isFile()) continue;
-            if (includeExtensions.length === 0) {
-                results.push(abs);
-                continue;
-            }
+      if (!ent.isFile()) continue;
+      if (includeExtensions.length === 0) {
+        results.push(abs);
+        continue;
+      }
 
-            const ext = path.extname(ent.name).toLowerCase();
-            if (includeExtensions.includes(ext)) {
-                results.push(abs);
-            }
-        }
+      const ext = path.extname(ent.name).toLowerCase();
+      if (includeExtensions.includes(ext)) {
+        results.push(abs);
+      }
     }
+  }
 
-    return results;
+  return results;
 }
 
 export function toPosixPath(p: string): string {
-    return p.replace(/\\/g, '/');
+  return p.replace(/\\/g, '/');
 }

package/src/version.ts

@@ -0,0 +1,6 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json') as { version?: string };
+
+export const VERSION = typeof pkg.version === 'string' ? pkg.version : '0.0.0';

package/tsconfig.json

@@ -1,34 +1,24 @@
 {
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "lib": [
-            "ES2022"
-        ],
-        "outDir": "dist",
-        "rootDir": "src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true,
-        "baseUrl": ".",
-        "paths": {
-            "@/*": [
-                "src/*"
-            ]
-        }
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist",
-        "**/*.test.ts"
-    ]
-}
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}