@atomixstudio/mcp 0.1.1 → 1.0.1

package/src/index.ts

@@ -1,1155 +0,0 @@
-/**
- * Atomix MCP Server
- * 
- * Exposes design tokens to AI tools via the Model Context Protocol.
- * 
- * Tools:
- * - getToken: Get a specific token by path
- * - listTokens: List all tokens in a category
- * - getComponentTokens: Get tokens for a specific component
- * - validateUsage: Check if a value follows the design system
- * - generateCursorRules: Generate .cursorrules for a project
- */
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-import { loadPrimitives } from "./tokens.js";
-import { 
-  getTokenByPath, 
-  listTokensInCategory, 
-  flattenTokens,
-  getTokenCategories,
-  getCssVariableName,
-  getTokenMetadata,
-  isSemanticToken,
-  type TokenTier,
-} from "./utils.js";
-import { COMPONENT_TOKENS } from "./component-tokens.js";
-import {
-  parseCLIArgs,
-  isUserDSMode,
-  fetchUserDesignSystem,
-  transformUserTokens,
-} from "./user-tokens.js";
-import { 
-  generateCursorRules,
-  generateRulesForTool,
-  generateRulesForAllTools,
-  getSupportedAITools,
-  generateToolSetupGuide,
-  generateMCPConfig,
-  generateAllMCPConfigs,
-  getSetupInstructions,
-  AI_TOOLS,
-  type AIToolId,
-  type MCPConfigToolId,
-} from "./ai-rules-generator.js";
-
-// ============================================
-// HELPERS
-// ============================================
-
-/**
- * Format a timestamp as a human-readable "time ago" string
- */
-function formatTimeAgo(timestamp: number): string {
-  const now = Date.now();
-  const diffMs = now - timestamp;
-  const diffSec = Math.floor(diffMs / 1000);
-  const diffMin = Math.floor(diffSec / 60);
-  const diffHour = Math.floor(diffMin / 60);
-  const diffDay = Math.floor(diffHour / 24);
-
-  if (diffSec < 60) return "just now";
-  if (diffMin < 60) return `${diffMin} minute${diffMin > 1 ? "s" : ""} ago`;
-  if (diffHour < 24) return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
-  if (diffDay < 7) return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
-  
-  // For older dates, show the date
-  const date = new Date(timestamp);
-  return date.toLocaleDateString("en-US", { 
-    month: "short", 
-    day: "numeric", 
-    year: date.getFullYear() !== new Date().getFullYear() ? "numeric" : undefined 
-  });
-}
-
-// ============================================
-// SERVER SETUP
-// ============================================
-
-const server = new Server(
-  {
-    name: "atomix-mcp",
-    version: "0.1.0",
-  },
-  {
-    capabilities: {
-      tools: {},
-      resources: {},
-    },
-  }
-);
-
-// ============================================
-// TOOL DEFINITIONS
-// ============================================
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "getToken",
-        description: "Get a specific design token by its path. Returns value, CSS variable, and tier metadata. IMPORTANT: Tokens are tiered - 'primitive' tokens are read-only reference values, 'semantic' tokens are the primary API for styling.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            path: {
-              type: "string",
-              description: "Token path in dot notation. Prefer semantic paths (colors.modes.light.bgPage) over primitive paths (colors.scales.green.500)",
-            },
-            tenantId: {
-              type: "string",
-              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')",
-            },
-          },
-          required: ["path"],
-        },
-      },
-      {
-        name: "listTokens",
-        description: "List tokens in a category. Use 'tier' filter to get only semantic tokens (recommended) or primitives (reference only). Semantic tokens are the primary API; primitives are read-only reference values.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            category: {
-              type: "string",
-              enum: ["colors", "typography", "spacing", "sizing", "shadows", "radius", "motion", "zIndex", "borders"],
-              description: "Token category to list",
-            },
-            subcategory: {
-              type: "string",
-              description: "Optional subcategory, e.g., 'modes.light' for semantic colors, 'scale' for primitive spacing",
-            },
-            tier: {
-              type: "string",
-              enum: ["semantic", "primitive", "all"],
-              description: "Filter by token tier. 'semantic' (recommended) returns purpose-driven tokens for styling. 'primitive' returns raw reference values. Default: 'all'",
-            },
-            tenantId: {
-              type: "string",
-              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')",
-            },
-          },
-          required: ["category"],
-        },
-      },
-      {
-        name: "getComponentTokens",
-        description: "Get all design tokens used by a specific component (Button, Card, Dialog, etc.)",
-        inputSchema: {
-          type: "object",
-          properties: {
-            component: {
-              type: "string",
-              enum: ["button", "card", "dialog", "input", "select", "heading", "checkbox", "radio", "toggle", "selectionControls"],
-              description: "Component name",
-            },
-            variant: {
-              type: "string",
-              description: "Optional variant name (e.g., 'primary', 'outline', 'ghost')",
-            },
-            size: {
-              type: "string",
-              description: "Optional size name (e.g., 'sm', 'md', 'lg')",
-            },
-            tenantId: {
-              type: "string",
-              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')",
-            },
-          },
-          required: ["component"],
-        },
-      },
-      {
-        name: "validateUsage",
-        description: "Check if a CSS value follows the Atomix design system. Detects arbitrary values that should use tokens.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            value: {
-              type: "string",
-              description: "CSS value to validate, e.g., '#ff0000', '16px', 'rgb(0,112,97)'",
-            },
-            context: {
-              type: "string",
-              enum: ["color", "spacing", "radius", "shadow", "typography", "any"],
-              description: "Context of the value (helps find the right token)",
-            },
-          },
-          required: ["value"],
-        },
-      },
-      {
-        name: "generateCursorRules",
-        description: "[DEPRECATED] Use 'getAIToolRules' instead. Generate .cursorrules content for a project.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            projectName: {
-              type: "string",
-              description: "Name of the project",
-            },
-            strict: {
-              type: "boolean",
-              description: "Whether to enforce strict token usage (no arbitrary values)",
-            },
-          },
-          required: [],
-        },
-      },
-      {
-        name: "getAIToolRules",
-        description: "Generate design system rules for AI coding tools. Supports Cursor, GitHub Copilot, Windsurf, Cline, Continue, Zed, and more.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            tool: {
-              type: "string",
-              enum: ["cursor", "copilot", "windsurf", "cline", "continue", "zed", "generic", "all"],
-              description: "AI tool to generate rules for. Use 'all' to generate for all supported tools.",
-            },
-            projectName: {
-              type: "string",
-              description: "Name of the project (default: 'My Project')",
-            },
-            strict: {
-              type: "boolean",
-              description: "Enforce strict token usage - no arbitrary values allowed (default: true)",
-            },
-          },
-          required: ["tool"],
-        },
-      },
-      {
-        name: "listAITools",
-        description: "List all supported AI coding tools and their rules file conventions.",
-        inputSchema: {
-          type: "object",
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: "getAIToolSetupGuide",
-        description: "Get a complete setup guide for integrating Atomix with AI coding tools.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            projectName: {
-              type: "string",
-              description: "Name of the project",
-            },
-          },
-          required: [],
-        },
-      },
-      {
-        name: "exportMCPConfig",
-        description: "Generate MCP configuration file for AI tools. Creates ready-to-use config for Cursor (.cursor/mcp.json), Claude Desktop, Windsurf, Continue, or VS Code.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            tool: {
-              type: "string",
-              enum: ["cursor", "claude-desktop", "windsurf", "continue", "vscode", "all"],
-              description: "AI tool to generate MCP config for. Use 'all' to generate for all supported tools.",
-            },
-            tenantId: {
-              type: "string",
-              description: "Tenant ID for multi-tenant setups (optional, defaults to 'default')",
-            },
-            projectName: {
-              type: "string",
-              description: "Project name for identification (optional)",
-            },
-            useNpx: {
-              type: "boolean",
-              description: "Use npx to run the server (default: true). Set to false for local development.",
-            },
-          },
-          required: ["tool"],
-        },
-      },
-      {
-        name: "getSetupInstructions",
-        description: "Get detailed step-by-step setup instructions for a specific AI tool. Includes MCP configuration, rules file setup, and verification steps.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            tool: {
-              type: "string",
-              enum: ["cursor", "copilot", "windsurf", "cline", "continue", "zed", "claude-desktop", "generic"],
-              description: "AI tool to get setup instructions for.",
-            },
-          },
-          required: ["tool"],
-        },
-      },
-      {
-        name: "searchTokens",
-        description: "Search for tokens by name or value. Results include tier metadata - prefer using 'semantic' tier tokens in code, use 'primitive' tier only for reference/validation.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "Search query (matches token paths or values)",
-            },
-            tier: {
-              type: "string",
-              enum: ["semantic", "primitive", "all"],
-              description: "Filter results by tier. 'semantic' recommended for styling. Default: 'all'",
-            },
-          },
-          required: ["query"],
-        },
-      },
-    ],
-  };
-});
-
-// ============================================
-// TOOL HANDLERS
-// ============================================
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  switch (name) {
-    case "getToken": {
-      const path = args?.path as string;
-      const value = getTokenByPath(primitives, path);
-      
-      if (value === undefined) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: `Token not found: ${path}`,
-                suggestion: `Use listTokens to see available tokens. Available categories: ${getTokenCategories().join(", ")}`,
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      const cssVar = getCssVariableName(path);
-      const metadata = getTokenMetadata(path);
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              path,
-              value,
-              cssVariable: cssVar,
-              // Token tier classification
-              tier: metadata.tier,
-              mutable: metadata.mutable,
-              editVia: metadata.editVia || null,
-              guidance: metadata.guidance,
-              // Usage examples
-              usage: metadata.tier === "semantic" ? {
-                css: `var(${cssVar})`,
-                tailwind: getTailwindClass(path, value),
-                recommendation: "Use this token in your components.",
-              } : {
-                css: `var(${cssVar})`,
-                tailwind: getTailwindClass(path, value),
-                recommendation: "This is a primitive (read-only reference). Consider using a semantic token instead.",
-                semanticAlternatives: getSuggestedSemanticTokens(path),
-              },
-            }, null, 2),
-          },
-        ],
-      };
-    }
-
-    case "listTokens": {
-      const category = args?.category as string;
-      const subcategory = args?.subcategory as string | undefined;
-      const tierFilter = (args?.tier as TokenTier | "all") || "all";
-      
-      const rawTokens = listTokensInCategory(primitives, category, subcategory);
-      
-      // Apply tier filter and add metadata
-      const tokensWithMetadata: Record<string, {
-        value: unknown;
-        tier: TokenTier;
-        mutable: boolean;
-        guidance: string;
-      }> = {};
-      
-      for (const [tokenPath, value] of Object.entries(rawTokens)) {
-        const fullPath = subcategory 
-          ? `${category}.${subcategory}.${tokenPath}`
-          : `${category}.${tokenPath}`;
-        const metadata = getTokenMetadata(fullPath);
-        
-        // Apply tier filter
-        if (tierFilter !== "all" && metadata.tier !== tierFilter) {
-          continue;
-        }
-        
-        tokensWithMetadata[tokenPath] = {
-          value,
-          tier: metadata.tier,
-          mutable: metadata.mutable,
-          guidance: metadata.guidance,
-        };
-      }
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              category,
-              subcategory: subcategory || null,
-              tierFilter,
-              count: Object.keys(tokensWithMetadata).length,
-              note: tierFilter === "all" 
-                ? "Results include both primitive (read-only) and semantic (usable) tokens. Use tier='semantic' for styling recommendations."
-                : tierFilter === "semantic"
-                ? "Showing semantic tokens - these are the recommended tokens for styling."
-                : "Showing primitive tokens - use these for reference/validation only, not direct styling.",
-              tokens: tokensWithMetadata,
-            }, null, 2),
-          },
-        ],
-      };
-    }
-
-    case "getComponentTokens": {
-      const component = args?.component as string;
-      const variant = args?.variant as string | undefined;
-      const size = args?.size as string | undefined;
-      
-      const componentKey = component.toLowerCase();
-      const componentData = COMPONENT_TOKENS[componentKey];
-      
-      if (!componentData) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: `Component not found: ${component}`,
-                available: Object.keys(COMPONENT_TOKENS),
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      let result = { ...componentData };
-      
-      // Filter by variant if specified
-      if (variant && result.variants) {
-        result.variants = { [variant]: result.variants[variant] };
-      }
-      
-      // Filter by size if specified
-      if (size && result.sizes) {
-        result.sizes = { [size]: result.sizes[size] };
-      }
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case "validateUsage": {
-      const value = args?.value as string;
-      const context = (args?.context as string) || "any";
-      
-      const validation = validateValue(value, context);
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(validation, null, 2),
-          },
-        ],
-      };
-    }
-
-    case "generateCursorRules": {
-      // DEPRECATED: Forward to getAIToolRules
-      const projectName = (args?.projectName as string) || "My Project";
-      const strict = (args?.strict as boolean) ?? true;
-      
-      const rules = generateCursorRules(projectName, strict);
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: `<!-- DEPRECATED: Use getAIToolRules instead -->\n${rules}`,
-          },
-        ],
-      };
-    }
-
-    case "getAIToolRules": {
-      const tool = args?.tool as string;
-      const projectName = (args?.projectName as string) || "My Project";
-      const strict = (args?.strict as boolean) ?? true;
-      
-      if (tool === "all") {
-        // Generate for all tools
-        const allRules = generateRulesForAllTools(projectName, strict);
-        
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                message: `Generated rules for ${allRules.length} AI tools`,
-                tools: allRules.map(r => ({
-                  tool: r.tool.name,
-                  filename: r.filename,
-                  path: r.path,
-                  description: r.tool.description,
-                })),
-                files: allRules.map(r => ({
-                  path: r.path,
-                  content: r.content,
-                })),
-              }, null, 2),
-            },
-          ],
-        };
-      }
-      
-      // Generate for specific tool
-      try {
-        const result = generateRulesForTool(tool as AIToolId, projectName, strict);
-        
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                tool: result.tool.name,
-                filename: result.filename,
-                path: result.path,
-                description: result.tool.description,
-                content: result.content,
-              }, null, 2),
-            },
-          ],
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: String(error),
-                availableTools: Object.keys(AI_TOOLS),
-              }, null, 2),
-            },
-          ],
-        };
-      }
-    }
-
-    case "listAITools": {
-      const tools = getSupportedAITools();
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              count: tools.length,
-              tools: tools.map(t => ({
-                id: t.id,
-                name: t.name,
-                rulesFile: t.rulesPath,
-                description: t.description,
-              })),
-              note: "Use getAIToolRules({ tool: 'toolId' }) to generate rules for a specific tool.",
-            }, null, 2),
-          },
-        ],
-      };
-    }
-
-    case "getAIToolSetupGuide": {
-      const projectName = (args?.projectName as string) || "My Project";
-      const guide = generateToolSetupGuide(projectName);
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: guide,
-          },
-        ],
-      };
-    }
-
-    case "exportMCPConfig": {
-      const tool = args?.tool as string;
-      const tenantId = (args?.tenantId as string) || "default";
-      const projectName = (args?.projectName as string) || "my-project";
-      const useNpx = (args?.useNpx as boolean) ?? true;
-      
-      const options = { tenantId, projectName, useNpx };
-      
-      if (tool === "all") {
-        // Generate for all tools
-        const allConfigs = generateAllMCPConfigs(options);
-        
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                message: `Generated MCP configs for ${allConfigs.length} AI tools`,
-                configs: allConfigs.map(c => ({
-                  tool: c.tool,
-                  path: c.path,
-                  filename: c.filename,
-                })),
-                files: allConfigs.map(c => ({
-                  tool: c.tool,
-                  path: c.path,
-                  content: c.content,
-                  instructions: c.instructions,
-                })),
-              }, null, 2),
-            },
-          ],
-        };
-      }
-      
-      // Generate for specific tool
-      try {
-        const config = generateMCPConfig(tool as MCPConfigToolId, options);
-        
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                tool: config.tool,
-                path: config.path,
-                filename: config.filename,
-                content: config.content,
-                instructions: config.instructions,
-              }, null, 2),
-            },
-          ],
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: String(error),
-                availableTools: ["cursor", "claude-desktop", "windsurf", "continue", "vscode", "all"],
-              }, null, 2),
-            },
-          ],
-        };
-      }
-    }
-
-    case "getSetupInstructions": {
-      const toolId = args?.tool as AIToolId;
-      
-      try {
-        const instructions = getSetupInstructions(toolId);
-        
-        return {
-          content: [
-            {
-              type: "text",
-              text: instructions,
-            },
-          ],
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: String(error),
-                availableTools: Object.keys(AI_TOOLS),
-              }, null, 2),
-            },
-          ],
-        };
-      }
-    }
-
-    case "searchTokens": {
-      const query = (args?.query as string).toLowerCase();
-      const tierFilter = (args?.tier as TokenTier | "all") || "all";
-      const allTokens = flattenTokens(primitives);
-      
-      const matches = Object.entries(allTokens)
-        .filter(([path, value]) => {
-          const pathLower = path.toLowerCase();
-          const valueStr = String(value).toLowerCase();
-          const matchesQuery = pathLower.includes(query) || valueStr.includes(query);
-          
-          if (!matchesQuery) return false;
-          
-          // Apply tier filter
-          if (tierFilter !== "all") {
-            const metadata = getTokenMetadata(path);
-            if (metadata.tier !== tierFilter) return false;
-          }
-          
-          return true;
-        })
-        .slice(0, 50) // Limit results
-        .map(([path, value]) => {
-          const metadata = getTokenMetadata(path);
-          return {
-            path,
-            value,
-            cssVariable: getCssVariableName(path),
-            tier: metadata.tier,
-            mutable: metadata.mutable,
-            guidance: metadata.guidance,
-          };
-        });
-      
-      // Sort semantic tokens first
-      matches.sort((a, b) => {
-        if (a.tier === "semantic" && b.tier !== "semantic") return -1;
-        if (a.tier !== "semantic" && b.tier === "semantic") return 1;
-        return 0;
-      });
-      
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              query,
-              tierFilter,
-              count: matches.length,
-              note: "Semantic tokens are listed first. Use semantic tokens for styling; primitives are for reference only.",
-              matches,
-            }, null, 2),
-          },
-        ],
-      };
-    }
-
-    default:
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ error: `Unknown tool: ${name}` }),
-          },
-        ],
-      };
-  }
-});
-
-// ============================================
-// RESOURCE DEFINITIONS
-// ============================================
-
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  return {
-    resources: [
-      {
-        uri: "atomix://tokens/all",
-        name: "All Atomix Tokens",
-        description: "Complete design token reference",
-        mimeType: "application/json",
-      },
-      {
-        uri: "atomix://tokens/colors",
-        name: "Color Tokens",
-        description: "All color tokens (static, scales, modes)",
-        mimeType: "application/json",
-      },
-      {
-        uri: "atomix://tokens/typography",
-        name: "Typography Tokens",
-        description: "Font families, sizes, weights, line heights",
-        mimeType: "application/json",
-      },
-      {
-        uri: "atomix://tokens/spacing",
-        name: "Spacing Tokens",
-        description: "Spacing scale, insets, gaps",
-        mimeType: "application/json",
-      },
-      {
-        uri: "atomix://components",
-        name: "Component Tokens",
-        description: "Token mappings for all components",
-        mimeType: "application/json",
-      },
-    ],
-  };
-});
-
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  const uri = request.params.uri;
-  
-  switch (uri) {
-    case "atomix://tokens/all":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(primitives, null, 2),
-          },
-        ],
-      };
-    
-    case "atomix://tokens/colors":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(primitives.colors, null, 2),
-          },
-        ],
-      };
-    
-    case "atomix://tokens/typography":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(primitives.typography, null, 2),
-          },
-        ],
-      };
-    
-    case "atomix://tokens/spacing":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(primitives.spacing, null, 2),
-          },
-        ],
-      };
-    
-    case "atomix://components":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(COMPONENT_TOKENS, null, 2),
-          },
-        ],
-      };
-    
-    default:
-      throw new Error(`Unknown resource: ${uri}`);
-  }
-});
-
-// ============================================
-// HELPER FUNCTIONS
-// ============================================
-
-function getTailwindClass(path: string, value: unknown): string | null {
-  // Map common token paths to Tailwind classes
-  if (path.startsWith("colors.static.brand.primary")) return "bg-brand text-brand";
-  // Spacing: flat structure (spacing.xs, spacing.md, etc.)
-  if (path.startsWith("spacing.") && !path.includes(".inset")) {
-    const size = path.split(".").pop();
-    return `p-${size} m-${size} gap-${size}`;
-  }
-  // Radius: flat structure (radius.xs, radius.md, etc.)
-  if (path.startsWith("radius.")) {
-    const size = path.split(".").pop();
-    return `rounded-${size}`;
-  }
-  return null;
-}
-
-/**
- * Suggest semantic token alternatives for a primitive token path
- */
-function getSuggestedSemanticTokens(primitivePath: string): string[] {
-  const suggestions: string[] = [];
-  
-  // Color scale → Mode colors
-  if (primitivePath.startsWith("colors.scales.")) {
-    suggestions.push(
-      "colors.modes.light.bgPage (page background)",
-      "colors.modes.light.bgSurface (card/panel background)",
-      "colors.modes.light.textPrimary (main text)",
-      "colors.modes.light.borderPrimary (borders)",
-      "colors.modes.light.actionPrimary (interactive elements)"
-    );
-  }
-  
-  // Spacing → Use flat spacing tokens (spacing.xs, spacing.md, etc.)
-  if (primitivePath.startsWith("spacing.")) {
-    suggestions.push(
-      "Use spacing tokens (spacing.xs, spacing.sm, spacing.md, spacing.lg, etc.)",
-      "These resolve to CSS variables automatically"
-    );
-  }
-  
-  // Typography fontSize → TypeSets
-  if (primitivePath.startsWith("typography.fontSize.")) {
-    suggestions.push(
-      "typography.typeSets.title-lg (large titles)",
-      "typography.typeSets.title-md (medium titles)",
-      "typography.typeSets.text-normal-regular (body text)",
-      "typography.typeSets.label-md (form labels)"
-    );
-  }
-  
-  // Radius → Use flat radius tokens (radius.sm, radius.md, etc.)
-  if (primitivePath.startsWith("radius.")) {
-    suggestions.push(
-      "Use radius tokens (radius.sm, radius.md, radius.lg, radius.full, etc.)",
-      "Describe semantic usage in AI guidance (e.g., 'Buttons use @radius.md')"
-    );
-  }
-  
-  // Shadow elevation → Use elevation keys
-  if (primitivePath.startsWith("shadows.elevation.")) {
-    suggestions.push(
-      "Use elevation keys (none, sm, md, lg, xl) in component defaults",
-      "These resolve to CSS variables automatically"
-    );
-  }
-  
-  return suggestions;
-}
-
-function validateValue(value: string, context: string): {
-  valid: boolean;
-  issue?: string;
-  suggestion?: string;
-  matchingTokens?: Array<{ path: string; value: unknown; cssVariable: string }>;
-} {
-  // Check for hex colors
-  if (/^#[0-9A-Fa-f]{3,8}$/.test(value)) {
-    const allTokens = flattenTokens(primitives);
-    const matches = Object.entries(allTokens)
-      .filter(([path, v]) => {
-        if (typeof v !== "string") return false;
-        return v.toLowerCase() === value.toLowerCase();
-      })
-      .map(([path, v]) => ({
-        path,
-        value: v,
-        cssVariable: getCssVariableName(path),
-      }));
-    
-    if (matches.length > 0) {
-      return {
-        valid: false,
-        issue: "Hardcoded hex color detected",
-        suggestion: `Use token instead: ${matches[0].cssVariable}`,
-        matchingTokens: matches,
-      };
-    }
-    
-    return {
-      valid: false,
-      issue: "Hardcoded hex color with no matching token",
-      suggestion: "Check colors.static, colors.scales, or colors.modes for appropriate tokens",
-    };
-  }
-
-  // Check for rgb/rgba/hsl colors
-  if (/^(rgb|rgba|hsl|hsla)\(/.test(value)) {
-    return {
-      valid: false,
-      issue: "Hardcoded color function detected",
-      suggestion: "Use CSS variable: var(--atomix-colors-*) or primitives.colors.*",
-    };
-  }
-
-  // Check for pixel values in spacing context
-  if (context === "spacing" && /^\d+px$/.test(value)) {
-    return {
-      valid: false,
-      issue: "Hardcoded pixel value for spacing",
-      suggestion: "Use spacing.* tokens (e.g., @spacing.md, @spacing.lg)",
-    };
-  }
-
-  // Check for pixel values in any context
-  if (/^\d+px$/.test(value)) {
-    return {
-      valid: false,
-      issue: "Hardcoded pixel value detected",
-      suggestion: "Consider using design tokens from spacing, sizing, or typography",
-    };
-  }
-
-  // Check for Tailwind arbitrary values
-  if (/\[.*\]/.test(value)) {
-    return {
-      valid: false,
-      issue: "Tailwind arbitrary value detected",
-      suggestion: "Replace with token-based class or CSS variable",
-    };
-  }
-
-  return { valid: true };
-}
-
-// ============================================
-// START SERVER
-// ============================================
-
-// Global primitives reference (loaded on startup)
-let primitives: Record<string, unknown> = {};
-
-// Global governance reference (for user DS mode)
-let userGovernance: { rules: string[]; categories?: Record<string, string[]> } | undefined;
-
-// Global DS mode flag
-let isUserMode = false;
-let userDsId: string | undefined;
-
-async function main() {
-  // Parse CLI arguments
-  const cliArgs = parseCLIArgs();
-  
-  if (isUserDSMode(cliArgs)) {
-    // User DS mode: fetch tokens from Atomix API
-    console.error(`[atomix-mcp] User DS mode: loading design system ${cliArgs.dsId}`);
-    isUserMode = true;
-    userDsId = cliArgs.dsId;
-    
-    const result = await fetchUserDesignSystem({
-      dsId: cliArgs.dsId!,
-      apiKey: cliArgs.apiKey,
-      baseUrl: cliArgs.baseUrl,
-    });
-    
-    if (!result.success || !result.tokens) {
-      console.error(`[atomix-mcp] Failed to load user DS: ${result.error}`);
-      console.error("[atomix-mcp] Falling back to Atomix internal tokens");
-      
-      // Fallback to internal tokens
-      primitives = await loadPrimitives();
-    } else {
-      // Transform user tokens to MCP-compatible format
-      primitives = transformUserTokens(result.tokens);
-      userGovernance = result.governance;
-      
-      // Display startup summary
-      const meta = result.meta;
-      const dsName = meta?.name || cliArgs.dsId;
-      const tokenCategories = Object.keys(primitives);
-      const rulesCount = userGovernance?.rules?.length || 0;
-      
-      console.error("");
-      console.error(`[atomix-mcp] ========================================`);
-      console.error(`[atomix-mcp]  Design System: ${dsName}`);
-      console.error(`[atomix-mcp] ----------------------------------------`);
-      
-      // Show publish info
-      if (meta?.publishedAt) {
-        const publishedDate = new Date(meta.publishedAt);
-        const timeAgo = formatTimeAgo(meta.publishedAt);
-        console.error(`[atomix-mcp]  Published: ${timeAgo}`);
-        console.error(`[atomix-mcp]            (${publishedDate.toLocaleString()})`);
-      }
-      if (meta?.version) {
-        console.error(`[atomix-mcp]  Version: ${meta.version}`);
-      }
-      
-      console.error(`[atomix-mcp] ----------------------------------------`);
-      console.error(`[atomix-mcp]  Tokens: ${tokenCategories.length} categories`);
-      console.error(`[atomix-mcp]          ${tokenCategories.join(", ")}`);
-      console.error(`[atomix-mcp]  Rules: ${rulesCount} governance rules`);
-      console.error(`[atomix-mcp] ========================================`);
-      console.error("");
-    }
-  } else {
-    // Standard mode: load Atomix internal primitives
-    console.error("[atomix-mcp] Loading Atomix internal primitives...");
-    primitives = await loadPrimitives();
-    console.error(`[atomix-mcp] Loaded ${Object.keys(primitives).length} token categories`);
-  }
-  
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  
-  console.error("[atomix-mcp] Atomix MCP server started");
-  if (isUserMode) {
-    console.error(`[atomix-mcp] Serving design system: ${userDsId}`);
-  }
-}
-
-main().catch((error) => {
-  console.error("[atomix-mcp] Fatal error:", error);
-  process.exit(1);
-});
-
-// ============================================
-// EXPORTS (for programmatic use)
-// ============================================
-
-export {
-  // AI rules generator functions
-  generateCursorRules,
-  generateRulesForTool,
-  generateRulesForAllTools,
-  getSupportedAITools,
-  generateToolSetupGuide,
-  generateMCPConfig,
-  generateAllMCPConfigs,
-  getSetupInstructions,
-  AI_TOOLS,
-  // User tokens functions
-  parseCLIArgs,
-  isUserDSMode,
-  fetchUserDesignSystem,
-  transformUserTokens,
-  // Types
-  type AIToolId,
-  type MCPConfigToolId,
-};
-