npm - @atomixstudio/mcp - Versions diffs - 1.0.7 → 1.0.9 - Mend

@atomixstudio/mcp 1.0.7 → 1.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -11,27 +11,34 @@ import {
   ListPromptsRequestSchema,
   GetPromptRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import * as fs from "fs";
+import {
+  fetchDesignSystem,
+  getTokenByPath,
+  flattenTokens,
+  searchTokens,
+  getTokenStats,
+  compareDesignSystems,
+  generateCSSOutput,
+  generateSCSSOutput,
+  generateLessOutput,
+  generateJSONOutput,
+  generateTSOutput,
+  generateJSOutput,
+  generateSwiftOutput,
+  generateKotlinOutput,
+  generateDartOutput,
+  diffTokens,
+  formatSyncResponse,
+  detectGovernanceChangesByFoundation,
+  syncRulesFiles
+} from "@atomixstudio/sync-core";
 import * as path from "path";
-import * as readline from "readline";
+import * as fs from "fs";
 function parseArgs() {
   const args = process.argv.slice(2);
-  let command = "server";
   let dsId2 = null;
   let apiKey2 = null;
   let apiBase2 = null;
-  let output = null;
-  let format = null;
-  let exclude = [];
-  let yes = false;
-  let rules = null;
-  let rulesDir = null;
-  if (args[0] && !args[0].startsWith("-")) {
-    const cmd = args[0].toLowerCase();
-    if (cmd === "sync") command = "sync";
-    else if (cmd === "init") command = "init";
-    else if (cmd === "help" || cmd === "--help" || cmd === "-h") command = "help";
-  }
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--ds-id" && args[i + 1]) {
       dsId2 = args[i + 1];
@@ -42,125 +49,51 @@ function parseArgs() {
     } else if (args[i] === "--api-base" && args[i + 1]) {
       apiBase2 = args[i + 1];
       i++;
-    } else if ((args[i] === "--output" || args[i] === "-o") && args[i + 1]) {
-      output = args[i + 1];
-      i++;
-    } else if (args[i] === "--format" && args[i + 1]) {
-      const f = args[i + 1].toLowerCase();
-      const validFormats = ["css", "scss", "less", "json", "ts", "js", "swift", "kotlin", "dart"];
-      if (validFormats.includes(f)) format = f;
-      i++;
-    } else if (args[i] === "--exclude" && args[i + 1]) {
-      exclude.push(args[i + 1]);
-      i++;
-    } else if (args[i] === "-y" || args[i] === "--yes") {
-      yes = true;
-    } else if (args[i] === "--rules" || args[i] === "-r") {
-      rules = true;
-    } else if (args[i] === "--no-rules") {
-      rules = false;
-    } else if (args[i] === "--rules-dir" && args[i + 1]) {
-      rulesDir = args[i + 1];
-      rules = true;
-      i++;
     }
   }
-  const effectiveRules = rules !== null ? rules : command === "sync";
-  return { command, dsId: dsId2, apiKey: apiKey2, apiBase: apiBase2, output, format, exclude, yes, rules: effectiveRules, rulesDir };
+  return { dsId: dsId2, apiKey: apiKey2, apiBase: apiBase2 };
 }
 var cliArgs = parseArgs();
 var { dsId, apiKey } = cliArgs;
 var apiBase = cliArgs.apiBase || "https://atomixstudio.eu";
 var cachedData = null;
-async function fetchDesignSystem() {
-  if (cachedData) return cachedData;
-  if (!dsId) {
-    throw new Error("Missing --ds-id argument. Usage: npx @atomixstudio/mcp --ds-id <id> --api-key <key>");
-  }
-  const url = `${apiBase}/api/ds/${dsId}/tokens?format=export`;
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  const response = await fetch(url, { headers });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Failed to fetch design system: ${response.status} ${text}`);
-  }
-  const data = await response.json();
-  cachedData = data;
-  return data;
-}
-var TOKEN_CATEGORIES = ["colors", "typography", "spacing", "sizing", "shadows", "radius", "borders", "motion", "zIndex"];
-function getTokenByPath(tokens, path2) {
-  const parts = path2.split(".");
-  let current = tokens;
-  for (const part of parts) {
-    if (current && typeof current === "object" && part in current) {
-      current = current[part];
-    } else {
-      return void 0;
-    }
-  }
-  return current;
+var cachedETag = null;
+var lastChangeSummary = null;
+var lastSyncAffectedTokens = null;
+function getLastChangeSummary() {
+  return lastChangeSummary;
 }
-function flattenTokens(obj, prefix = "") {
-  const results = [];
-  if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-    for (const [key, value] of Object.entries(obj)) {
-      const newPath = prefix ? `${prefix}.${key}` : key;
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        results.push(...flattenTokens(value, newPath));
-      } else {
-        results.push({ path: newPath, value });
-      }
+async function updateChangeSummary(freshData) {
+  if (cachedData) {
+    const changes = compareDesignSystems(cachedData, freshData);
+    lastChangeSummary = changes.summary;
+    if (changes.hasChanges) {
+      console.error(`[mcp-user] Design system changes detected:
+${changes.summary}`);
     }
   }
-  return results;
 }
-function searchTokens(tokens, query) {
-  const flat = flattenTokens(tokens);
-  const lowerQuery = query.toLowerCase();
-  return flat.filter(({ path: path2, value }) => {
-    const pathMatch = path2.toLowerCase().includes(lowerQuery);
-    const valueMatch = String(value).toLowerCase().includes(lowerQuery);
-    return pathMatch || valueMatch;
+async function fetchDesignSystemForMCP(forceRefresh = false) {
+  if (!dsId) throw new Error("Missing --ds-id. Usage: npx @atomixstudio/mcp --ds-id <id>");
+  const result = await fetchDesignSystem({
+    dsId,
+    apiKey: apiKey ?? void 0,
+    apiBase: apiBase ?? void 0,
+    etag: forceRefresh ? void 0 : cachedETag ?? void 0,
+    forceRefresh
   });
+  if (result.status === 304 && cachedData) return cachedData;
+  if (result.status === 304 || !result.data) throw new Error("No design system data (304 or null)");
+  cachedData = result.data;
+  cachedETag = result.etag;
+  await updateChangeSummary(result.data);
+  return result.data;
 }
-function countTokens(tokens, prefix = "") {
-  let count = 0;
-  for (const [key, value] of Object.entries(tokens)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      count += countTokens(value, `${prefix}${key}.`);
-    } else if (value !== void 0 && value !== null) {
-      count++;
-    }
-  }
-  return count;
-}
-function getTokenStats(data) {
-  const byCategory = {};
-  let total = 0;
-  for (const [category, value] of Object.entries(data.tokens)) {
-    if (value && typeof value === "object") {
-      const count = countTokens(value);
-      byCategory[category] = count;
-      total += count;
-    }
-  }
-  return {
-    total,
-    byCategory,
-    cssVariables: Object.keys(data.cssVariables).length,
-    governanceRules: data.governance.rules.length
-  };
-}
+var TOKEN_CATEGORIES = ["colors", "typography", "spacing", "sizing", "shadows", "radius", "borders", "motion", "zIndex"];
 var server = new Server(
   {
     name: "atomix-mcp-user",
-    version: "1.0.0"
+    version: "1.0.9"
   },
   {
     capabilities: {
@@ -286,7 +219,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "syncTokens",
-        description: "Sync design tokens to a local file. Creates or updates a tokens file with the latest values from your design system. Returns a diff of changes.",
+        description: "Sync design tokens to a local file. Safe, never breaks UI - adds new tokens, updates existing values, marks deprecated tokens. Use /refactor to migrate deprecated tokens. WARNING: The output file is completely rewritten - only CSS custom properties (variables) are preserved. Custom CSS rules will be lost. Keep custom CSS in a separate file.",
         inputSchema: {
           type: "object",
           properties: {
@@ -302,6 +235,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ["output"]
         }
+      },
+      {
+        name: "getDependencies",
+        description: "Get suggested dependencies for this design system (icon package, fonts, SKILL.md, MCP config, token files). Use with atomix/install. Optional platform and stack for tailored suggestions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            platform: {
+              type: "string",
+              enum: ["web", "ios", "android"],
+              description: "Target platform (web, ios, android). Optional."
+            },
+            stack: {
+              type: "string",
+              description: "Stack or framework (e.g. react, vue, next, swift, kotlin). Optional."
+            }
+          },
+          required: []
+        }
       }
     ]
   };
@@ -309,7 +261,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
-    const data = await fetchDesignSystem();
+    const shouldForceRefresh = name === "syncTokens";
+    const data = await fetchDesignSystemForMCP(shouldForceRefresh);
     switch (name) {
       case "getToken": {
         const path2 = args?.path;
@@ -359,16 +312,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           };
         }
         const flat = flattenTokens(tokensToList);
+        const tokensWithCssVars = flat.map(({ path: path2, value }) => {
+          const fullPath = subcategory ? `${category}.${subcategory}.${path2}` : `${category}.${path2}`;
+          let cssVar;
+          if (category === "colors" && subcategory === "static.brand") {
+            cssVar = data.cssVariables[`--atmx-color-brand-${path2}`];
+          } else if (category === "colors" && subcategory?.startsWith("modes.")) {
+            cssVar = data.cssVariables[`--atmx-color-${path2}`];
+          } else {
+            const cssVarKey = `--atmx-${fullPath.replace(/\./g, "-")}`;
+            cssVar = data.cssVariables[cssVarKey];
+          }
+          return {
+            path: fullPath,
+            value,
+            cssVariable: cssVar || void 0
+          };
+        });
         return {
           content: [{
             type: "text",
             text: JSON.stringify({
               category,
               subcategory,
-              count: flat.length,
-              tokens: flat.slice(0, 50),
+              count: tokensWithCssVars.length,
+              tokens: tokensWithCssVars.slice(0, 50),
               // Limit to 50 for readability
-              truncated: flat.length > 50
+              truncated: tokensWithCssVars.length > 50
             }, null, 2)
           }]
         };
@@ -529,43 +499,114 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 1. Create \`.cursor/mcp.json\` in your project root
 2. Add the MCP configuration (use exportMCPConfig to get it)
 3. Restart Cursor IDE
-4. Verify by asking: "What design tokens are available?"`,
-          copilot: `# GitHub Copilot Setup
+4. Verify by asking: "What design tokens are available?"
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
-1. Create \`.github/copilot-instructions.md\` in your project
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
+          copilot: `# Copilot Setup
+1. Create a Copilot instructions file in your project (e.g. \`.github/copilot-instructions.md\`)
 2. Use getAIToolRules({ tool: "copilot" }) to get the content
-3. Enable custom instructions in VS Code settings:
-   "github.copilot.chat.codeGeneration.useInstructionFiles": true`,
+3. Enable custom instructions in your editor (e.g. \`github.copilot.chat.codeGeneration.useInstructionFiles\`: true in settings)
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           windsurf: `# Windsurf Setup
 1. Create \`.windsurf/mcp.json\` in your project root
 2. Create \`.windsurfrules\` with rules from getAIToolRules
-3. Restart Windsurf Editor`,
+3. Restart Windsurf Editor
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           cline: `# Cline Setup
 1. Create \`.clinerules\` in your project root
-2. Cline auto-detects MCP from .cursor/mcp.json`,
+2. Cline auto-detects MCP from .cursor/mcp.json
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           continue: `# Continue Setup
 1. Create/edit \`.continue/config.json\`
 2. Add mcpServers configuration
-3. Restart VS Code`,
+3. Restart VS Code
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           zed: `# Zed Setup
 1. Create \`.zed/assistant/rules.md\` in your project
-2. Use getAIToolRules({ tool: "zed" }) for content`,
+2. Use getAIToolRules({ tool: "zed" }) for content
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           "claude-desktop": `# Claude Desktop Setup
 1. Find your Claude config:
    - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    - Windows: %APPDATA%\\Claude\\claude_desktop_config.json
 2. Add MCP server configuration
-3. Restart Claude Desktop`,
+3. Restart Claude Desktop
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`,
           generic: `# Generic AI Tool Setup
 1. Create AI_GUIDELINES.md in your project root
 2. Use getAIToolRules({ tool: "generic" }) for content
-3. Reference in your prompts or context`
+3. Reference in your prompts or context
+## File Structure
+\u26A0\uFE0F **IMPORTANT**: The \`tokens.css\` file (or your specified output file) is **completely rewritten** on each sync.
+- \u2705 **Preserved**: CSS custom properties (variables) - both design system tokens and custom variables
+- \u274C **Lost**: Regular CSS rules (selectors, classes, media queries, etc.)
+**Best Practice**: Keep \`tokens.css\` separate from your custom CSS. Use a separate file (e.g., \`custom.css\`) for custom styles.`
         };
         const instruction = instructions[tool];
         if (!instruction) {
@@ -597,17 +638,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }]
           };
         }
+        const outputPath = path.resolve(process.cwd(), output);
+        const fileExists = fs.existsSync(outputPath);
+        const deprecatedTokens = /* @__PURE__ */ new Map();
+        const existingTokens = /* @__PURE__ */ new Map();
+        if (fileExists && ["css", "scss", "less"].includes(format)) {
+          const oldContent = fs.readFileSync(outputPath, "utf-8");
+          const oldVarPattern = /(?:^|\n)\s*(?:\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?(--[a-zA-Z0-9-]+):\s*([^;]+);/gm;
+          let match;
+          while ((match = oldVarPattern.exec(oldContent)) !== null) {
+            const varName = match[1];
+            const varValue = match[2].trim();
+            existingTokens.set(varName, varValue);
+            if (!(varName in data.cssVariables)) {
+              deprecatedTokens.set(varName, varValue);
+            }
+          }
+        }
+        const mergedCssVariables = { ...data.cssVariables };
         const darkModeColors = data.tokens?.colors?.modes;
         let newContent;
         switch (format) {
           case "css":
-            newContent = generateCSSOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateCSSOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           case "scss":
-            newContent = generateSCSSOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateSCSSOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           case "less":
-            newContent = generateLessOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateLessOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           case "json":
             newContent = generateJSONOutput(data.tokens);
@@ -619,29 +678,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             newContent = generateTSOutput(data.tokens);
             break;
           case "swift":
-            newContent = generateSwiftOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateSwiftOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           case "kotlin":
-            newContent = generateKotlinOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateKotlinOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           case "dart":
-            newContent = generateDartOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateDartOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
             break;
           default:
-            newContent = generateCSSOutput(data.cssVariables, darkModeColors?.dark);
+            newContent = generateCSSOutput(mergedCssVariables, darkModeColors?.dark, deprecatedTokens);
         }
-        const outputPath = path.resolve(process.cwd(), output);
-        const fileExists = fs.existsSync(outputPath);
-        const tokenCount = Object.keys(data.cssVariables).length;
+        const tokenCount = Object.keys(mergedCssVariables).length;
+        const dsTokenCount = Object.keys(data.cssVariables).length;
+        const deprecatedCount = deprecatedTokens.size;
         let diffSummary = "";
         let changes = [];
+        let diff;
         if (fileExists && ["css", "scss", "less"].includes(format)) {
           const oldContent = fs.readFileSync(outputPath, "utf-8");
-          const diff = diffTokens(oldContent, data.cssVariables, format, darkModeColors?.dark);
-          const lightChanges = diff.added.length + diff.modified.length + diff.removed.length;
-          const darkChanges = diff.addedDark.length + diff.modifiedDark.length + diff.removedDark.length;
-          const totalChanges = lightChanges + darkChanges;
+          diff = diffTokens(oldContent, mergedCssVariables, format, darkModeColors?.dark);
+          const lightChanges = diff.added.length + diff.modified.length;
+          const darkChanges = diff.addedDark.length + diff.modifiedDark.length;
+          const totalChanges = lightChanges + darkChanges + deprecatedCount;
           if (totalChanges === 0) {
+            const lastUpdated = data.meta.exportedAt ? new Date(data.meta.exportedAt).toLocaleString() : "N/A";
             return {
               content: [{
                 type: "text",
@@ -649,40 +710,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 File: ${output}
 Tokens: ${tokenCount}
-Version: ${data.meta.version}`
+Version: ${data.meta.version}
+Last updated: ${lastUpdated}`
               }]
             };
           }
           changes = [...diff.modified, ...diff.modifiedDark];
-          const lightSummary = lightChanges > 0 ? `Light: ${diff.modified.length} modified, ${diff.added.length} added, ${diff.removed.length} removed` : "";
-          const darkSummary = darkChanges > 0 ? `Dark: ${diff.modifiedDark.length} modified, ${diff.addedDark.length} added, ${diff.removedDark.length} removed` : "";
-          diffSummary = [lightSummary, darkSummary].filter(Boolean).join(" | ");
+          const lightSummary = lightChanges > 0 ? `Light: ${diff.modified.length} modified, ${diff.added.length} added` : "";
+          const darkSummary = darkChanges > 0 ? `Dark: ${diff.modifiedDark.length} modified, ${diff.addedDark.length} added` : "";
+          const deprecatedSummary = deprecatedCount > 0 ? `${deprecatedCount} deprecated (use /refactor)` : "";
+          diffSummary = [lightSummary, darkSummary, deprecatedSummary].filter(Boolean).join(" | ");
+          const removedTokensWithValues = [];
+          for (const [token, value] of deprecatedTokens.entries()) {
+            removedTokensWithValues.push({ token, lastValue: value });
+          }
+          lastSyncAffectedTokens = {
+            modified: [...diff.modified, ...diff.modifiedDark].map((m) => ({
+              token: m.key,
+              oldValue: m.old,
+              newValue: m.new
+            })),
+            removed: removedTokensWithValues,
+            added: [...diff.added, ...diff.addedDark],
+            format,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
         }
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
           fs.mkdirSync(outputDir, { recursive: true });
         }
         fs.writeFileSync(outputPath, newContent);
-        let response = `\u2713 Synced ${tokenCount} tokens to ${output}
-`;
-        response += `Format: ${format}
-`;
-        response += `Design System: ${data.meta.name} (v${data.meta.version})
-`;
-        if (diffSummary) {
-          response += `
-${diffSummary}
-`;
-          if (changes.length > 0 && changes.length <= 10) {
-            response += "\nModified tokens:\n";
-            for (const { key, old: oldVal, new: newVal } of changes) {
-              response += `  ${key}: ${oldVal} \u2192 ${newVal}
-`;
-            }
-          }
-        } else if (!fileExists) {
-          response += "\n(New file created)";
+        let rulesResults = [];
+        try {
+          rulesResults = await syncRulesFiles({
+            dsId,
+            apiKey: apiKey ?? void 0,
+            apiBase: apiBase ?? void 0,
+            rulesDir: process.cwd()
+          });
+        } catch (error) {
+          console.error(`[syncTokens] Failed to sync rules: ${error}`);
         }
+        const governanceChanges = cachedData ? detectGovernanceChangesByFoundation(cachedData, data) : [];
+        const response = formatSyncResponse({
+          data,
+          output,
+          format,
+          dsTokenCount,
+          deprecatedCount,
+          deprecatedTokens,
+          diff,
+          changes,
+          fileExists,
+          rulesResults,
+          governanceChanges,
+          changeSummary: getLastChangeSummary(),
+          hasRefactorRecommendation: !!lastSyncAffectedTokens?.removed.length,
+          deprecatedTokenCount: lastSyncAffectedTokens?.removed.length || 0
+        });
         return {
           content: [{
             type: "text",
@@ -690,55 +776,210 @@ ${diffSummary}
           }]
         };
       }
+      case "getDependencies": {
+        const platform = args?.platform;
+        const stack = args?.stack;
+        const tokens = data.tokens;
+        const typography = tokens?.typography;
+        const fontFamily = typography?.fontFamily;
+        const fontNames = [];
+        if (fontFamily) {
+          for (const key of ["display", "heading", "body"]) {
+            const v = fontFamily[key];
+            if (typeof v === "string" && v && !fontNames.includes(v)) fontNames.push(v);
+          }
+        }
+        const icons = tokens?.icons;
+        const ICON_PACKAGES = {
+          lucide: { web: "lucide-react", native: "lucide-react-native" },
+          heroicons: { web: "@heroicons/react", native: "heroicons-react-native" },
+          phosphor: { web: "phosphor-react", native: "phosphor-react-native" }
+        };
+        const lib = icons?.library || "lucide";
+        const iconPkgs = ICON_PACKAGES[lib] || ICON_PACKAGES.lucide;
+        const serverName = data.meta.name.toLowerCase().replace(/[^a-z0-9]/g, "-");
+        const npxArgs = ["@atomixstudio/mcp@latest"];
+        if (dsId) npxArgs.push("--ds-id", dsId);
+        if (apiKey) npxArgs.push("--api-key", apiKey);
+        const mcpConfig = {
+          path: ".cursor/mcp.json",
+          content: JSON.stringify({
+            mcpServers: {
+              [serverName]: { command: "npx", args: npxArgs }
+            }
+          }, null, 2)
+        };
+        const payload = {
+          iconLibrary: {
+            package: iconPkgs.web,
+            nativePackage: iconPkgs.native,
+            performanceHint: "Use individual SVG imports for tree-shaking; avoid loading entire icon libraries or icon fonts."
+          },
+          fonts: {
+            families: fontNames,
+            performanceHint: "Implement self-hosted fonts and local @font-face declarations; avoid external CDN links; use font-display: swap."
+          },
+          skill: {
+            path: ".cursor/skills/atomix-ds/SKILL.md",
+            content: GENERIC_SKILL_MD
+          },
+          mcpConfig,
+          tokenFiles: {
+            files: ["tokens.css", "tokens.json"],
+            copyInstructions: "Copy tokens.css and tokens.json from the design system export (or use syncTokens) into your project."
+          },
+          meta: { dsName: data.meta.name, platform: platform ?? void 0, stack: stack ?? void 0 }
+        };
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(payload, null, 2)
+          }]
+        };
+      }
       default:
         return {
           content: [{
             type: "text",
             text: JSON.stringify({
               error: `Unknown tool: ${name}`,
-              availableTools: ["getToken", "listTokens", "searchTokens", "validateUsage", "getAIToolRules", "exportMCPConfig", "getSetupInstructions", "syncTokens"]
+              availableTools: ["getToken", "listTokens", "searchTokens", "validateUsage", "getAIToolRules", "exportMCPConfig", "getSetupInstructions", "syncTokens", "getDependencies"]
             }, null, 2)
           }]
         };
     }
   } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    let suggestion = "Check your MCP server configuration.";
+    if (errorMessage.includes("Missing --ds-id")) {
+      suggestion = "Add --ds-id <your-design-system-id> to your MCP server configuration.";
+    } else if (errorMessage.includes("Failed to fetch")) {
+      const statusMatch = errorMessage.match(/Failed to fetch design system: (\d+)/);
+      if (statusMatch) {
+        const status = statusMatch[1];
+        if (status === "404") {
+          suggestion = `Design system ID "${dsId}" not found. Verify the ID is correct or the design system has been published.`;
+        } else if (status === "401" || status === "403") {
+          suggestion = "Design system is private. Add --api-key <your-key> to your MCP server configuration.";
+        } else {
+          suggestion = `API request failed (${status}). Check your network connection and API base URL (${apiBase}).`;
+        }
+      } else {
+        suggestion = `Failed to connect to API at ${apiBase}. Check your network connection.`;
+      }
+    }
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          error: error instanceof Error ? error.message : "Unknown error",
-          suggestion: "Make sure --ds-id and --api-key are correct."
+          error: errorMessage,
+          suggestion,
+          configured: {
+            dsId: dsId || "not set",
+            apiBase: apiBase || "not set",
+            hasApiKey: !!apiKey
+          }
         }, null, 2)
       }],
       isError: true
     };
   }
 });
+var GENERIC_SKILL_MD = `---
+name: atomix-ds
+description: Use this design system when editing UI, design system files, or when the user asks to follow the project's design system. Fetch rules dynamically via MCP.
+---
+# Atomix Design System
+## When to use
+- Editing UI components, pages, or styles
+- Working in design system or token files
+- User asks to follow the project's design system
+## How to use
+1. Call MCP tool **getAIToolRules** with the tool id that matches your **current AI coding environment**:
+   - **cursor** (Cursor IDE)
+   - **windsurf** (Windsurf)
+   - **copilot** (Copilot)
+   - **cline** (Cline)
+   - **continue** (Continue)
+   - **zed** (Zed)
+   - **generic** (other tools)
+   Example: \`getAIToolRules({ tool: "cursor" })\` when in Cursor.
+2. Alternatively use the **design-system-rules** prompt or the resource \`atomix://rules/<tool>\` with the same tool id.
+3. Apply the returned rules (tokens, governance) when generating or editing code.
+4. Ensure Atomix MCP is configured with the project's \`--ds-id\` (config path varies by platform: e.g. \`.cursor/mcp.json\`, \`.windsurf/mcp.json\`).
+`;
 var AI_TOOLS = ["cursor", "copilot", "windsurf", "cline", "continue", "zed", "generic"];
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  const data = await fetchDesignSystem();
-  const stats = getTokenStats(data);
-  const resources = [
-    {
-      uri: "atomix://welcome",
-      name: `Welcome to ${data.meta.name}`,
-      description: `Design system overview with ${stats.total} tokens and ${stats.governanceRules} governance rules`,
-      mimeType: "text/markdown"
-    },
-    ...AI_TOOLS.map((tool) => ({
-      uri: `atomix://rules/${tool}`,
-      name: `${tool.charAt(0).toUpperCase() + tool.slice(1)} Rules`,
-      description: `Design system rules file for ${tool}`,
-      mimeType: "text/markdown"
-    }))
-  ];
-  return { resources };
+  try {
+    const data = await fetchDesignSystemForMCP();
+    const stats = getTokenStats(data);
+    const resources = [
+      {
+        uri: "atomix://hello",
+        name: `Welcome to ${data.meta.name}`,
+        description: `Design system overview with ${stats.total} tokens and ${stats.governanceRules} governance rules`,
+        mimeType: "text/markdown"
+      },
+      ...AI_TOOLS.map((tool) => ({
+        uri: `atomix://rules/${tool}`,
+        name: `${tool.charAt(0).toUpperCase() + tool.slice(1)} Rules`,
+        description: `Design system rules file for ${tool}`,
+        mimeType: "text/markdown"
+      }))
+    ];
+    return { resources };
+  } catch {
+    return {
+      resources: [
+        {
+          uri: "atomix://setup",
+          name: "Configure MCP",
+          description: "Add --ds-id to your MCP config to load design system resources",
+          mimeType: "text/markdown"
+        }
+      ]
+    };
+  }
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   const { uri } = request.params;
-  const data = await fetchDesignSystem();
+  if (uri === "atomix://setup") {
+    return {
+      contents: [{
+        uri,
+        mimeType: "text/markdown",
+        text: `# Configure Atomix MCP
+Add \`--ds-id <your-design-system-id>\` to your MCP server config.
+Example (\`.cursor/mcp.json\`):
+\`\`\`json
+{
+  "mcpServers": {
+    "atomix": {
+      "command": "npx",
+      "args": ["@atomixstudio/mcp@latest", "--ds-id", "<your-ds-id>"]
+    }
+  }
+}
+\`\`\`
+Get your DS ID from: https://atomixstudio.eu/ds/[your-ds-id]`
+      }]
+    };
+  }
+  const data = await fetchDesignSystemForMCP();
   const stats = getTokenStats(data);
-  if (uri === "atomix://welcome") {
+  if (uri === "atomix://hello") {
     const welcome = generateWelcomeMessage(data, stats);
     return {
       contents: [{
@@ -773,35 +1014,185 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   throw new Error(`Unknown resource: ${uri}`);
 });
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
-  return {
-    prompts: [
-      {
-        name: "welcome",
-        description: "Get started with this design system - shows overview, available tokens, and tools. Run this first!"
-      },
-      {
-        name: "design-system-rules",
-        description: "Get the design system governance rules for your AI coding tool",
-        arguments: [
+  const prompts = [
+    {
+      name: "hello",
+      description: "Get started with this design system - shows overview, available tokens, and tools. Run this first!"
+    },
+    {
+      name: "design-system-rules",
+      description: "Get the design system governance rules for your AI coding tool",
+      arguments: [
+        {
+          name: "tool",
+          description: "AI tool to generate rules for (cursor, copilot, windsurf, cline, continue, zed, generic)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "spacing",
+      description: "List all spacing tokens with their values in a table format"
+    },
+    {
+      name: "radius",
+      description: "List all border radius tokens with their values in a table format"
+    },
+    {
+      name: "color",
+      description: "List all color tokens with light/dark mode values in a table format"
+    },
+    {
+      name: "typography",
+      description: "List all typography tokens with their values in a table format"
+    },
+    {
+      name: "shadow",
+      description: "List all shadow/elevation tokens with their values in a table format"
+    },
+    {
+      name: "border",
+      description: "List all border width tokens with their values in a table format"
+    },
+    {
+      name: "sizing",
+      description: "List all sizing tokens (height, icon) with their values in a table format"
+    },
+    {
+      name: "motion",
+      description: "List all motion tokens (duration, easing) with their values in a table format"
+    },
+    {
+      name: "sync",
+      description: "Sync design tokens (./tokens.css). Safe: Adds new tokens, updates existing values, marks deprecated tokens. Supports formats: css, scss, less, json, ts, js, swift, kotlin, dart. Use /refactor to migrate deprecated tokens."
+    },
+    {
+      name: "refactor",
+      description: "Migrate deprecated tokens in codebase. Scans for deprecated tokens marked by /sync and suggests replacements. Run after /sync to update code."
+    },
+    {
+      name: "install",
+      description: "Suggest dependencies for this design system (icons, fonts, SKILL.md, MCP config, tokens). Asks before installing. Run getDependencies then follow phased instructions.",
+      arguments: [
+        { name: "platform", description: "Target platform (web, ios, android). Optional; ask user if unknown.", required: false },
+        { name: "stack", description: "Stack or framework (e.g. react, vue, next, swift, kotlin). Optional.", required: false }
+      ]
+    }
+  ];
+  return { prompts };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const shouldForceRefresh = name === "sync";
+  let data = null;
+  let stats = null;
+  try {
+    data = await fetchDesignSystemForMCP(shouldForceRefresh);
+    stats = getTokenStats(data);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    if (errorMessage.includes("Missing --ds-id")) {
+      return {
+        description: "MCP Server Configuration Required",
+        messages: [
           {
-            name: "tool",
-            description: "AI tool to generate rules for (cursor, copilot, windsurf, cline, continue, zed, generic)",
-            required: false
+            role: "user",
+            content: {
+              type: "text",
+              text: `The MCP server isn't configured. To use design system prompts, you need to configure the server with:
+- \`--ds-id\`: Your design system ID (required - get it from https://atomixstudio.eu/ds/[your-ds-id])
+- \`--api-key\`: Your API key (optional - only needed for private design systems)
+**Note:** Most design systems are public and don't require an API key. Only add \`--api-key\` if your design system is private.
+Configure the MCP server in your Cursor settings, then restart Cursor.`
+            }
           }
         ]
+      };
+    } else if (errorMessage.includes("Failed to fetch")) {
+      const statusMatch = errorMessage.match(/Failed to fetch design system: (\d+) (.+)/);
+      const status = statusMatch ? statusMatch[1] : "unknown";
+      const details = statusMatch ? statusMatch[2] : errorMessage;
+      let helpText = `**Error:** Failed to fetch design system from ${apiBase}/api/ds/${dsId}/tokens
+`;
+      helpText += `**Status:** ${status}
+`;
+      helpText += `**Details:** ${details}
+`;
+      if (status === "404") {
+        helpText += `**Possible causes:**
+`;
+        helpText += `- Design system ID "${dsId}" doesn't exist
+`;
+        helpText += `- API base URL "${apiBase}" is incorrect
+`;
+        helpText += `- Design system hasn't been published yet
+`;
+        helpText += `**Solution:** Verify the design system ID and API base URL in your MCP server configuration.`;
+      } else if (status === "401" || status === "403") {
+        helpText += `**Possible causes:**
+`;
+        helpText += `- Design system is private and requires an API key
+`;
+        helpText += `- API key is invalid or expired
+`;
+        helpText += `**Solution:** Add \`--api-key <your-key>\` to your MCP server configuration.`;
+      } else {
+        helpText += `**Possible causes:**
+`;
+        helpText += `- Network connection issue
+`;
+        helpText += `- API server is down
+`;
+        helpText += `- CORS or firewall blocking the request
+`;
+        helpText += `**Solution:** Check your network connection and verify the API base URL is accessible.`;
       }
-    ]
+      return {
+        description: "Design System Fetch Failed",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: helpText
+            }
+          }
+        ]
+      };
+    }
+    throw error;
+  }
+  const buildCategoryPrompt = (category, instructions) => {
+    const lines = [];
+    lines.push(`## Design System Information`);
+    lines.push(`- **Name**: ${data.meta.name}`);
+    lines.push(`- **Version**: ${data.meta.version || "1.0.0"}`);
+    lines.push(`- **Last Published**: ${data.meta.exportedAt ? new Date(data.meta.exportedAt).toLocaleDateString() : "N/A"}`);
+    lines.push(``);
+    const categoryRules = data.governance.categories?.[category];
+    if (categoryRules && categoryRules.length > 0) {
+      lines.push(`## AI Rules for ${category.charAt(0).toUpperCase() + category.slice(1)}`);
+      categoryRules.forEach((rule, index) => {
+        lines.push(`${index + 1}. ${rule}`);
+      });
+      lines.push(``);
+    }
+    lines.push(`## Instructions`);
+    lines.push(instructions);
+    return lines.join("\n");
   };
-});
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  const data = await fetchDesignSystem();
-  const stats = getTokenStats(data);
   switch (name) {
-    case "welcome": {
+    case "hello": {
       const welcome = generateWelcomeMessage(data, stats);
       return {
-        description: `Welcome to ${data.meta.name} Design System`,
+        description: `Hello \u2014 ${data.meta.name} Design System`,
         messages: [
           {
             role: "user",
@@ -850,33 +1241,345 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
         ]
       };
     }
-    default:
-      throw new Error(`Unknown prompt: ${name}`);
-  }
-});
-function generateWelcomeMessage(data, stats) {
-  const toolsList = [
-    "getToken - Get a specific token by path",
-    "listTokens - List all tokens in a category",
-    "searchTokens - Search tokens by name or value",
-    "validateUsage - Check if a CSS value follows the design system",
-    "getAIToolRules - Generate AI coding rules for any tool",
-    "exportMCPConfig - Generate MCP config for AI tools",
-    "getSetupInstructions - Get setup guide for specific tools",
-    "syncTokens - Sync tokens to a local file (css, scss, swift, kotlin, dart, etc.)"
-  ];
-  const categoryBreakdown = Object.entries(stats.byCategory).map(([cat, count]) => `  - ${cat}: ${count} tokens`).join("\n");
-  const asciiArt = `
-\`\`\`
-                               \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                            \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                          \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                         \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                       \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                       \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                 \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-              \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-            \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+    case "spacing": {
+      const instructions = `List all spacing tokens in a table format. Use the listTokens tool with category "spacing" and subcategory "scale". Format the response as a markdown table with columns: Token Name | Value | CSS Variable. The Token Name should be in short format (e.g., "spacing.xs" instead of "spacing.scale.xs").`;
+      const response = {
+        description: "List all spacing tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("spacing", instructions)
+            }
+          }
+        ]
+      };
+      return response;
+    }
+    case "radius": {
+      const instructions = `List all border radius tokens in a table format. Use the listTokens tool with category "radius" and subcategory "scale". Format the response as a markdown table with columns: Token Name | Value | CSS Variable. The Token Name should be in short format (e.g., "radius.sm" instead of "radius.scale.sm").`;
+      return {
+        description: "List all border radius tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("radius", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "color": {
+      const instructions = `List all color tokens in a table format showing both light and dark mode values.
+First, call listTokens with category "colors" and subcategory "modes.light" to get light mode colors.
+Then, call listTokens with category "colors" and subcategory "modes.dark" to get dark mode colors.
+Also call listTokens with category "colors" and subcategory "static.brand" to get brand colors.
+Format the response as a markdown table with columns: Token Name | Light Mode Value | Dark Mode Value | CSS Variable.
+For brand colors (from static.brand), show the same value in both Light and Dark columns since brand colors don't change with mode.
+For semantic colors (from modes.light/modes.dark), match tokens by name and show their respective values.
+The Token Name should be in short format:
+- Brand colors: "colors.brand.primary" (not "colors.static.brand.primary")
+- Semantic colors: "colors.bgSurface" (not "colors.modes.light.bgSurface")`;
+      return {
+        description: "List all color tokens with light/dark mode",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("colors", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "typography": {
+      const instructions = `List all typography tokens in a table format. Use the listTokens tool with category "typography" (no subcategory needed). Format the response as a markdown table with columns: Token Name | Value | CSS Variable. Group tokens by type (fontSize, fontWeight, lineHeight, etc.) with section headers.`;
+      return {
+        description: "List all typography tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("typography", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "shadow": {
+      const instructions = `List all shadow/elevation tokens in a table format. Use the listTokens tool with category "shadows" and subcategory "elevation". Format the response as a markdown table with columns: Token Name | Value | CSS Variable. The Token Name should be in short format (e.g., "shadows.elevation.md" is fine as-is).`;
+      return {
+        description: "List all shadow/elevation tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("shadows", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "border": {
+      const instructions = `List all border width tokens in a table format. Use the listTokens tool with category "borders" and subcategory "width". Format the response as a markdown table with columns: Token Name | Value | CSS Variable. The Token Name should be in short format (e.g., "borders.width.sm" is fine as-is).`;
+      return {
+        description: "List all border width tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("borders", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "sizing": {
+      const instructions = `List all sizing tokens in a table format. Call listTokens twice:
+1. category "sizing" and subcategory "height" for component heights
+2. category "sizing" and subcategory "icon" for icon sizes
+Format the response as a markdown table with columns: Token Name | Value | CSS Variable. Group by type (height vs icon) with section headers.`;
+      return {
+        description: "List all sizing tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("sizing", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "motion": {
+      const instructions = `List all motion tokens in a table format. Call listTokens twice:
+1. category "motion" and subcategory "duration" for duration tokens
+2. category "motion" and subcategory "easing" for easing tokens
+Format the response as a markdown table with columns: Token Name | Value | CSS Variable. Group by type (duration vs easing) with section headers.`;
+      return {
+        description: "List all motion tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: buildCategoryPrompt("motion", instructions)
+            }
+          }
+        ]
+      };
+    }
+    case "sync": {
+      const output = args?.output || "./tokens.css";
+      const format = args?.format || "css";
+      const response = {
+        description: `Sync design tokens to ${output}`,
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Call the syncTokens tool now. Use output="${output}" and format="${format}". Execute immediately - do not search or ask questions.`
+            }
+          }
+        ]
+      };
+      return response;
+    }
+    case "refactor": {
+      if (!lastSyncAffectedTokens) {
+        return {
+          description: "Refactor codebase for deprecated tokens",
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `No recent sync data available. Please run \`/sync\` first to update your token file, then run \`/refactor\` to scan your codebase for deprecated token usage.`
+              }
+            }
+          ]
+        };
+      }
+      if (lastSyncAffectedTokens.removed.length === 0) {
+        return {
+          description: "Refactor codebase for deprecated tokens",
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `\u2713 No deprecated tokens found in last sync.
+Your codebase is up to date! The last sync on ${new Date(lastSyncAffectedTokens.timestamp).toLocaleString()} did not remove any tokens.`
+              }
+            }
+          ]
+        };
+      }
+      const format = lastSyncAffectedTokens.format;
+      const isNativeFormat = ["swift", "kotlin", "dart"].includes(format);
+      let searchPatterns = "";
+      let fileExtensions = "";
+      if (isNativeFormat) {
+        const nativeTokens = lastSyncAffectedTokens.removed.map((r) => {
+          const withoutPrefix = r.token.replace(/^--atmx-/, "");
+          const camelCase = withoutPrefix.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+          const pascalCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+          return { css: r.token, camel: camelCase, pascal: pascalCase, lastValue: r.lastValue };
+        });
+        if (format === "swift") {
+          fileExtensions = ".swift files";
+          searchPatterns = nativeTokens.map((t) => `  \u2022 \`DesignTokens.*.${t.camel}\` (was: ${t.lastValue})`).join("\n");
+        } else if (format === "kotlin") {
+          fileExtensions = ".kt files";
+          searchPatterns = nativeTokens.map((t) => `  \u2022 \`DesignTokens.*.${t.pascal}\` (was: ${t.lastValue})`).join("\n");
+        } else {
+          fileExtensions = ".dart files";
+          searchPatterns = nativeTokens.map((t) => `  \u2022 \`DesignTokens.${t.camel}\` (was: ${t.lastValue})`).join("\n");
+        }
+      } else {
+        fileExtensions = ".tsx, .ts, .jsx, .js, .css, .scss, .less, .vue, .svelte files";
+        searchPatterns = lastSyncAffectedTokens.removed.map(
+          (r) => `  \u2022 \`var(${r.token})\` or \`"${r.token}"\` (was: ${r.lastValue})`
+        ).join("\n");
+      }
+      const instructions = `Scan the codebase for deprecated design tokens and help update them.
+## Deprecated Tokens (${lastSyncAffectedTokens.removed.length})
+The following tokens have been removed from the design system:
+${searchPatterns}
+## Instructions
+1. **Search** for these patterns in ${fileExtensions}:
+   - Skip node_modules, dist, build, .next, .git directories
+   - Look for both \`var(--token)\` and direct string references
+2. **Report findings** in this format:
+   \`\`\`
+   \u{1F4C4} path/to/file.tsx
+      Line 42: background: var(--atmx-color-deprecated);
+      Line 78: const color = "--atmx-color-deprecated";
+   \`\`\`
+3. **After listing all findings**, ask:
+   > "Found X instances of deprecated tokens in Y files. Would you like me to update them?"
+   >
+   > For each deprecated token, I'll suggest the closest equivalent from the current design system.
+4. **If user confirms**:
+   - Show the proposed replacement for each instance
+   - Apply changes only after user approves
+   - For tokens with no clear replacement, ask user which token to use
+## Important
+- Do NOT make any changes without explicit user confirmation
+- Show before \u2192 after for each change
+- If you can't find a suitable replacement token, ask the user
+## Available Token Categories
+Use \`/color\`, \`/spacing\`, \`/radius\`, \`/typography\`, \`/shadow\`, \`/border\`, \`/sizing\`, \`/motion\` to see current tokens if you need to find replacements.`;
+      return {
+        description: "Refactor codebase for deprecated tokens",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: instructions
+            }
+          }
+        ]
+      };
+    }
+    case "install": {
+      const installInstructions = `You are running **atomix/install**. Follow these phases in order; do not skip any phase.
+## Phase 1 \u2013 Resolve platform and stack
+- If the project clearly indicates platform (e.g. package.json + web deps, or build.gradle / Android, or Xcode / iOS), infer \`platform\` (e.g. web, ios, android) and optionally \`stack\` (e.g. react, next, vue, swift, kotlin).
+- If the project gives **no hint** (blank repo, empty folder, or ambiguous): **Ask the user:** "Which platform are you building for? (e.g. web, Android, iOS)" and, if relevant, "Which stack or framework? (e.g. React, Vue, Next, Swift, Kotlin)." Do **not** assume web or any default.
+- Proceed only once platform (and optionally stack) is known or confirmed.
+## Phase 2 \u2013 Get suggested dependencies
+- Call MCP tool **getDependencies** with the resolved \`platform\` (and optional \`stack\`). Use the parameter names the tool expects (e.g. platform, stack).
+- If the call fails (e.g. MCP not connected or no ds-id), tell the user: "Atomix MCP is not connected or design system ID is missing. Configure MCP with --ds-id and try again."
+## Phase 3 \u2013 Scan codebase and build suggestion list
+- Scan the repo for: package.json (or equivalent), existing skill path (e.g. .cursor/skills), presence of tokens.css or project token file, font imports/config, icon package usage.
+- Build two lists: **Suggested dependencies** (from getDependencies, minus what is already present) and **Already present**. Include: icon package, fonts, SKILL path, MCP config, token files.
+- Do **not** install, copy, or write any file in this phase.
+## Phase 4 \u2013 Present list and ask before install
+- Reply with: "Suggested dependencies: \u2026" and "Already present: \u2026" and state: "Do not install or copy anything until you confirm. Would you like me to install or add these?"
+- If the user says yes, perform only the steps they approved. If no or only part, perform only that.
+## Phase 5 \u2013 Optional: suggest global styles (if missing)
+- After presenting the dependency list (Phase 4), or after the user has approved install, check whether the project has **global styles that use the design system tokens** (e.g. typography scale, semantic color classes, or theme file referencing DS tokens). If **not** (e.g. no globals.css using tokens, or blank project), ask the user **verbatim**:
+"Your project doesn't appear to have global styles that use the design system tokens (e.g. semantic typography scale or semantic color classes). Would you like me to suggest or generate a minimal set (e.g. typography scale + semantic utilities) so you can develop consistently with the DS?"
+- If the user says yes, suggest or generate a minimal set; do not overwrite existing global styles without confirmation.
+## Phase 6 \u2013 Report what was created
+- After any install or copy steps (and optional global-styles step), list **what was created or updated** (e.g. "Installed: lucide-react. Added: .cursor/skills/atomix-ds/SKILL.md. Updated: .cursor/mcp.json. Copied: tokens.css."). If global styles were added, include that.
+---
+Execute Phase 1 now (resolve or ask platform/stack), then Phase 2 (call getDependencies), then continue through Phase 6.`;
+      return {
+        description: "Suggest dependencies for this design system (atomix/install)",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: installInstructions
+            }
+          }
+        ]
+      };
+    }
+    default:
+      throw new Error(`Unknown prompt: ${name}`);
+  }
+});
+function generateWelcomeMessage(data, stats) {
+  const tokenSummary = Object.entries(stats.byCategory).map(([cat, count]) => `${cat}: ${count}`).join(", ");
+  const asciiArt = `
+\`\`\`
+                               \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+                            \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+                          \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+                         \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+                       \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+                 \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+              \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
+            \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
           \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
          \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
         \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198           \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
@@ -890,7 +1593,6 @@ function generateWelcomeMessage(data, stats) {
                   \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
                        \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
                         \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
-                         \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
                            \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
                              \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
                                 \u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198\u2198
@@ -899,8 +1601,6 @@ function generateWelcomeMessage(data, stats) {
   return `${asciiArt}
 # Welcome to ${data.meta.name}
-Your design system is connected and ready to use.
 ## Design System Overview
 | Metric | Value |
@@ -912,930 +1612,46 @@ Your design system is connected and ready to use.
 | Governance Rules | ${stats.governanceRules} |
 | Version | ${data.meta.version || 1} |
-### Token Breakdown
-${categoryBreakdown}
-## Available Tools
-${toolsList.map((t, i) => `${i + 1}. **${t.split(" - ")[0]}** - ${t.split(" - ")[1]}`).join("\n")}
-## Quick Start
+### Token breakdown
-### Get a Token
-\`\`\`
-Use getToken with path "colors.static.brand.primary"
-\`\`\`
-### List All Spacing Tokens
-\`\`\`
-Use listTokens with category "spacing"
-\`\`\`
+${tokenSummary}
-### Validate a Hardcoded Value
-\`\`\`
-Use validateUsage with value "#ff0000" and context "color"
-\`\`\`
-## Resources Available
+---
-This MCP server exposes rules files as resources that your AI tool can read:
+## Essential commands
-| Resource | Description |
-|----------|-------------|
-| \`atomix://welcome\` | This welcome message |
-| \`atomix://rules/cursor\` | .cursorrules file content |
-| \`atomix://rules/copilot\` | GitHub Copilot instructions |
-| \`atomix://rules/windsurf\` | .windsurfrules file content |
-| \`atomix://rules/cline\` | .clinerules file content |
-| \`atomix://rules/continue\` | Continue rules |
-| \`atomix://rules/zed\` | Zed assistant rules |
-| \`atomix://rules/generic\` | Generic AI guidelines |
+| Command | What to expect |
+|---------|----------------|
+| **install** | Scans your repo to set up global styles (if none), icons and fonts. Safe: Won't install until you confirm. |
+| **sync** | Syncs tokens to a local file. Adds new, updates existing, marks deprecated. Safe: No changes until you confirm. |
+| **refactor** | Scans codebase for deprecated tokens (after sync), suggests replacements. Run after sync to migrate code. |
-## Checking for Updates
+## Helper commands
-Your design system may be updated over time. To ensure you have the latest tokens:
+| Command | What to expect |
+|---------|----------------|
+| **design-system-rules** | Returns governance rules for your AI tools. |
+| **spacing** | Table of all spacing tokens and values. |
+| **color** | Table of color tokens with light/dark values. |
+| **typography** | Table of typography tokens and values. |
+| **radius** | Table of border radius tokens. |
+| **shadow** | Table of shadow/elevation tokens. |
+| **border** | Table of border width tokens. |
+| **sizing** | Table of height and icon size tokens. |
+| **motion** | Table of duration and easing tokens. |
-1. **Check version**: The current version is ${data.meta.version || 1}
-2. **Refresh tokens**: Restart the MCP server to fetch latest tokens
-3. **View changes**: Visit https://atomixstudio.eu/ds/${dsId} to see recent changes
+**Suggested next step:** Run **install** to set up global styles, icons, fonts, and token files; the AI will list options and ask before adding anything.
 ---
-*Powered by Atomix Studio - https://atomixstudio.eu*
-`;
-}
-function findConfig() {
-  const configNames = [".atomixrc", ".atomixrc.json", "atomix.config.json"];
-  const cwd = process.cwd();
-  for (const name of configNames) {
-    const configPath = path.join(cwd, name);
-    if (fs.existsSync(configPath)) {
-      try {
-        const content = fs.readFileSync(configPath, "utf-8");
-        return JSON.parse(content);
-      } catch {
-        console.error(`Error parsing ${name}`);
-      }
-    }
-  }
-  return null;
-}
-function generateCSSOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "/* Atomix Design System Tokens",
-    " * Auto-generated - do not edit manually",
-    ` * Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    " */",
-    "",
-    "/* Light mode (default) */",
-    ":root {"
-  ];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    lines.push(`  ${key}: ${value};`);
-  }
-  lines.push("}");
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("/* Dark mode */");
-    lines.push(".dark,");
-    lines.push('[data-theme="dark"] {');
-    const firstKey = Object.keys(cssVariables)[0] || "--atmx-";
-    const prefixMatch = firstKey.match(/^(--[a-z]+-)/);
-    const prefix = prefixMatch ? prefixMatch[1] : "--atmx-";
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      lines.push(`  ${prefix}color-${key}: ${value};`);
-    }
-    lines.push("}");
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function generateJSONOutput(tokens) {
-  return JSON.stringify(tokens, null, 2);
-}
-function generateTSOutput(tokens) {
-  return `// Atomix Design System Tokens
-// Auto-generated - do not edit manually
-// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}
-export const tokens = ${JSON.stringify(tokens, null, 2)} as const;
-export type Tokens = typeof tokens;
+*Atomix Studio \u2014 https://atomixstudio.eu | DS: https://atomixstudio.eu/ds/${dsId}*
 `;
 }
-function generateJSOutput(tokens) {
-  return `// Atomix Design System Tokens
-// Auto-generated - do not edit manually
-// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}
-export const tokens = ${JSON.stringify(tokens, null, 2)};
-`;
-}
-function generateSCSSOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "// Atomix Design System Tokens",
-    "// Auto-generated - do not edit manually",
-    `// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "// CSS Custom Properties (for use in CSS/HTML)",
-    "// Light mode (default)",
-    ":root {"
-  ];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    lines.push(`  ${key}: ${value};`);
-  }
-  lines.push("}");
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("// Dark mode");
-    lines.push(".dark,");
-    lines.push('[data-theme="dark"] {');
-    const firstKey = Object.keys(cssVariables)[0] || "--atmx-";
-    const prefixMatch = firstKey.match(/^(--[a-z]+-)/);
-    const prefix = prefixMatch ? prefixMatch[1] : "--atmx-";
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      lines.push(`  ${prefix}color-${key}: ${value};`);
-    }
-    lines.push("}");
-  }
-  lines.push("");
-  lines.push("// SCSS Variables (light mode values)");
-  for (const [key, value] of Object.entries(cssVariables)) {
-    const scssVar = "$" + key.replace(/^--/, "");
-    lines.push(`${scssVar}: ${value};`);
-  }
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("// SCSS Variables (dark mode values)");
-    const firstKey = Object.keys(cssVariables)[0] || "--atmx-";
-    const prefixMatch = firstKey.match(/^--([a-z]+)-/);
-    const prefix = prefixMatch ? prefixMatch[1] : "atmx";
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      const scssVar = `$${prefix}-color-${key}-dark`;
-      lines.push(`${scssVar}: ${value};`);
-    }
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function generateLessOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "// Atomix Design System Tokens",
-    "// Auto-generated - do not edit manually",
-    `// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "// CSS Custom Properties (for use in CSS/HTML)",
-    "// Light mode (default)",
-    ":root {"
-  ];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    lines.push(`  ${key}: ${value};`);
-  }
-  lines.push("}");
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("// Dark mode");
-    lines.push(".dark,");
-    lines.push('[data-theme="dark"] {');
-    const firstKey = Object.keys(cssVariables)[0] || "--atmx-";
-    const prefixMatch = firstKey.match(/^(--[a-z]+-)/);
-    const prefix = prefixMatch ? prefixMatch[1] : "--atmx-";
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      lines.push(`  ${prefix}color-${key}: ${value};`);
-    }
-    lines.push("}");
-  }
-  lines.push("");
-  lines.push("// Less Variables (light mode values)");
-  for (const [key, value] of Object.entries(cssVariables)) {
-    const lessVar = "@" + key.replace(/^--/, "");
-    lines.push(`${lessVar}: ${value};`);
-  }
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("// Less Variables (dark mode values)");
-    const firstKey = Object.keys(cssVariables)[0] || "--atmx-";
-    const prefixMatch = firstKey.match(/^--([a-z]+)-/);
-    const prefix = prefixMatch ? prefixMatch[1] : "atmx";
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      const lessVar = `@${prefix}-color-${key}-dark`;
-      lines.push(`${lessVar}: ${value};`);
-    }
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function toSwiftName(cssVar) {
-  return cssVar.replace(/^--atmx-/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-function toKotlinName(cssVar) {
-  const camel = toSwiftName(cssVar);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-function toDartName(cssVar) {
-  return toSwiftName(cssVar);
-}
-function isColorValue(value) {
-  return /^#[0-9A-Fa-f]{3,8}$/.test(value) || /^rgb/.test(value) || /^hsl/.test(value);
-}
-function hexToSwiftColor(hex) {
-  const clean = hex.replace("#", "");
-  if (clean.length === 3) {
-    const r = clean[0], g = clean[1], b = clean[2];
-    return `Color(hex: 0x${r}${r}${g}${g}${b}${b})`;
-  }
-  if (clean.length === 6) {
-    return `Color(hex: 0x${clean})`;
-  }
-  if (clean.length === 8) {
-    const rgb = clean.substring(0, 6);
-    const alpha = parseInt(clean.substring(6, 8), 16) / 255;
-    return `Color(hex: 0x${rgb}).opacity(${alpha.toFixed(2)})`;
-  }
-  return `Color.clear // Could not parse: ${hex}`;
-}
-function hexToKotlinColor(hex) {
-  const clean = hex.replace("#", "").toUpperCase();
-  if (clean.length === 3) {
-    const r = clean[0], g = clean[1], b = clean[2];
-    return `Color(0xFF${r}${r}${g}${g}${b}${b})`;
-  }
-  if (clean.length === 6) {
-    return `Color(0xFF${clean})`;
-  }
-  if (clean.length === 8) {
-    const rgb = clean.substring(0, 6);
-    const alpha = clean.substring(6, 8);
-    return `Color(0x${alpha}${rgb})`;
-  }
-  return `Color.Transparent // Could not parse: ${hex}`;
-}
-function hexToDartColor(hex) {
-  const clean = hex.replace("#", "").toUpperCase();
-  if (clean.length === 3) {
-    const r = clean[0], g = clean[1], b = clean[2];
-    return `Color(0xFF${r}${r}${g}${g}${b}${b})`;
-  }
-  if (clean.length === 6) {
-    return `Color(0xFF${clean})`;
-  }
-  if (clean.length === 8) {
-    const rgb = clean.substring(0, 6);
-    const alpha = clean.substring(6, 8);
-    return `Color(0x${alpha}${rgb})`;
-  }
-  return `Colors.transparent // Could not parse: ${hex}`;
-}
-function generateSwiftOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "// Atomix Design System Tokens",
-    "// Auto-generated - do not edit manually",
-    `// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "import SwiftUI",
-    "",
-    "// MARK: - Color Extension for Hex",
-    "extension Color {",
-    "    init(hex: UInt, alpha: Double = 1.0) {",
-    "        self.init(",
-    "            .sRGB,",
-    "            red: Double((hex >> 16) & 0xFF) / 255.0,",
-    "            green: Double((hex >> 8) & 0xFF) / 255.0,",
-    "            blue: Double(hex & 0xFF) / 255.0,",
-    "            opacity: alpha",
-    "        )",
-    "    }",
-    "}",
-    "",
-    "// MARK: - Design Tokens",
-    "enum DesignTokens {",
-    "",
-    "    // MARK: Colors (Light Mode)",
-    "    enum Colors {"
-  ];
-  const colors = [];
-  const spacing = [];
-  const typography = [];
-  const other = [];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    if (key.includes("-color-")) colors.push([key, value]);
-    else if (key.includes("-spacing-")) spacing.push([key, value]);
-    else if (key.includes("-typography-") || key.includes("-font-")) typography.push([key, value]);
-    else other.push([key, value]);
-  }
-  for (const [key, value] of colors) {
-    const name = toSwiftName(key);
-    if (isColorValue(value)) {
-      lines.push(`        static let ${name} = ${hexToSwiftColor(value)}`);
-    }
-  }
-  lines.push("    }");
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("    // MARK: Colors (Dark Mode)");
-    lines.push("    enum ColorsDark {");
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      const name = `color${key.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")}`;
-      if (isColorValue(value)) {
-        lines.push(`        static let ${name} = ${hexToSwiftColor(value)}`);
-      }
-    }
-    lines.push("    }");
-  }
-  lines.push("");
-  lines.push("    // MARK: Spacing");
-  lines.push("    enum Spacing {");
-  for (const [key, value] of spacing) {
-    const name = toSwiftName(key);
-    const numValue = parseFloat(value);
-    if (!isNaN(numValue)) {
-      lines.push(`        static let ${name}: CGFloat = ${numValue}`);
-    }
-  }
-  lines.push("    }");
-  lines.push("");
-  lines.push("    // MARK: Typography");
-  lines.push("    enum Typography {");
-  for (const [key, value] of typography) {
-    const name = toSwiftName(key);
-    if (key.includes("size")) {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`        static let ${name}: CGFloat = ${numValue}`);
-      }
-    } else if (key.includes("weight")) {
-      lines.push(`        static let ${name} = "${value}"`);
-    } else if (key.includes("family")) {
-      lines.push(`        static let ${name} = "${value}"`);
-    }
-  }
-  lines.push("    }");
-  lines.push("");
-  lines.push("    // MARK: Other");
-  lines.push("    enum Other {");
-  for (const [key, value] of other) {
-    const name = toSwiftName(key);
-    if (isColorValue(value)) {
-      lines.push(`        static let ${name} = ${hexToSwiftColor(value)}`);
-    } else {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`        static let ${name}: CGFloat = ${numValue}`);
-      } else {
-        lines.push(`        static let ${name} = "${value}"`);
-      }
-    }
-  }
-  lines.push("    }");
-  lines.push("}");
-  lines.push("");
-  return lines.join("\n");
-}
-function generateKotlinOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "// Atomix Design System Tokens",
-    "// Auto-generated - do not edit manually",
-    `// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "package com.atomix.design",
-    "",
-    "import androidx.compose.ui.graphics.Color",
-    "import androidx.compose.ui.unit.dp",
-    "import androidx.compose.ui.unit.sp",
-    "",
-    "object DesignTokens {",
-    "",
-    "    // Light mode colors",
-    "    object Colors {"
-  ];
-  const colors = [];
-  const spacing = [];
-  const typography = [];
-  const other = [];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    if (key.includes("-color-")) colors.push([key, value]);
-    else if (key.includes("-spacing-")) spacing.push([key, value]);
-    else if (key.includes("-typography-") || key.includes("-font-")) typography.push([key, value]);
-    else other.push([key, value]);
-  }
-  for (const [key, value] of colors) {
-    const name = toKotlinName(key);
-    if (isColorValue(value)) {
-      lines.push(`        val ${name} = ${hexToKotlinColor(value)}`);
-    }
-  }
-  lines.push("    }");
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("    // Dark mode colors");
-    lines.push("    object ColorsDark {");
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      const name = `Color${key.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")}`;
-      if (isColorValue(value)) {
-        lines.push(`        val ${name} = ${hexToKotlinColor(value)}`);
-      }
-    }
-    lines.push("    }");
-  }
-  lines.push("");
-  lines.push("    object Spacing {");
-  for (const [key, value] of spacing) {
-    const name = toKotlinName(key);
-    const numValue = parseFloat(value);
-    if (!isNaN(numValue)) {
-      lines.push(`        val ${name} = ${numValue}.dp`);
-    }
-  }
-  lines.push("    }");
-  lines.push("");
-  lines.push("    object Typography {");
-  for (const [key, value] of typography) {
-    const name = toKotlinName(key);
-    if (key.includes("size")) {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`        val ${name} = ${numValue}.sp`);
-      }
-    } else {
-      lines.push(`        const val ${name} = "${value}"`);
-    }
-  }
-  lines.push("    }");
-  lines.push("");
-  lines.push("    object Other {");
-  for (const [key, value] of other) {
-    const name = toKotlinName(key);
-    if (isColorValue(value)) {
-      lines.push(`        val ${name} = ${hexToKotlinColor(value)}`);
-    } else {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`        val ${name} = ${numValue}.dp`);
-      } else {
-        lines.push(`        const val ${name} = "${value}"`);
-      }
-    }
-  }
-  lines.push("    }");
-  lines.push("}");
-  lines.push("");
-  return lines.join("\n");
-}
-function generateDartOutput(cssVariables, darkModeColors) {
-  const lines = [
-    "// Atomix Design System Tokens",
-    "// Auto-generated - do not edit manually",
-    `// Synced: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "import 'package:flutter/material.dart';",
-    "",
-    "class DesignTokens {",
-    "  DesignTokens._();",
-    "",
-    "  // Colors (Light Mode)"
-  ];
-  const colors = [];
-  const spacing = [];
-  const typography = [];
-  const other = [];
-  for (const [key, value] of Object.entries(cssVariables)) {
-    if (key.includes("-color-")) colors.push([key, value]);
-    else if (key.includes("-spacing-")) spacing.push([key, value]);
-    else if (key.includes("-typography-") || key.includes("-font-")) typography.push([key, value]);
-    else other.push([key, value]);
-  }
-  for (const [key, value] of colors) {
-    const name = toDartName(key);
-    if (isColorValue(value)) {
-      lines.push(`  static const ${name} = ${hexToDartColor(value)};`);
-    }
-  }
-  if (darkModeColors && Object.keys(darkModeColors).length > 0) {
-    lines.push("");
-    lines.push("  // Colors (Dark Mode)");
-    for (const [key, value] of Object.entries(darkModeColors)) {
-      const name = `color${key.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")}Dark`;
-      if (isColorValue(value)) {
-        lines.push(`  static const ${name} = ${hexToDartColor(value)};`);
-      }
-    }
-  }
-  lines.push("");
-  lines.push("  // Spacing");
-  for (const [key, value] of spacing) {
-    const name = toDartName(key);
-    const numValue = parseFloat(value);
-    if (!isNaN(numValue)) {
-      lines.push(`  static const double ${name} = ${numValue};`);
-    }
-  }
-  lines.push("");
-  lines.push("  // Typography");
-  for (const [key, value] of typography) {
-    const name = toDartName(key);
-    if (key.includes("size")) {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`  static const double ${name} = ${numValue};`);
-      }
-    } else {
-      lines.push(`  static const String ${name} = '${value}';`);
-    }
-  }
-  lines.push("");
-  lines.push("  // Other");
-  for (const [key, value] of other) {
-    const name = toDartName(key);
-    if (isColorValue(value)) {
-      lines.push(`  static const ${name} = ${hexToDartColor(value)};`);
-    } else {
-      const numValue = parseFloat(value);
-      if (!isNaN(numValue)) {
-        lines.push(`  static const double ${name} = ${numValue};`);
-      } else {
-        lines.push(`  static const String ${name} = '${value}';`);
-      }
-    }
-  }
-  lines.push("}");
-  lines.push("");
-  return lines.join("\n");
-}
-function diffTokens(oldContent, newCssVars, format, newDarkVars) {
-  const added = [];
-  const modified = [];
-  const removed = [];
-  const addedDark = [];
-  const modifiedDark = [];
-  const removedDark = [];
-  if (format === "css" || format === "scss" || format === "less") {
-    const rootMatch = oldContent.match(/:root\s*\{([^}]*)\}/);
-    const darkMatch = oldContent.match(/\.dark[^{]*\{([^}]*)\}/);
-    const oldLightVars = {};
-    if (rootMatch) {
-      const rootContent = rootMatch[1];
-      const varRegex = /(--[\w-]+):\s*([^;]+);/g;
-      let match;
-      while ((match = varRegex.exec(rootContent)) !== null) {
-        oldLightVars[match[1]] = match[2].trim();
-      }
-    } else {
-      const varRegex = /(--[\w-]+):\s*([^;]+);/g;
-      let match;
-      while ((match = varRegex.exec(oldContent)) !== null) {
-        if (!(match[1] in oldLightVars)) {
-          oldLightVars[match[1]] = match[2].trim();
-        }
-      }
-    }
-    const oldDarkVars = {};
-    if (darkMatch) {
-      const darkContent = darkMatch[1];
-      const varRegex = /(--[\w-]+):\s*([^;]+);/g;
-      let match;
-      while ((match = varRegex.exec(darkContent)) !== null) {
-        oldDarkVars[match[1]] = match[2].trim();
-      }
-    }
-    for (const [key, value] of Object.entries(newCssVars)) {
-      if (!(key in oldLightVars)) {
-        added.push(key);
-      } else if (oldLightVars[key] !== value) {
-        modified.push({ key, old: oldLightVars[key], new: value });
-      }
-    }
-    for (const key of Object.keys(oldLightVars)) {
-      if (!(key in newCssVars)) {
-        removed.push(key);
-      }
-    }
-    if (newDarkVars && Object.keys(newDarkVars).length > 0) {
-      const firstKey = Object.keys(newCssVars)[0] || "--atmx-";
-      const prefixMatch = firstKey.match(/^(--[a-z]+-)/);
-      const prefix = prefixMatch ? prefixMatch[1] : "--atmx-";
-      for (const [key, value] of Object.entries(newDarkVars)) {
-        const cssVarName = `${prefix}color-${key}`;
-        if (!(cssVarName in oldDarkVars)) {
-          addedDark.push(cssVarName);
-        } else if (oldDarkVars[cssVarName] !== value) {
-          modifiedDark.push({ key: cssVarName, old: oldDarkVars[cssVarName], new: value });
-        }
-      }
-      for (const key of Object.keys(oldDarkVars)) {
-        const shortKey = key.replace(new RegExp(`^${prefix}color-`), "");
-        if (!(shortKey in newDarkVars)) {
-          removedDark.push(key);
-        }
-      }
-    }
-  }
-  return { added, modified, removed, addedDark, modifiedDark, removedDark };
-}
-async function promptConfirm(message) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve2) => {
-    rl.question(`${message} [Y/n] `, (answer) => {
-      rl.close();
-      const normalized = answer.toLowerCase().trim();
-      resolve2(normalized === "" || normalized === "y" || normalized === "yes");
-    });
-  });
-}
-async function runSync() {
-  console.log("");
-  console.log("  \u2198\u2198\u2198  Atomix Token Sync");
-  console.log("");
-  const config = findConfig();
-  const effectiveDsId = cliArgs.dsId || config?.dsId;
-  const effectiveApiKey = cliArgs.apiKey || config?.apiKey;
-  const effectiveApiBase = cliArgs.apiBase || config?.apiBase || "https://atomixstudio.eu";
-  const effectiveOutput = cliArgs.output || config?.output || "./tokens.css";
-  const effectiveFormat = cliArgs.format || config?.format || "css";
-  if (!effectiveDsId) {
-    console.error("  Error: Missing design system ID");
-    console.error("");
-    console.error("  Either:");
-    console.error("    1. Run: npx atomix sync --ds-id <your-ds-id>");
-    console.error('    2. Create .atomixrc with { "dsId": "<your-ds-id>" }');
-    console.error("    3. Run: npx atomix init");
-    console.error("");
-    process.exit(1);
-  }
-  console.log(`  Fetching tokens from ${effectiveApiBase}...`);
-  const url = `${effectiveApiBase}/api/ds/${effectiveDsId}/tokens?format=export`;
-  const headers = { "Content-Type": "application/json" };
-  if (effectiveApiKey) headers["x-api-key"] = effectiveApiKey;
-  let data;
-  try {
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.error(`  Error: Failed to fetch tokens (${response.status})`);
-      console.error(`  ${errorText}`);
-      process.exit(1);
-    }
-    data = await response.json();
-  } catch (error) {
-    console.error(`  Error: Could not connect to ${effectiveApiBase}`);
-    console.error(`  ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-  console.log(`  Design System: ${data.meta.name} (v${data.meta.version})`);
-  console.log("");
-  const darkModeColors = data.tokens?.colors?.modes;
-  let newContent;
-  switch (effectiveFormat) {
-    case "css":
-      newContent = generateCSSOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    case "scss":
-      newContent = generateSCSSOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    case "less":
-      newContent = generateLessOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    case "json":
-      newContent = generateJSONOutput(data.tokens);
-      break;
-    case "js":
-      newContent = generateJSOutput(data.tokens);
-      break;
-    case "ts":
-      newContent = generateTSOutput(data.tokens);
-      break;
-    case "swift":
-      newContent = generateSwiftOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    case "kotlin":
-      newContent = generateKotlinOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    case "dart":
-      newContent = generateDartOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-    default:
-      newContent = generateCSSOutput(data.cssVariables, darkModeColors?.dark);
-      break;
-  }
-  const outputPath = path.resolve(process.cwd(), effectiveOutput);
-  const fileExists = fs.existsSync(outputPath);
-  const supportsDiff = ["css", "scss", "less"].includes(effectiveFormat);
-  if (fileExists && supportsDiff) {
-    const oldContent = fs.readFileSync(outputPath, "utf-8");
-    const diff = diffTokens(oldContent, data.cssVariables, effectiveFormat, darkModeColors?.dark);
-    const lightChanges = diff.added.length + diff.modified.length + diff.removed.length;
-    const darkChanges = diff.addedDark.length + diff.modifiedDark.length + diff.removedDark.length;
-    const totalChanges = lightChanges + darkChanges;
-    if (totalChanges === 0) {
-      console.log("  \u2713 Already up to date!");
-      console.log("");
-      process.exit(0);
-    }
-    console.log(`  Changes detected in ${path.basename(effectiveOutput)}:`);
-    console.log("");
-    if (lightChanges > 0) {
-      console.log("  Light Mode:");
-      if (diff.modified.length > 0) {
-        for (const { key, old: oldVal, new: newVal } of diff.modified) {
-          console.log(`    ${key}`);
-          console.log(`      - ${oldVal}`);
-          console.log(`      + ${newVal}`);
-        }
-      }
-      if (diff.added.length > 0) {
-        console.log(`    + ${diff.added.length} new token(s)`);
-      }
-      if (diff.removed.length > 0) {
-        console.log(`    - ${diff.removed.length} removed token(s)`);
-      }
-      console.log("");
-    }
-    if (darkChanges > 0) {
-      console.log("  Dark Mode:");
-      if (diff.modifiedDark.length > 0) {
-        for (const { key, old: oldVal, new: newVal } of diff.modifiedDark) {
-          console.log(`    ${key}`);
-          console.log(`      - ${oldVal}`);
-          console.log(`      + ${newVal}`);
-        }
-      }
-      if (diff.addedDark.length > 0) {
-        console.log(`    + ${diff.addedDark.length} new token(s)`);
-      }
-      if (diff.removedDark.length > 0) {
-        console.log(`    - ${diff.removedDark.length} removed token(s)`);
-      }
-      console.log("");
-    }
-    console.log(`  Total: ${totalChanges} change(s) (Light: ${lightChanges}, Dark: ${darkChanges})`);
-    console.log("");
-    if (!cliArgs.yes) {
-      const confirmed = await promptConfirm("  Apply changes?");
-      if (!confirmed) {
-        console.log("  Cancelled.");
-        process.exit(0);
-      }
-    }
-  } else if (!fileExists) {
-    console.log(`  Creating ${effectiveOutput}...`);
-    console.log(`  ${Object.keys(data.cssVariables).length} tokens`);
-    console.log("");
-    if (!cliArgs.yes) {
-      const confirmed = await promptConfirm("  Create file?");
-      if (!confirmed) {
-        console.log("  Cancelled.");
-        process.exit(0);
-      }
-    }
-  }
-  const outputDir = path.dirname(outputPath);
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-  fs.writeFileSync(outputPath, newContent);
-  console.log("");
-  console.log(`  \u2713 Tokens synced \u2192 ${effectiveOutput}`);
-  if (cliArgs.rules) {
-    console.log("");
-    console.log("  Syncing AI guidance rules...");
-    const rulesDir = cliArgs.rulesDir || process.cwd();
-    const rulesDirResolved = path.resolve(process.cwd(), rulesDir);
-    const toolsToSync = [
-      { tool: "cursor", filename: ".cursorrules" },
-      { tool: "windsurf", filename: ".windsurfrules" },
-      { tool: "cline", filename: ".clinerules" },
-      { tool: "continue", filename: ".continuerules" },
-      { tool: "copilot", filename: "copilot-instructions.md", dir: ".github" },
-      { tool: "generic", filename: "AI_GUIDELINES.md" }
-    ];
-    const existingTools = toolsToSync.filter((t) => {
-      const filePath = t.dir ? path.join(rulesDirResolved, t.dir, t.filename) : path.join(rulesDirResolved, t.filename);
-      return fs.existsSync(filePath);
-    });
-    const toolsToWrite = existingTools.length > 0 ? existingTools : [{ tool: "cursor", filename: ".cursorrules" }];
-    for (const { tool, filename, dir } of toolsToWrite) {
-      try {
-        const rulesUrl = `${effectiveApiBase}/api/ds/${effectiveDsId}/rules?format=${tool}`;
-        const headers2 = { "Content-Type": "application/json" };
-        if (effectiveApiKey) headers2["x-api-key"] = effectiveApiKey;
-        const response = await fetch(rulesUrl, { headers: headers2 });
-        if (!response.ok) {
-          console.error(`    \u2717 Failed to fetch ${tool} rules: ${response.status}`);
-          continue;
-        }
-        const rulesData = await response.json();
-        if (!rulesData.content) {
-          console.error(`    \u2717 No content for ${tool} rules`);
-          continue;
-        }
-        const targetDir = dir ? path.join(rulesDirResolved, dir) : rulesDirResolved;
-        if (!fs.existsSync(targetDir)) {
-          fs.mkdirSync(targetDir, { recursive: true });
-        }
-        const filePath = path.join(targetDir, filename);
-        fs.writeFileSync(filePath, rulesData.content);
-        const relativePath = dir ? `${dir}/${filename}` : filename;
-        console.log(`    \u2713 ${relativePath}`);
-      } catch (error) {
-        console.error(`    \u2717 Error syncing ${tool} rules:`, error instanceof Error ? error.message : String(error));
-      }
-    }
-  }
-  console.log("");
-}
-async function runInit() {
-  console.log("");
-  console.log("  \u2198\u2198\u2198  Atomix Config Setup");
-  console.log("");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const question = (prompt) => new Promise((resolve2) => rl.question(prompt, resolve2));
-  const dsId2 = cliArgs.dsId || await question("  Design System ID: ");
-  const output = await question("  Output file [./tokens.css]: ") || "./tokens.css";
-  const format = await question("  Format (css/json/ts) [css]: ") || "css";
-  rl.close();
-  const config = {
-    dsId: dsId2,
-    output,
-    format
-  };
-  const configPath = path.join(process.cwd(), ".atomixrc");
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  console.log("");
-  console.log(`  \u2713 Created .atomixrc`);
-  console.log("");
-  console.log("  Now run: npx atomix sync");
-  console.log("");
-}
-function showHelp() {
-  console.log(`
-  \u2198\u2198\u2198  Atomix CLI
-  COMMANDS
-    sync          Sync design tokens to your project
-    init          Create .atomixrc config file
-    help          Show this help message
-    (none)        Start MCP server for AI tools
-  SYNC OPTIONS
-    --ds-id       Design system ID (or set in .atomixrc)
-    --api-key     API key for private design systems
-    --output, -o  Output file path [./tokens.css]
-    --format      Output format [css]
-                  WEB:
-                    css    - CSS custom properties (:root { --var: value })
-                    scss   - CSS vars + SCSS variables ($var: value)
-                    less   - CSS vars + Less variables (@var: value)
-                    json   - Raw token JSON
-                    ts     - TypeScript with types
-                    js     - JavaScript ES module
-                  NATIVE:
-                    swift  - SwiftUI (iOS/macOS)
-                    kotlin - Jetpack Compose (Android)
-                    dart   - Flutter
-    --no-rules    Skip syncing AI rules files (tokens + rules sync by default)
-    --rules-dir   Directory for rules files [project root]
-    --exclude     Glob pattern to exclude (can use multiple times)
-    -y, --yes     Auto-confirm changes
-  MCP SERVER OPTIONS
-    --ds-id       Design system ID (required)
-    --api-key     API key for private design systems
-    --api-base    API base URL [https://atomixstudio.eu]
-  EXAMPLES
-    npx heyatomix sync                     # Sync tokens + AI rules (default)
-    npx heyatomix sync --no-rules          # Sync tokens only
-    npx heyatomix sync -o ./src/tokens.css
-    npx heyatomix sync --format scss -o ./src/styles/_tokens.scss
-    npx heyatomix sync --format swift -o ./Sources/DesignTokens.swift
-    npx heyatomix init
-    npx heyatomix --ds-id abc123           # Start MCP server
-  CONFIG FILE (.atomixrc)
-    {
-      "dsId": "your-design-system-id",
-      "output": "./src/styles/tokens.css",
-      "format": "css",
-      "exclude": ["legacy/**", "vendor/**"]
-    }
-  DEFAULT SCANNED FILES
-    *.tsx, *.jsx, *.ts, *.js, *.css, *.scss, *.less, *.vue, *.svelte
-  DEFAULT EXCLUDED
-    node_modules/**, dist/**, build/**, .next/**, *.min.*, *.d.ts
-`);
-}
 async function startServer() {
   if (!dsId) {
     console.error("Error: Missing --ds-id argument");
-    console.error("Usage: npx atomix --ds-id <id> --api-key <key>");
+    console.error("Usage: npx atomix --ds-id <id> [--api-key <key>]");
+    console.error("Note: --api-key is optional (only needed for private design systems)");
     console.error("");
     console.error("For sync command: npx atomix sync --help");
     console.error("Get your DS ID from https://atomixstudio.eu/ds/[your-ds-id]");
@@ -1846,21 +1662,7 @@ async function startServer() {
   console.error(`Atomix MCP Server started for design system: ${dsId}`);
 }
 async function main() {
-  switch (cliArgs.command) {
-    case "sync":
-      await runSync();
-      break;
-    case "init":
-      await runInit();
-      break;
-    case "help":
-      showHelp();
-      break;
-    case "server":
-    default:
-      await startServer();
-      break;
-  }
+  await startServer();
 }
 main().catch((error) => {
   console.error("Failed:", error);