@atomixstudio/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2974 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tokens.ts
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var atomixPath = join(__dirname, "../../atomix/dist/index.mjs");
+var loadedPrimitives = null;
+async function loadPrimitives() {
+  if (loadedPrimitives) return loadedPrimitives;
+  try {
+    const module = await import(atomixPath);
+    loadedPrimitives = module.primitives;
+    return loadedPrimitives;
+  } catch (error) {
+    console.error(`Failed to load @atomix/tokens from ${atomixPath}:`, error);
+    console.error("Falling back to inline primitives...");
+    loadedPrimitives = FALLBACK_PRIMITIVES;
+    return FALLBACK_PRIMITIVES;
+  }
+}
+var primitives = {};
+loadPrimitives().then((p) => {
+  primitives = p;
+});
+var TOKEN_CATEGORIES = [
+  "colors",
+  "typography",
+  "spacing",
+  "sizing",
+  "shadows",
+  "radius",
+  "motion",
+  "zIndex",
+  "borders"
+];
+var FALLBACK_PRIMITIVES = {
+  colors: {
+    static: {
+      brand: {
+        primary: "#007061",
+        primaryLight: "#00A389",
+        primaryDark: "#005A4D",
+        primaryForeground: "#FFFFFF"
+      },
+      white: "#FFFFFF",
+      black: "#000000"
+    },
+    modes: {
+      light: {
+        bgPage: "#FFFFFF",
+        bgSurface: "#FFFFFF",
+        bgMuted: "#F5F5F5",
+        textPrimary: "#171717",
+        textSecondary: "#525252",
+        textMuted: "#A3A3A3",
+        // Icon colors (derived from brand/text)
+        iconBrand: "#007061",
+        // = brand.primary
+        iconStrong: "#171717",
+        // = textPrimary
+        iconSubtle: "#525252",
+        // = textSecondary
+        iconDisabled: "#A3A3A3",
+        // = textMuted
+        borderPrimary: "#E5E5E5"
+      },
+      dark: {
+        bgPage: "#0A0A0A",
+        bgSurface: "#1A1A1A",
+        bgMuted: "#262626",
+        textPrimary: "#FAFAFA",
+        textSecondary: "#A3A3A3",
+        textMuted: "#737373",
+        // Icon colors (derived from brand/text)
+        iconBrand: "#007061",
+        // = brand.primary
+        iconStrong: "#FAFAFA",
+        // = textPrimary
+        iconSubtle: "#A3A3A3",
+        // = textSecondary
+        iconDisabled: "#737373",
+        // = textMuted
+        borderPrimary: "#404040"
+      }
+    },
+    scales: {
+      green: {
+        50: "#E6F5F2",
+        500: "#007061",
+        900: "#002E28"
+      }
+    }
+  },
+  typography: {
+    fontFamily: {
+      sans: "Inter, system-ui, sans-serif",
+      mono: "JetBrains Mono, monospace"
+    },
+    fontSize: {
+      xs: "0.75rem",
+      sm: "0.875rem",
+      md: "1rem",
+      lg: "1.125rem",
+      xl: "1.25rem"
+    },
+    fontWeight: {
+      regular: 400,
+      medium: 500,
+      semibold: 600,
+      bold: 700
+    },
+    lineHeight: {
+      tight: 1.25,
+      normal: 1.5,
+      relaxed: 1.625
+    }
+  },
+  spacing: {
+    scale: {
+      xs: "0.25rem",
+      sm: "0.5rem",
+      md: "1rem",
+      lg: "1.5rem",
+      xl: "2rem"
+    },
+    inset: {
+      xs: "0.25rem",
+      sm: "0.5rem",
+      md: "1rem",
+      lg: "1.5rem"
+    }
+  },
+  sizing: {
+    button: {
+      sm: { height: "32px" },
+      md: { height: "40px" },
+      lg: { height: "48px" }
+    }
+  },
+  shadows: {
+    elevation: {
+      none: "none",
+      sm: "0 1px 2px rgba(0, 0, 0, 0.05)",
+      md: "0 4px 6px rgba(0, 0, 0, 0.1)",
+      lg: "0 10px 15px rgba(0, 0, 0, 0.1)"
+    },
+    focus: {
+      ring: "0 0 0 2px var(--atomix-brand)"
+    }
+  },
+  radius: {
+    scale: {
+      none: "0",
+      sm: "0.25rem",
+      md: "0.5rem",
+      lg: "0.75rem",
+      xl: "1rem",
+      full: "9999px"
+    }
+  },
+  motion: {
+    duration: {
+      instant: "0ms",
+      fast: "150ms",
+      normal: "200ms",
+      slow: "300ms"
+    },
+    easing: {
+      ease: "cubic-bezier(0.4, 0, 0.2, 1)",
+      easeIn: "cubic-bezier(0.4, 0, 1, 1)",
+      easeOut: "cubic-bezier(0, 0, 0.2, 1)"
+    }
+  },
+  zIndex: {
+    dropdown: 1e3,
+    modal: 1100,
+    tooltip: 1200
+  },
+  borders: {
+    width: {
+      none: "0",
+      thin: "1px",
+      medium: "2px"
+    }
+  }
+};
+
+// src/utils.ts
+function getTokenByPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function listTokensInCategory(primitives3, category, subcategory) {
+  let base = primitives3[category];
+  if (!base) return {};
+  if (subcategory) {
+    const subParts = subcategory.split(".");
+    for (const part of subParts) {
+      if (typeof base !== "object" || base === null) return {};
+      base = base[part];
+    }
+  }
+  if (typeof base !== "object" || base === null) {
+    return { [subcategory || category]: base };
+  }
+  return flattenTokens(base);
+}
+function flattenTokens(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      Object.assign(result, flattenTokens(value, path));
+    } else {
+      result[path] = value;
+    }
+  }
+  return result;
+}
+function getTokenCategories() {
+  return [...TOKEN_CATEGORIES];
+}
+function getCssVariableName(path) {
+  const dashPath = path.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return `--atomix-${dashPath}`;
+}
+function getTokenMetadata(path) {
+  if (path.match(/^colors\.scales\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Raw color palette. Use semantic colors (colors.modes.*) in components instead."
+    };
+  }
+  if (path.match(/^colors\.scales\.(black|white|green)Alpha\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Alpha transparency scale. Reference only for overlays/effects."
+    };
+  }
+  if (path.match(/^spacing\.scale\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Spacing scale values. Use semantic spacing keys (xs, sm, md, lg) in components."
+    };
+  }
+  if (path.match(/^spacing\.(inset|stack|inline|gap)\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Spacing presets derived from scale. Reference only."
+    };
+  }
+  if (path.match(/^typography\.(fontSize|fontWeight|lineHeight|lineHeightPx|letterSpacing|paragraphSpacing)\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Raw typography values. Use typeSets (title-lg, text-normal-regular) in components."
+    };
+  }
+  if (path.match(/^radius\.scale\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Border radius scale. Use semantic radius (radius.semantic.*) or scale keys in components."
+    };
+  }
+  if (path.match(/^borders\.width\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Border width scale. Use semantic border keys in components."
+    };
+  }
+  if (path.match(/^shadows\.elevation\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Elevation shadow values. Use elevation keys (sm, md, lg) in components."
+    };
+  }
+  if (path.match(/^motion\.(duration|easing)\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Motion primitives. Use semantic motion presets (motion.semantic.*) when available."
+    };
+  }
+  if (path.match(/^zIndex\.scale\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Z-index scale. Use semantic z-index (zIndex.semantic.*) in components."
+    };
+  }
+  if (path.match(/^sizing\./)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Component sizing values. Reference only for layout calculations."
+    };
+  }
+  if (path.match(/^colors\.modes\.(light|dark)\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Semantic color for theming. Use this in components. Editable via Atomix Designer."
+    };
+  }
+  if (path.match(/^colors\.adaptive\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Adaptive feedback color (error, warning, success, info). Use for validation states."
+    };
+  }
+  if (path.match(/^colors\.static\.brand/)) {
+    return {
+      tier: "semantic",
+      mutable: false,
+      // Brand colors are locked
+      guidance: "Brand identity color. Use for primary brand elements. Protected from modification."
+    };
+  }
+  if (path.match(/^colors\.static\.(white|black|transparent)/)) {
+    return {
+      tier: "primitive",
+      mutable: false,
+      guidance: "Static utility color. Use for absolute white/black when needed."
+    };
+  }
+  if (path.match(/^radius\.semantic\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Semantic border radius for component types. Use this in component styling."
+    };
+  }
+  if (path.match(/^borders\.semantic\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Semantic border width for component types. Use this in component styling."
+    };
+  }
+  if (path.match(/^motion\.semantic\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Semantic animation preset. Use for consistent motion patterns."
+    };
+  }
+  if (path.match(/^zIndex\.semantic\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Semantic z-index for UI layers. Use for proper stacking order."
+    };
+  }
+  if (path.match(/^shadows\.focus\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Focus ring styles for accessibility. Use for keyboard focus indicators."
+    };
+  }
+  if (path.match(/^typography\.typeSets\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Composed typography style. Use these for consistent text styling."
+    };
+  }
+  if (path.match(/^typography\.fontFamily\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Font family selection. Use 'sans', 'mono', or 'display' keys."
+    };
+  }
+  if (path.match(/^typography\.textStyles\./)) {
+    return {
+      tier: "semantic",
+      mutable: true,
+      editVia: "designer",
+      guidance: "Complete text style definition. Use for consistent typography."
+    };
+  }
+  return {
+    tier: "primitive",
+    mutable: false,
+    guidance: "Token classification unknown. Treat as read-only reference."
+  };
+}
+
+// src/component-tokens.ts
+var COMPONENT_TOKENS = {
+  "button": {
+    "description": "Interactive button component with multiple variants and sizes",
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "top": "xs",
+          "right": "sm",
+          "bottom": "xs",
+          "left": "sm",
+          "borderRadius": "radius.scale.lg",
+          "typeSet": "typography.typeSets.text-small-bold"
+        }
+      },
+      "padding": {
+        "tokens": {
+          "top": "xs",
+          "right": "sm",
+          "bottom": "xs",
+          "left": "sm",
+          "borderRadius": "radius.scale.lg",
+          "typeSet": "typography.typeSets.text-small-bold"
+        }
+      },
+      "md": {
+        "tokens": {
+          "top": "sm",
+          "right": "lg",
+          "bottom": "sm",
+          "left": "lg",
+          "borderRadius": "radius.scale.4xl",
+          "typeSet": "typography.typeSets.text-normal-bold"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "top": "sm",
+          "right": "lg",
+          "bottom": "sm",
+          "left": "lg",
+          "borderRadius": "radius.scale.4xl",
+          "typeSet": "typography.typeSets.text-large-bold"
+        }
+      }
+    }
+  },
+  "card": {
+    "description": "Container component for grouping related content",
+    "variants": {
+      "default": {
+        "description": "default variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgSurface",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderWidth": "sm",
+          "borderRadius": "xl",
+          "shadow": "none",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textSecondary",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "interaction": "elevation",
+          "hoverShadow": "elevation-lg",
+          "hoverTranslateY": "-2px",
+          "hoverBorderColor": "colors.modes.{mode}.borderStrong"
+        }
+      },
+      "elevated": {
+        "description": "elevated variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgSurface",
+          "borderColor": "colors.modes.{mode}.borderPrimary",
+          "borderWidth": "sm",
+          "borderRadius": "2xl",
+          "shadow": "elevation-md",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textSecondary",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "interaction": "elevation",
+          "hoverShadow": "elevation-lg",
+          "hoverTranslateY": "-2px",
+          "hoverBorderColor": "transparent"
+        }
+      },
+      "outlined": {
+        "description": "outlined variant",
+        "tokens": {
+          "background": "transparent",
+          "borderColor": "colors.modes.{mode}.borderSecondary",
+          "borderWidth": "lg",
+          "borderRadius": "2xl",
+          "shadow": "none",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textSecondary",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "interaction": "border",
+          "hoverShadow": "none",
+          "hoverTranslateY": "0",
+          "hoverBorderColor": "colors.modes.{mode}.borderStrong"
+        }
+      },
+      "ghost": {
+        "description": "ghost variant",
+        "tokens": {
+          "background": "transparent",
+          "borderColor": "transparent",
+          "borderWidth": "none",
+          "borderRadius": "xl",
+          "shadow": "none",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textMuted",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "interaction": "none",
+          "hoverShadow": "none",
+          "hoverTranslateY": "0",
+          "hoverBorderColor": "transparent"
+        }
+      }
+    },
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "top": "lg",
+          "right": "xl",
+          "bottom": "lg",
+          "left": "xl",
+          "headingSize": "sm"
+        }
+      },
+      "padding": {
+        "tokens": {
+          "top": "lg",
+          "right": "xl",
+          "bottom": "lg",
+          "left": "xl",
+          "headingSize": "sm"
+        }
+      },
+      "md": {
+        "tokens": {
+          "top": "xl",
+          "right": "2xl",
+          "bottom": "xl",
+          "left": "2xl",
+          "headingSize": "md"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "top": "2xl",
+          "right": "3xl",
+          "bottom": "2xl",
+          "left": "3xl",
+          "headingSize": "lg"
+        }
+      }
+    },
+    "shared": {
+      "titleFontFamily": "typography.fontFamily.sans",
+      "bodyFontFamily": "typography.fontFamily.sans"
+    }
+  },
+  "input": {
+    "description": "Text input field component with validation states",
+    "variants": {
+      "default": {
+        "description": "default variant",
+        "tokens": {
+          "borderWidth": "sm",
+          "borderColor": "colors.modes.{mode}.borderPrimary",
+          "borderColorFocus": "colors.modes.{mode}.borderStrong",
+          "helperTextColor": "colors.modes.{mode}.textMuted"
+        }
+      },
+      "error": {
+        "description": "error variant",
+        "tokens": {
+          "borderWidth": "md",
+          "borderColor": "colors.adaptive.error.{mode}.border",
+          "borderColorFocus": "colors.adaptive.error.{mode}.border",
+          "helperTextColor": "colors.adaptive.error.{mode}.text"
+        }
+      },
+      "success": {
+        "description": "success variant",
+        "tokens": {
+          "borderWidth": "md",
+          "borderColor": "colors.modes.{mode}.ring",
+          "borderColorFocus": "colors.modes.{mode}.ring",
+          "helperTextColor": "colors.adaptive.success.{mode}.text"
+        }
+      }
+    },
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "fieldHeight": "32px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "radius.scale.lg",
+          "top": "xs",
+          "right": "md",
+          "bottom": "xs",
+          "left": "md"
+        }
+      },
+      "padding": {
+        "tokens": {
+          "top": "xs",
+          "right": "md",
+          "bottom": "xs",
+          "left": "md"
+        }
+      },
+      "md": {
+        "tokens": {
+          "fieldHeight": "40px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "radius.scale.xl",
+          "top": "sm",
+          "right": "md",
+          "bottom": "sm",
+          "left": "md"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "fieldHeight": "48px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "radius.scale.2xl",
+          "top": "xl",
+          "right": "lg",
+          "bottom": "xl",
+          "left": "lg"
+        }
+      }
+    }
+  },
+  "select": {
+    "description": "Unified text field component supporting input, select, and textarea",
+    "variants": {
+      "default": {
+        "description": "default variant",
+        "tokens": {
+          "borderWidth": "md",
+          "borderColor": "colors.modes.{mode}.borderPrimary",
+          "borderColorFocus": "colors.modes.{mode}.borderSecondary",
+          "helperTextColor": "colors.modes.{mode}.textMuted"
+        }
+      },
+      "error": {
+        "description": "error variant",
+        "tokens": {
+          "borderWidth": "md",
+          "borderColor": "colors.adaptive.error.{mode}.border",
+          "borderColorFocus": "colors.adaptive.error.{mode}.border",
+          "helperTextColor": "colors.adaptive.error.{mode}.text"
+        }
+      },
+      "success": {
+        "description": "success variant",
+        "tokens": {
+          "borderWidth": "md",
+          "borderColor": "colors.modes.{mode}.ring",
+          "borderColorFocus": "colors.modes.{mode}.ring",
+          "helperTextColor": "colors.adaptive.success.{mode}.text"
+        }
+      },
+      "disabled": {
+        "description": "disabled variant",
+        "tokens": {
+          "borderWidth": "sm",
+          "borderColor": "colors.modes.{mode}.borderSecondary",
+          "borderColorFocus": "colors.modes.{mode}.borderSecondary",
+          "helperTextColor": "colors.modes.{mode}.textDisabled"
+        }
+      }
+    },
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "fieldHeight": "32px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "radius.scale.lg",
+          "top": "xs",
+          "right": "md",
+          "bottom": "xs",
+          "left": "md"
+        }
+      },
+      "padding": {
+        "tokens": {
+          "top": "xs",
+          "right": "md",
+          "bottom": "xs",
+          "left": "md"
+        }
+      },
+      "md": {
+        "tokens": {
+          "fieldHeight": "44px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "none",
+          "top": "sm",
+          "right": "md",
+          "bottom": "sm",
+          "left": "md"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "fieldHeight": "48px",
+          "helperTypeSet": "helper-text",
+          "borderRadius": "radius.scale.2xl",
+          "top": "xl",
+          "right": "lg",
+          "bottom": "xl",
+          "left": "lg"
+        }
+      }
+    }
+  },
+  "dialog": {
+    "description": "Modal dialog for focused interactions",
+    "variants": {
+      "default": {
+        "description": "default variant",
+        "tokens": {
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textSecondary",
+          "contentAlign": "center",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "buttonAlign": "center"
+        }
+      },
+      "with-footer": {
+        "description": "with-footer variant",
+        "tokens": {
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textSecondary",
+          "contentAlign": "left",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "buttonAlign": "space-between"
+        }
+      },
+      "minimal": {
+        "description": "minimal variant",
+        "tokens": {
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "bodyColor": "colors.modes.{mode}.textMuted",
+          "contentAlign": "center",
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "buttonAlign": "center"
+        }
+      }
+    },
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "headingSize": "sm",
+          "top": "xl",
+          "right": "xl",
+          "bottom": "xl",
+          "left": "xl",
+          "buttonSize": "sm"
+        }
+      },
+      "padding": {
+        "tokens": {
+          "top": "xl",
+          "right": "xl",
+          "bottom": "xl",
+          "left": "xl",
+          "buttonSize": "sm"
+        }
+      },
+      "md": {
+        "tokens": {
+          "headingSize": "md",
+          "top": "xl",
+          "right": "xl",
+          "bottom": "xl",
+          "left": "xl",
+          "buttonSize": "md"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "headingSize": "lg",
+          "top": "xl",
+          "right": "xl",
+          "bottom": "xl",
+          "left": "xl",
+          "buttonSize": "lg"
+        }
+      }
+    },
+    "shared": {
+      "titleFontFamily": "typography.fontFamily.sans",
+      "bodyFontFamily": "typography.fontFamily.sans"
+    }
+  },
+  "heading": {
+    "description": "Typography component for titles, descriptions, and eyebrows",
+    "variants": {
+      "title-only": {
+        "description": "title-only variant",
+        "tokens": {
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "descriptionColor": "colors.modes.{mode}.textSecondary",
+          "textAlign": "left",
+          "eyebrowGap": "xs",
+          "descriptionGap": "sm",
+          "footerGap": "sm"
+        }
+      },
+      "title-description": {
+        "description": "title-description variant",
+        "tokens": {
+          "eyebrowColor": "colors.modes.{mode}.textMuted",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "descriptionColor": "colors.modes.{mode}.textSecondary",
+          "textAlign": "left",
+          "eyebrowGap": "xs",
+          "descriptionGap": "xs",
+          "footerGap": "sm"
+        }
+      },
+      "full": {
+        "description": "full variant",
+        "tokens": {
+          "eyebrowColor": "colors.modes.{mode}.textSecondary",
+          "titleColor": "colors.modes.{mode}.textPrimary",
+          "descriptionColor": "colors.modes.{mode}.textSecondary",
+          "textAlign": "left",
+          "eyebrowGap": "xs",
+          "descriptionGap": "xs",
+          "footerGap": "sm"
+        }
+      }
+    },
+    "sizes": {
+      "sm": {
+        "tokens": {
+          "eyebrowTypeSet": "typography.typeSets.title-sm",
+          "titleTypeSet": "typography.typeSets.title-md",
+          "descriptionTypeSet": "typography.typeSets.text-normal-regular"
+        }
+      },
+      "md": {
+        "tokens": {
+          "eyebrowTypeSet": "typography.typeSets.title-sm",
+          "titleTypeSet": "typography.typeSets.title-lg",
+          "descriptionTypeSet": "typography.typeSets.text-normal-regular"
+        }
+      },
+      "lg": {
+        "tokens": {
+          "eyebrowTypeSet": "typography.typeSets.title-sm",
+          "titleTypeSet": "typography.typeSets.title-2xl",
+          "descriptionTypeSet": "typography.typeSets.text-normal-regular"
+        }
+      }
+    },
+    "shared": {
+      "fontFamily": "typography.fontFamily.sans"
+    }
+  },
+  "selectionControls": {
+    "description": "Selection control components: checkbox, radio, and toggle switch",
+    "variants": {
+      "checkbox": {
+        "description": "checkbox variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "subtle"
+        }
+      },
+      "radio": {
+        "description": "radio variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "subtle"
+        }
+      },
+      "toggle": {
+        "description": "toggle variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "press"
+        }
+      }
+    },
+    "sizes": {
+      "md": {
+        "tokens": {
+          "controlSize": "20px",
+          "labelTypeSet": "typography.typeSets.text-normal-regular",
+          "gap": "spacing.scale.sm",
+          "borderRadius": "radius.scale.lg"
+        }
+      }
+    }
+  },
+  "checkbox": {
+    "description": "Checkbox selection control",
+    "variants": {
+      "default": {
+        "description": "checkbox variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "subtle"
+        }
+      }
+    },
+    "sizes": {
+      "md": {
+        "tokens": {
+          "controlSize": "20px",
+          "labelTypeSet": "typography.typeSets.text-normal-regular",
+          "gap": "spacing.scale.sm",
+          "borderRadius": "radius.scale.lg"
+        }
+      }
+    },
+    "shared": {
+      "transitionDuration": "motion.duration.fast",
+      "focusRing": "shadows.focus.ring"
+    }
+  },
+  "radio": {
+    "description": "Radio selection control",
+    "variants": {
+      "default": {
+        "description": "radio variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "subtle"
+        }
+      }
+    },
+    "sizes": {
+      "md": {
+        "tokens": {
+          "controlSize": "20px",
+          "labelTypeSet": "typography.typeSets.text-normal-regular",
+          "gap": "spacing.scale.sm",
+          "borderRadius": "radius.scale.lg"
+        }
+      }
+    },
+    "shared": {
+      "transitionDuration": "motion.duration.fast",
+      "focusRing": "shadows.focus.ring"
+    }
+  },
+  "toggle": {
+    "description": "Toggle selection control",
+    "variants": {
+      "default": {
+        "description": "toggle variant",
+        "tokens": {
+          "background": "colors.modes.{mode}.bgMuted",
+          "backgroundChecked": "colors.modes.{mode}.actionPrimary",
+          "backgroundDisabled": "colors.modes.{mode}.actionSecondary",
+          "backgroundError": "colors.modes.{mode}.bgMuted",
+          "borderWidth": "md",
+          "borderWidthError": "md",
+          "borderWidthDisabled": "md",
+          "borderColor": "colors.modes.{mode}.borderStrong",
+          "borderColorChecked": "transparent",
+          "borderColorDisabled": "colors.modes.{mode}.borderSecondary",
+          "borderColorError": "colors.adaptive.error.{mode}.border",
+          "indicatorColor": "colors.static.white",
+          "labelColor": "colors.modes.{mode}.textPrimary",
+          "interaction": "press"
+        }
+      }
+    },
+    "sizes": {
+      "md": {
+        "tokens": {
+          "controlSize": "20px",
+          "labelTypeSet": "typography.typeSets.text-normal-regular",
+          "gap": "spacing.scale.sm",
+          "borderRadius": "radius.scale.lg"
+        }
+      }
+    },
+    "shared": {
+      "transitionDuration": "motion.duration.fast",
+      "focusRing": "shadows.focus.ring"
+    }
+  }
+};
+
+// src/user-tokens.ts
+var DEFAULT_BASE_URL = "https://atomixstudio.eu";
+async function fetchUserDesignSystem(options) {
+  const { dsId, apiKey, baseUrl = DEFAULT_BASE_URL } = options;
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const tokensResponse = await fetch(`${baseUrl}/api/ds/${dsId}/tokens`, {
+      method: "GET",
+      headers
+    });
+    if (!tokensResponse.ok) {
+      const error = await tokensResponse.text();
+      return {
+        success: false,
+        error: `Failed to fetch tokens: ${tokensResponse.status} ${error}`
+      };
+    }
+    const tokensData = await tokensResponse.json();
+    const meta = "meta" in tokensData && tokensData.meta ? tokensData.meta : void 0;
+    let governance;
+    try {
+      const rulesResponse = await fetch(`${baseUrl}/api/ds/${dsId}/rules`, {
+        method: "GET",
+        headers
+      });
+      if (rulesResponse.ok) {
+        const rulesData = await rulesResponse.json();
+        governance = rulesData;
+      }
+    } catch {
+      console.error("[atomix-mcp] Could not fetch governance rules, continuing without them");
+    }
+    const tokens = "tokens" in tokensData && tokensData.tokens ? tokensData.tokens : tokensData;
+    return {
+      success: true,
+      tokens,
+      governance,
+      meta
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Network error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function parseCLIArgs(argv = process.argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--ds-id":
+        if (next && !next.startsWith("--")) {
+          args.dsId = next;
+          i++;
+        }
+        break;
+      case "--api-key":
+        if (next && !next.startsWith("--")) {
+          args.apiKey = next;
+          i++;
+        }
+        break;
+      case "--tenant":
+        if (next && !next.startsWith("--")) {
+          args.tenant = next;
+          args.dsId = args.dsId || next;
+          i++;
+        }
+        break;
+      case "--base-url":
+        if (next && !next.startsWith("--")) {
+          args.baseUrl = next;
+          i++;
+        }
+        break;
+    }
+  }
+  return args;
+}
+function isUserDSMode(args) {
+  return Boolean(args.dsId);
+}
+function transformUserTokens(userTokens) {
+  if (userTokens.colors && userTokens.typography && userTokens.spacing) {
+    return userTokens;
+  }
+  if (typeof userTokens.tokens === "object" && userTokens.tokens !== null) {
+    return userTokens.tokens;
+  }
+  return userTokens;
+}
+
+// src/ai-rules-generator.ts
+var AI_TOOLS = {
+  cursor: {
+    id: "cursor",
+    name: "Cursor",
+    rulesFilename: ".cursorrules",
+    rulesPath: ".cursorrules",
+    mcpConfigPath: ".cursor/mcp.json",
+    supportsMarkdown: true,
+    supportsMCP: true,
+    description: "Cursor IDE - AI-first code editor"
+  },
+  copilot: {
+    id: "copilot",
+    name: "GitHub Copilot",
+    rulesFilename: "copilot-instructions.md",
+    rulesPath: ".github/copilot-instructions.md",
+    supportsMarkdown: true,
+    supportsMCP: false,
+    // Uses rules file instead
+    description: "GitHub Copilot in VS Code, JetBrains, etc."
+  },
+  windsurf: {
+    id: "windsurf",
+    name: "Windsurf",
+    rulesFilename: ".windsurfrules",
+    rulesPath: ".windsurfrules",
+    mcpConfigPath: ".windsurf/mcp.json",
+    supportsMarkdown: true,
+    supportsMCP: true,
+    description: "Windsurf Editor by Codeium"
+  },
+  cline: {
+    id: "cline",
+    name: "Cline",
+    rulesFilename: ".clinerules",
+    rulesPath: ".clinerules",
+    supportsMarkdown: true,
+    supportsMCP: true,
+    description: "Cline VS Code extension (formerly Claude Dev)"
+  },
+  continue: {
+    id: "continue",
+    name: "Continue",
+    rulesFilename: ".continuerules",
+    rulesPath: ".continuerules",
+    mcpConfigPath: ".continue/config.json",
+    supportsMarkdown: true,
+    supportsMCP: true,
+    description: "Continue - open source AI code assistant"
+  },
+  zed: {
+    id: "zed",
+    name: "Zed",
+    rulesFilename: ".zed/assistant/rules.md",
+    rulesPath: ".zed/assistant/rules.md",
+    supportsMarkdown: true,
+    supportsMCP: true,
+    description: "Zed Editor with AI assistant"
+  },
+  "claude-desktop": {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    rulesFilename: "",
+    rulesPath: "",
+    mcpConfigPath: "~/Library/Application Support/Claude/claude_desktop_config.json",
+    supportsMarkdown: false,
+    supportsMCP: true,
+    description: "Claude Desktop App by Anthropic"
+  },
+  generic: {
+    id: "generic",
+    name: "Generic AI",
+    rulesFilename: "AI_GUIDELINES.md",
+    rulesPath: "AI_GUIDELINES.md",
+    supportsMarkdown: true,
+    supportsMCP: false,
+    description: "Generic guidelines for any AI tool"
+  }
+};
+function generateMCPConfig(tool, options = {}) {
+  const {
+    serverPath,
+    useNpx = true,
+    dsId,
+    apiKey,
+    tenantId,
+    // Legacy support
+    projectName = "my-project"
+  } = options;
+  const npxCommand = useNpx ? "npx" : "node";
+  const npxArgs = useNpx ? ["@atomixstudio/mcp@latest"] : [serverPath || "./node_modules/@atomixstudio/mcp/dist/index.js"];
+  const effectiveDsId = dsId || tenantId;
+  if (effectiveDsId && effectiveDsId !== "default") {
+    npxArgs.push("--ds-id", effectiveDsId);
+    if (apiKey) {
+      npxArgs.push("--api-key", apiKey);
+    }
+  }
+  switch (tool) {
+    case "cursor": {
+      const config = {
+        mcpServers: {
+          atomix: {
+            command: npxCommand,
+            args: npxArgs
+          }
+        }
+      };
+      return {
+        tool: "cursor",
+        filename: "mcp.json",
+        path: ".cursor/mcp.json",
+        content: JSON.stringify(config, null, 2),
+        instructions: `
+## Cursor MCP Setup
+
+1. Create the file \`.cursor/mcp.json\` in your project root
+2. Paste the configuration below
+3. Restart Cursor IDE
+4. The Atomix MCP server will be available in Cursor's AI features
+
+### Configuration File
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+
+### Verify Setup
+After restarting Cursor, you can verify the MCP server is working by:
+- Opening the AI chat (Cmd/Ctrl + L)
+- Asking: "What design tokens are available?"
+- The AI should query the Atomix MCP server and list token categories
+`.trim()
+      };
+    }
+    case "claude-desktop": {
+      const config = {
+        mcpServers: {
+          atomix: {
+            command: npxCommand,
+            args: npxArgs
+          }
+        }
+      };
+      const configPath = process.platform === "darwin" ? "~/Library/Application Support/Claude/claude_desktop_config.json" : process.platform === "win32" ? "%APPDATA%\\Claude\\claude_desktop_config.json" : "~/.config/Claude/claude_desktop_config.json";
+      return {
+        tool: "claude-desktop",
+        filename: "claude_desktop_config.json",
+        path: configPath,
+        content: JSON.stringify(config, null, 2),
+        instructions: `
+## Claude Desktop MCP Setup
+
+1. Locate your Claude Desktop config file:
+   - **macOS**: \`${configPath}\`
+   - **Windows**: \`%APPDATA%\\Claude\\claude_desktop_config.json\`
+   - **Linux**: \`~/.config/Claude/claude_desktop_config.json\`
+
+2. Create or edit the file with the configuration below
+
+3. Restart Claude Desktop
+
+4. The Atomix MCP server will be available when chatting with Claude
+
+### Configuration File
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+
+### Verify Setup
+After restarting Claude Desktop:
+- Start a new conversation
+- Ask: "Can you check what Atomix design tokens are available?"
+- Claude should use the MCP server to query tokens
+`.trim()
+      };
+    }
+    case "windsurf": {
+      const config = {
+        mcpServers: {
+          atomix: {
+            command: npxCommand,
+            args: npxArgs
+          }
+        }
+      };
+      return {
+        tool: "windsurf",
+        filename: "mcp.json",
+        path: ".windsurf/mcp.json",
+        content: JSON.stringify(config, null, 2),
+        instructions: `
+## Windsurf MCP Setup
+
+1. Create the file \`.windsurf/mcp.json\` in your project root
+2. Paste the configuration below
+3. Restart Windsurf Editor
+4. The Atomix MCP server will be available in Cascade
+
+### Configuration File
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+`.trim()
+      };
+    }
+    case "continue": {
+      const config = {
+        models: [],
+        mcpServers: [
+          {
+            name: "atomix",
+            command: npxCommand,
+            args: npxArgs
+          }
+        ]
+      };
+      return {
+        tool: "continue",
+        filename: "config.json",
+        path: ".continue/config.json",
+        content: JSON.stringify(config, null, 2),
+        instructions: `
+## Continue MCP Setup
+
+1. Create or edit \`.continue/config.json\` in your project root
+2. Add the mcpServers section below
+3. Restart VS Code
+4. The Atomix MCP server will be available in Continue
+
+### Configuration File
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+
+Note: If you already have a config.json, merge the mcpServers array.
+`.trim()
+      };
+    }
+    case "vscode": {
+      return {
+        tool: "vscode",
+        filename: "settings.json",
+        path: ".vscode/settings.json",
+        content: JSON.stringify({
+          "mcp.servers": {
+            atomix: {
+              command: npxCommand,
+              args: npxArgs
+            }
+          }
+        }, null, 2),
+        instructions: `
+## VS Code MCP Setup
+
+For VS Code, MCP support depends on your AI extension:
+
+### Option 1: Use GitHub Copilot Instructions
+Create \`.github/copilot-instructions.md\` with Atomix rules (use getAIToolRules)
+
+### Option 2: Use Continue Extension
+See Continue setup instructions above
+
+### Option 3: Use Cline Extension
+1. Install Cline extension
+2. Cline will auto-detect MCP servers in .cursor/mcp.json or .vscode/settings.json
+
+### Settings.json (for MCP-aware extensions)
+\`\`\`json
+{
+  "mcp.servers": {
+    "atomix": {
+      "command": "${npxCommand}",
+      "args": ${JSON.stringify(npxArgs)}
+    }
+  }
+}
+\`\`\`
+`.trim()
+      };
+    }
+    default:
+      throw new Error(`Unknown MCP config tool: ${tool}`);
+  }
+}
+function generateAllMCPConfigs(options = {}) {
+  const tools = ["cursor", "claude-desktop", "windsurf", "continue", "vscode"];
+  return tools.map((tool) => generateMCPConfig(tool, options));
+}
+function getSetupInstructions(toolId) {
+  const tool = AI_TOOLS[toolId];
+  if (!tool) {
+    throw new Error(`Unknown AI tool: ${toolId}. Available: ${Object.keys(AI_TOOLS).join(", ")}`);
+  }
+  const baseInstructions = `
+# ${tool.name} Setup for Atomix Design System
+
+${tool.description}
+
+## Overview
+
+${tool.supportsMCP ? `${tool.name} supports MCP (Model Context Protocol), allowing direct integration with the Atomix design token server.` : `${tool.name} uses a rules file to understand the Atomix design system.`}
+
+`;
+  switch (toolId) {
+    case "cursor":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Add MCP Configuration
+
+Create \`.cursor/mcp.json\` in your project root:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "atomix": {
+      "command": "npx",
+      "args": ["@atomixstudio/mcp@latest"]
+    }
+  }
+}
+\`\`\`
+
+### Step 2: Add Rules File (Optional but Recommended)
+
+Create \`.cursorrules\` in your project root with Atomix guidelines.
+Use \`getAIToolRules({ tool: "cursor" })\` to generate this file.
+
+### Step 3: Restart Cursor
+
+After adding the MCP config, restart Cursor IDE completely.
+
+## Verification
+
+1. Open AI chat (Cmd/Ctrl + L)
+2. Ask: "What Atomix design tokens are available?"
+3. Cursor should query the MCP server and respond with token information
+
+## Available MCP Tools
+
+Once configured, you can use these in conversations:
+- \`getToken("colors.static.brand.primary")\` - Get a specific token
+- \`listTokens("colors")\` - List tokens in a category
+- \`getComponentTokens("button")\` - Get component tokens
+- \`validateUsage("#ff0000")\` - Check if a value is allowed
+- \`searchTokens("brand")\` - Search for tokens
+`;
+    case "claude-desktop":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Locate Config File
+
+- **macOS**: \`~/Library/Application Support/Claude/claude_desktop_config.json\`
+- **Windows**: \`%APPDATA%\\Claude\\claude_desktop_config.json\`
+- **Linux**: \`~/.config/Claude/claude_desktop_config.json\`
+
+### Step 2: Add MCP Configuration
+
+Create or edit the config file:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "atomix": {
+      "command": "npx",
+      "args": ["@atomixstudio/mcp@latest"]
+    }
+  }
+}
+\`\`\`
+
+### Step 3: Restart Claude Desktop
+
+Completely quit and reopen Claude Desktop.
+
+## Verification
+
+Start a new conversation and ask:
+"Can you check what Atomix design tokens are available?"
+
+Claude should use the MCP server to query and list tokens.
+`;
+    case "copilot":
+      return baseInstructions + `
+## Quick Setup
+
+GitHub Copilot doesn't support MCP directly, but uses instruction files.
+
+### Step 1: Create Instructions File
+
+Create \`.github/copilot-instructions.md\` in your project:
+
+Use \`getAIToolRules({ tool: "copilot" })\` to generate the content.
+
+### Step 2: Enable Custom Instructions
+
+In VS Code settings, ensure:
+\`\`\`json
+{
+  "github.copilot.chat.codeGeneration.useInstructionFiles": true
+}
+\`\`\`
+
+## Verification
+
+1. Open Copilot Chat
+2. Ask about design tokens
+3. Copilot should follow the Atomix guidelines from the instructions file
+`;
+    case "windsurf":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Add MCP Configuration
+
+Create \`.windsurf/mcp.json\` in your project root:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "atomix": {
+      "command": "npx",
+      "args": ["@atomixstudio/mcp@latest"]
+    }
+  }
+}
+\`\`\`
+
+### Step 2: Add Rules File
+
+Create \`.windsurfrules\` in your project root.
+Use \`getAIToolRules({ tool: "windsurf" })\` to generate this file.
+
+### Step 3: Restart Windsurf
+
+Restart the editor to load the MCP configuration.
+`;
+    case "cline":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Create Rules File
+
+Create \`.clinerules\` in your project root.
+Use \`getAIToolRules({ tool: "cline" })\` to generate this file.
+
+### Step 2: MCP Auto-Detection
+
+Cline can auto-detect MCP servers from:
+- \`.cursor/mcp.json\`
+- Project configuration
+
+If you have Cursor's MCP config, Cline will use it automatically.
+
+### Step 3: Manual MCP Setup (if needed)
+
+In Cline settings, add MCP server configuration:
+- Command: \`npx\`
+- Args: \`@atomixstudio/mcp@latest\`
+`;
+    case "continue":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Add MCP Configuration
+
+Create or edit \`.continue/config.json\`:
+
+\`\`\`json
+{
+  "mcpServers": [
+    {
+      "name": "atomix",
+      "command": "npx",
+      "args": ["@atomixstudio/mcp@latest"]
+    }
+  ]
+}
+\`\`\`
+
+### Step 2: Add Rules File (Optional)
+
+Create \`.continuerules\` in your project root.
+Use \`getAIToolRules({ tool: "continue" })\` to generate this file.
+
+### Step 3: Restart VS Code
+
+Restart VS Code to load the Continue configuration.
+`;
+    case "zed":
+      return baseInstructions + `
+## Quick Setup
+
+### Step 1: Add Rules File
+
+Create \`.zed/assistant/rules.md\` in your project root.
+Use \`getAIToolRules({ tool: "zed" })\` to generate this file.
+
+### Step 2: MCP Configuration
+
+Zed's MCP support is configured in Zed settings.
+Check Zed documentation for the latest MCP configuration format.
+`;
+    default:
+      return baseInstructions + `
+## Generic Setup
+
+### Step 1: Create Guidelines File
+
+Create \`AI_GUIDELINES.md\` in your project root.
+Use \`getAIToolRules({ tool: "generic" })\` to generate this file.
+
+### Step 2: Reference in Prompts
+
+When working with AI tools, reference the guidelines file in your prompts
+or include it in your context.
+`;
+  }
+}
+function generateCursorRules(projectName, strict) {
+  const componentList = Object.keys(COMPONENT_TOKENS).join(", ");
+  const categoryList = TOKEN_CATEGORIES.join(", ");
+  const strictRules = strict ? `
+## Hard Rules (Strict Mode)
+
+1. **NO arbitrary values** \u2014 \`w-[350px]\`, \`bg-[#ff0000]\` are FORBIDDEN
+2. **NO hardcoded colors** \u2014 All colors must use CSS variables or token imports
+3. **NO hardcoded spacing** \u2014 Use \`spacing.*\` tokens (e.g., \`@spacing.md\`, \`@spacing.lg\`)
+4. **NO hardcoded typography** \u2014 Use \`typography.fontSize.*\` and \`typography.fontWeight.*\`
+5. **Token vocabulary only** \u2014 If a value isn't in the design system, don't use it
+
+### Escape Hatch
+
+If external constraints require arbitrary values:
+
+\`\`\`tsx
+{/* @design-override: YouTube embed requires 16:9 aspect ratio */}
+<div className="aspect-[16/9]">
+\`\`\`
+
+Document the reason. The override comment signals intentional deviation.
+` : `
+## Guidelines (Non-Strict Mode)
+
+1. **Prefer tokens** \u2014 Use design system tokens when available
+2. **Document overrides** \u2014 If using arbitrary values, add a comment explaining why
+3. **Consistency** \u2014 Match existing patterns in the codebase
+`;
+  const tierGuidance = `
+## Token Tier System (Critical)
+
+Atomix tokens are organized in tiers. Understanding this hierarchy is essential:
+
+### Tier 1: Primitives (Read-Only Reference)
+
+Raw foundational values. **DO NOT use these directly in components.**
+
+| Type | Example Path | Example Value | Use For |
+|------|-------------|---------------|---------|
+| Color scales | \`colors.scales.green.500\` | \`#10B981\` | Reference only |
+| Spacing scale | \`spacing.md\` | \`1rem\` | Token reference |
+| Font sizes | \`typography.fontSize.sm\` | \`0.875rem\` | Reference only |
+| Radius scale | \`radius.lg\` | \`12px\` | Token reference |
+
+These values are **locked** \u2014 AI tools should never suggest modifying them.
+
+### Tier 2: Semantics (Primary API)
+
+Purpose-driven tokens that reference primitives. **USE THESE in components.**
+
+| Type | Example Path | Maps To | Use For |
+|------|-------------|---------|---------|
+| Mode colors | \`colors.modes.light.bgSurface\` | \`neutral[5]\` | Backgrounds |
+| Semantic radius | \`radius.semantic.button\` | \`scale.md\` | Component corners |
+| TypeSets | \`typography.typeSets.title-lg\` | Composed style | Text styling |
+| Focus rings | \`shadows.focus.ring\` | Composed shadow | A11y focus |
+
+These are **editable via Atomix Designer** and auto-switch for dark mode.
+
+### Tier 3: Component Tokens
+
+Component-specific token assignments. Managed via Atomix Designer.
+
+- Button variants: primary, secondary, outline, ghost
+- Card variants: default, outlined, elevated
+- Sizes: sm, md, lg
+
+---
+
+### Correct Token Usage
+
+\`\`\`tsx
+// \u2705 CORRECT: Use semantic color (Tier 2)
+style={{ backgroundColor: "var(--atomix-bg-surface)" }}
+
+// \u274C WRONG: Using primitive directly (Tier 1)
+style={{ backgroundColor: colors.scales.neutral[5] }}
+
+// \u2705 CORRECT: Use typeSet (Tier 2)
+style={{ ...typography.typeSets["title-lg"] }}
+
+// \u274C WRONG: Using primitive font size (Tier 1)
+style={{ fontSize: typography.fontSize["2xl"] }}
+\`\`\`
+
+### When to Reference Primitives
+
+Primitives are useful for:
+1. **Validation** \u2014 Checking if a hardcoded value matches a token
+2. **Documentation** \u2014 Explaining what a semantic token resolves to
+3. **A11y calculations** \u2014 Contrast ratio checks need actual hex values
+4. **Debug logging** \u2014 Showing resolved values in dev tools
+
+But **NEVER** use primitive paths directly in component styling code.
+`;
+  return `# ${projectName} \u2014 Atomix Design System Rules
+
+This project uses the **Atomix Design System**. All UI code must follow these guidelines.
+
+---
+${strictRules}
+---
+${tierGuidance}
+---
+
+## Token Categories
+
+Available token categories: ${categoryList}
+
+### Color Tokens
+
+Use CSS variables for all colors:
+
+\`\`\`tsx
+// \u2705 Correct
+style={{ backgroundColor: "var(--atomix-bg-surface)" }}
+style={{ color: "var(--atomix-text-primary)" }}
+
+// \u274C Wrong
+style={{ backgroundColor: "#ffffff" }}
+style={{ color: "rgb(0, 0, 0)" }}
+\`\`\`
+
+**Semantic color aliases:**
+- \`--atomix-brand\` \u2014 Primary brand color
+- \`--atomix-bg-page\` \u2014 Page background
+- \`--atomix-bg-surface\` \u2014 Card/surface background
+- \`--atomix-bg-muted\` \u2014 Muted/secondary background
+- \`--atomix-text-primary\` \u2014 Primary text color
+- \`--atomix-text-secondary\` \u2014 Secondary text color
+- \`--atomix-text-muted\` \u2014 Muted/placeholder text
+- \`--atomix-icon-brand\` \u2014 Brand-colored icons
+- \`--atomix-icon-strong\` \u2014 High contrast icons
+- \`--atomix-icon-subtle\` \u2014 Medium contrast icons
+- \`--atomix-icon-disabled\` \u2014 Disabled state icons
+- \`--atomix-border-primary\` \u2014 Default border color
+
+### Spacing Tokens
+
+Use spacing tokens for all padding, margin, and gap values:
+
+\`\`\`tsx
+import { spacing } from "@atomix/tokens/primitives";
+
+// \u2705 Correct
+style={{ padding: spacing.inset.md }}
+style={{ gap: spacing.gap.sm }}
+
+// \u274C Wrong
+style={{ padding: "16px" }}
+style={{ gap: "8px" }}
+\`\`\`
+
+**Spacing scale:** xs, sm, md, lg, xl, 2xl, 3xl
+
+### Typography Tokens
+
+Use typography tokens for font properties:
+
+\`\`\`tsx
+import { typography } from "@atomix/tokens/primitives";
+
+// \u2705 Correct
+style={{ 
+  fontSize: typography.fontSize.sm,
+  fontWeight: typography.fontWeight.medium,
+  lineHeight: typography.lineHeight.normal,
+}}
+
+// \u274C Wrong
+style={{ fontSize: "14px", fontWeight: 500 }}
+\`\`\`
+
+### Motion Tokens
+
+Use motion tokens for animations:
+
+\`\`\`tsx
+import { motion } from "@atomix/tokens/primitives";
+
+// \u2705 Correct
+style={{ 
+  transitionDuration: motion.duration.fast,
+  transitionTimingFunction: motion.easing.ease,
+}}
+
+// \u274C Wrong
+style={{ transition: "all 150ms ease" }}
+\`\`\`
+
+---
+
+## Component Usage
+
+Available components: ${componentList}
+
+### Using the MCP Server
+
+This project has an MCP server for querying design tokens. Use these tools:
+
+- \`getToken("path.to.token")\` \u2014 Get a specific token value
+- \`listTokens("colors")\` \u2014 List all tokens in a category
+- \`getComponentTokens("button")\` \u2014 Get tokens for a component
+- \`validateUsage("value")\` \u2014 Check if a value follows the design system
+- \`searchTokens("brand")\` \u2014 Search for tokens by name or value
+
+### Component Patterns
+
+When implementing components:
+
+1. Check the component tokens first: \`getComponentTokens("componentName")\`
+2. Use the documented variants and sizes
+3. Apply tokens through CSS variables or direct imports
+4. Follow the existing component architecture
+
+---
+
+## Import Patterns
+
+\`\`\`tsx
+// Import primitives for direct use
+import { colors, spacing, typography, motion } from "@atomix/tokens/primitives";
+
+// Or import the combined object
+import { primitives } from "@atomix/tokens";
+
+// Use CSS variables in styles (preferred for colors)
+const style = {
+  backgroundColor: "var(--atomix-bg-surface)",
+  padding: spacing.inset.md,
+  borderRadius: "var(--atomix-radius-scale-md)",
+};
+\`\`\`
+
+---
+
+## Dark Mode
+
+Colors automatically switch in dark mode when using CSS variables:
+
+\`\`\`tsx
+// This works in both light and dark mode
+style={{ 
+  backgroundColor: "var(--atomix-bg-surface)",
+  color: "var(--atomix-text-primary)",
+}}
+\`\`\`
+
+The \`.dark\` class on the root element toggles all color variables.
+
+---
+
+## When Unsure
+
+1. **Search tokens first:** Use \`searchTokens("query")\` to find relevant tokens
+2. **Check component tokens:** Use \`getComponentTokens("component")\` for component-specific values
+3. **Use the nearest token:** If exact match unavailable, use the closest semantic token
+4. **Flag for review:** Add \`{/* TODO: need new token? */}\` comment if a token seems missing
+
+---
+
+## Reference
+
+- Token package: \`@atomix/tokens\`
+- CSS variables: All prefixed with \`--atomix-\`
+- MCP server: \`atomix-mcp\` (run \`npm run start\` in packages/atomix-mcp)
+`;
+}
+function generateRulesForTool(toolId, projectName, strict) {
+  const tool = AI_TOOLS[toolId];
+  if (!tool) {
+    throw new Error(`Unknown AI tool: ${toolId}. Available: ${Object.keys(AI_TOOLS).join(", ")}`);
+  }
+  const header = `<!-- Generated for ${tool.name} by Atomix MCP Server -->
+<!-- Tool: ${tool.description} -->
+<!-- Rules file: ${tool.rulesPath} -->
+<!-- Generated: ${(/* @__PURE__ */ new Date()).toISOString()} -->
+
+`;
+  const content = header + generateCursorRules(projectName, strict);
+  return {
+    tool,
+    filename: tool.rulesFilename,
+    path: tool.rulesPath,
+    content
+  };
+}
+function generateRulesForAllTools(projectName, strict) {
+  return Object.keys(AI_TOOLS).filter((id) => AI_TOOLS[id].rulesPath !== "").map(
+    (toolId) => generateRulesForTool(toolId, projectName, strict)
+  );
+}
+function getSupportedAITools() {
+  return Object.values(AI_TOOLS);
+}
+function generateToolSetupGuide(projectName) {
+  const tools = getSupportedAITools();
+  const mcpTools = tools.filter((t) => t.supportsMCP);
+  const rulesTools = tools.filter((t) => t.rulesPath);
+  return `# AI Tool Setup Guide for ${projectName}
+
+This project uses the **Atomix Design System** with MCP (Model Context Protocol).
+
+## Quick Start
+
+Choose your AI tool and follow the setup:
+
+| Tool | MCP Support | Rules File | Setup Command |
+|------|-------------|------------|---------------|
+${tools.map((t) => `| ${t.name} | ${t.supportsMCP ? "Yes" : "No"} | ${t.rulesPath || "N/A"} | \`getSetupInstructions("${t.id}")\` |`).join("\n")}
+
+## MCP-Enabled Tools (Recommended)
+
+These tools can query Atomix tokens directly:
+
+${mcpTools.map((t) => `- **${t.name}** \u2014 ${t.description}`).join("\n")}
+
+### Generate MCP Config
+
+\`\`\`
+exportMCPConfig({ tool: "cursor" })     // For Cursor
+exportMCPConfig({ tool: "claude-desktop" })  // For Claude Desktop
+exportMCPConfig({ tool: "all" })        // All configs at once
+\`\`\`
+
+## Rules-Based Tools
+
+These tools use instruction files:
+
+${rulesTools.filter((t) => !t.supportsMCP).map((t) => `- **${t.name}** \u2014 \`${t.rulesPath}\``).join("\n")}
+
+### Generate Rules Files
+
+\`\`\`
+getAIToolRules({ tool: "copilot" })     // For GitHub Copilot
+getAIToolRules({ tool: "all" })         // All rules at once
+\`\`\`
+
+## Available MCP Tools
+
+Once connected, AI tools can use:
+
+| Tool | Description |
+|------|-------------|
+| \`getToken\` | Get a specific token by path |
+| \`listTokens\` | List tokens in a category |
+| \`getComponentTokens\` | Get tokens for a component |
+| \`validateUsage\` | Check if a value follows the design system |
+| \`searchTokens\` | Search tokens by name or value |
+| \`exportMCPConfig\` | Generate MCP configuration files |
+| \`getSetupInstructions\` | Get detailed setup instructions |
+
+## Token Tier System
+
+| Tier | Mutable | Use For |
+|------|---------|---------|
+| Primitive | No | Reference only (validation, a11y) |
+| Semantic | Yes (Designer) | Primary API for styling |
+| Component | Yes (Designer) | Component-specific tokens |
+
+**Rule**: Always use semantic tokens in code. Never use primitive paths directly.
+`;
+}
+
+// src/index.ts
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const diffMs = now - timestamp;
+  const diffSec = Math.floor(diffMs / 1e3);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  if (diffSec < 60) return "just now";
+  if (diffMin < 60) return `${diffMin} minute${diffMin > 1 ? "s" : ""} ago`;
+  if (diffHour < 24) return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
+  if (diffDay < 7) return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
+  const date = new Date(timestamp);
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: date.getFullYear() !== (/* @__PURE__ */ new Date()).getFullYear() ? "numeric" : void 0
+  });
+}
+var server = new Server(
+  {
+    name: "atomix-mcp",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "getToken",
+        description: "Get a specific design token by its path. Returns value, CSS variable, and tier metadata. IMPORTANT: Tokens are tiered - 'primitive' tokens are read-only reference values, 'semantic' tokens are the primary API for styling.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Token path in dot notation. Prefer semantic paths (colors.modes.light.bgPage) over primitive paths (colors.scales.green.500)"
+            },
+            tenantId: {
+              type: "string",
+              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')"
+            }
+          },
+          required: ["path"]
+        }
+      },
+      {
+        name: "listTokens",
+        description: "List tokens in a category. Use 'tier' filter to get only semantic tokens (recommended) or primitives (reference only). Semantic tokens are the primary API; primitives are read-only reference values.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              enum: ["colors", "typography", "spacing", "sizing", "shadows", "radius", "motion", "zIndex", "borders"],
+              description: "Token category to list"
+            },
+            subcategory: {
+              type: "string",
+              description: "Optional subcategory, e.g., 'modes.light' for semantic colors, 'scale' for primitive spacing"
+            },
+            tier: {
+              type: "string",
+              enum: ["semantic", "primitive", "all"],
+              description: "Filter by token tier. 'semantic' (recommended) returns purpose-driven tokens for styling. 'primitive' returns raw reference values. Default: 'all'"
+            },
+            tenantId: {
+              type: "string",
+              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')"
+            }
+          },
+          required: ["category"]
+        }
+      },
+      {
+        name: "getComponentTokens",
+        description: "Get all design tokens used by a specific component (Button, Card, Dialog, etc.)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            component: {
+              type: "string",
+              enum: ["button", "card", "dialog", "input", "select", "heading", "checkbox", "radio", "toggle", "selectionControls"],
+              description: "Component name"
+            },
+            variant: {
+              type: "string",
+              description: "Optional variant name (e.g., 'primary', 'outline', 'ghost')"
+            },
+            size: {
+              type: "string",
+              description: "Optional size name (e.g., 'sm', 'md', 'lg')"
+            },
+            tenantId: {
+              type: "string",
+              description: "Tenant ID for multi-tenant support (optional, defaults to 'default')"
+            }
+          },
+          required: ["component"]
+        }
+      },
+      {
+        name: "validateUsage",
+        description: "Check if a CSS value follows the Atomix design system. Detects arbitrary values that should use tokens.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: {
+              type: "string",
+              description: "CSS value to validate, e.g., '#ff0000', '16px', 'rgb(0,112,97)'"
+            },
+            context: {
+              type: "string",
+              enum: ["color", "spacing", "radius", "shadow", "typography", "any"],
+              description: "Context of the value (helps find the right token)"
+            }
+          },
+          required: ["value"]
+        }
+      },
+      {
+        name: "generateCursorRules",
+        description: "[DEPRECATED] Use 'getAIToolRules' instead. Generate .cursorrules content for a project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectName: {
+              type: "string",
+              description: "Name of the project"
+            },
+            strict: {
+              type: "boolean",
+              description: "Whether to enforce strict token usage (no arbitrary values)"
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "getAIToolRules",
+        description: "Generate design system rules for AI coding tools. Supports Cursor, GitHub Copilot, Windsurf, Cline, Continue, Zed, and more.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tool: {
+              type: "string",
+              enum: ["cursor", "copilot", "windsurf", "cline", "continue", "zed", "generic", "all"],
+              description: "AI tool to generate rules for. Use 'all' to generate for all supported tools."
+            },
+            projectName: {
+              type: "string",
+              description: "Name of the project (default: 'My Project')"
+            },
+            strict: {
+              type: "boolean",
+              description: "Enforce strict token usage - no arbitrary values allowed (default: true)"
+            }
+          },
+          required: ["tool"]
+        }
+      },
+      {
+        name: "listAITools",
+        description: "List all supported AI coding tools and their rules file conventions.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "getAIToolSetupGuide",
+        description: "Get a complete setup guide for integrating Atomix with AI coding tools.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectName: {
+              type: "string",
+              description: "Name of the project"
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "exportMCPConfig",
+        description: "Generate MCP configuration file for AI tools. Creates ready-to-use config for Cursor (.cursor/mcp.json), Claude Desktop, Windsurf, Continue, or VS Code.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tool: {
+              type: "string",
+              enum: ["cursor", "claude-desktop", "windsurf", "continue", "vscode", "all"],
+              description: "AI tool to generate MCP config for. Use 'all' to generate for all supported tools."
+            },
+            tenantId: {
+              type: "string",
+              description: "Tenant ID for multi-tenant setups (optional, defaults to 'default')"
+            },
+            projectName: {
+              type: "string",
+              description: "Project name for identification (optional)"
+            },
+            useNpx: {
+              type: "boolean",
+              description: "Use npx to run the server (default: true). Set to false for local development."
+            }
+          },
+          required: ["tool"]
+        }
+      },
+      {
+        name: "getSetupInstructions",
+        description: "Get detailed step-by-step setup instructions for a specific AI tool. Includes MCP configuration, rules file setup, and verification steps.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tool: {
+              type: "string",
+              enum: ["cursor", "copilot", "windsurf", "cline", "continue", "zed", "claude-desktop", "generic"],
+              description: "AI tool to get setup instructions for."
+            }
+          },
+          required: ["tool"]
+        }
+      },
+      {
+        name: "searchTokens",
+        description: "Search for tokens by name or value. Results include tier metadata - prefer using 'semantic' tier tokens in code, use 'primitive' tier only for reference/validation.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query (matches token paths or values)"
+            },
+            tier: {
+              type: "string",
+              enum: ["semantic", "primitive", "all"],
+              description: "Filter results by tier. 'semantic' recommended for styling. Default: 'all'"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  switch (name) {
+    case "getToken": {
+      const path = args?.path;
+      const value = getTokenByPath(primitives2, path);
+      if (value === void 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Token not found: ${path}`,
+                suggestion: `Use listTokens to see available tokens. Available categories: ${getTokenCategories().join(", ")}`
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      const cssVar = getCssVariableName(path);
+      const metadata = getTokenMetadata(path);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              path,
+              value,
+              cssVariable: cssVar,
+              // Token tier classification
+              tier: metadata.tier,
+              mutable: metadata.mutable,
+              editVia: metadata.editVia || null,
+              guidance: metadata.guidance,
+              // Usage examples
+              usage: metadata.tier === "semantic" ? {
+                css: `var(${cssVar})`,
+                tailwind: getTailwindClass(path, value),
+                recommendation: "Use this token in your components."
+              } : {
+                css: `var(${cssVar})`,
+                tailwind: getTailwindClass(path, value),
+                recommendation: "This is a primitive (read-only reference). Consider using a semantic token instead.",
+                semanticAlternatives: getSuggestedSemanticTokens(path)
+              }
+            }, null, 2)
+          }
+        ]
+      };
+    }
+    case "listTokens": {
+      const category = args?.category;
+      const subcategory = args?.subcategory;
+      const tierFilter = args?.tier || "all";
+      const rawTokens = listTokensInCategory(primitives2, category, subcategory);
+      const tokensWithMetadata = {};
+      for (const [tokenPath, value] of Object.entries(rawTokens)) {
+        const fullPath = subcategory ? `${category}.${subcategory}.${tokenPath}` : `${category}.${tokenPath}`;
+        const metadata = getTokenMetadata(fullPath);
+        if (tierFilter !== "all" && metadata.tier !== tierFilter) {
+          continue;
+        }
+        tokensWithMetadata[tokenPath] = {
+          value,
+          tier: metadata.tier,
+          mutable: metadata.mutable,
+          guidance: metadata.guidance
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              category,
+              subcategory: subcategory || null,
+              tierFilter,
+              count: Object.keys(tokensWithMetadata).length,
+              note: tierFilter === "all" ? "Results include both primitive (read-only) and semantic (usable) tokens. Use tier='semantic' for styling recommendations." : tierFilter === "semantic" ? "Showing semantic tokens - these are the recommended tokens for styling." : "Showing primitive tokens - use these for reference/validation only, not direct styling.",
+              tokens: tokensWithMetadata
+            }, null, 2)
+          }
+        ]
+      };
+    }
+    case "getComponentTokens": {
+      const component = args?.component;
+      const variant = args?.variant;
+      const size = args?.size;
+      const componentKey = component.toLowerCase();
+      const componentData = COMPONENT_TOKENS[componentKey];
+      if (!componentData) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Component not found: ${component}`,
+                available: Object.keys(COMPONENT_TOKENS)
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      let result = { ...componentData };
+      if (variant && result.variants) {
+        result.variants = { [variant]: result.variants[variant] };
+      }
+      if (size && result.sizes) {
+        result.sizes = { [size]: result.sizes[size] };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+    case "validateUsage": {
+      const value = args?.value;
+      const context = args?.context || "any";
+      const validation = validateValue(value, context);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(validation, null, 2)
+          }
+        ]
+      };
+    }
+    case "generateCursorRules": {
+      const projectName = args?.projectName || "My Project";
+      const strict = args?.strict ?? true;
+      const rules = generateCursorRules(projectName, strict);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `<!-- DEPRECATED: Use getAIToolRules instead -->
+${rules}`
+          }
+        ]
+      };
+    }
+    case "getAIToolRules": {
+      const tool = args?.tool;
+      const projectName = args?.projectName || "My Project";
+      const strict = args?.strict ?? true;
+      if (tool === "all") {
+        const allRules = generateRulesForAllTools(projectName, strict);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                message: `Generated rules for ${allRules.length} AI tools`,
+                tools: allRules.map((r) => ({
+                  tool: r.tool.name,
+                  filename: r.filename,
+                  path: r.path,
+                  description: r.tool.description
+                })),
+                files: allRules.map((r) => ({
+                  path: r.path,
+                  content: r.content
+                }))
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      try {
+        const result = generateRulesForTool(tool, projectName, strict);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                tool: result.tool.name,
+                filename: result.filename,
+                path: result.path,
+                description: result.tool.description,
+                content: result.content
+              }, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: String(error),
+                availableTools: Object.keys(AI_TOOLS)
+              }, null, 2)
+            }
+          ]
+        };
+      }
+    }
+    case "listAITools": {
+      const tools = getSupportedAITools();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              count: tools.length,
+              tools: tools.map((t) => ({
+                id: t.id,
+                name: t.name,
+                rulesFile: t.rulesPath,
+                description: t.description
+              })),
+              note: "Use getAIToolRules({ tool: 'toolId' }) to generate rules for a specific tool."
+            }, null, 2)
+          }
+        ]
+      };
+    }
+    case "getAIToolSetupGuide": {
+      const projectName = args?.projectName || "My Project";
+      const guide = generateToolSetupGuide(projectName);
+      return {
+        content: [
+          {
+            type: "text",
+            text: guide
+          }
+        ]
+      };
+    }
+    case "exportMCPConfig": {
+      const tool = args?.tool;
+      const tenantId = args?.tenantId || "default";
+      const projectName = args?.projectName || "my-project";
+      const useNpx = args?.useNpx ?? true;
+      const options = { tenantId, projectName, useNpx };
+      if (tool === "all") {
+        const allConfigs = generateAllMCPConfigs(options);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                message: `Generated MCP configs for ${allConfigs.length} AI tools`,
+                configs: allConfigs.map((c) => ({
+                  tool: c.tool,
+                  path: c.path,
+                  filename: c.filename
+                })),
+                files: allConfigs.map((c) => ({
+                  tool: c.tool,
+                  path: c.path,
+                  content: c.content,
+                  instructions: c.instructions
+                }))
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      try {
+        const config = generateMCPConfig(tool, options);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                tool: config.tool,
+                path: config.path,
+                filename: config.filename,
+                content: config.content,
+                instructions: config.instructions
+              }, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: String(error),
+                availableTools: ["cursor", "claude-desktop", "windsurf", "continue", "vscode", "all"]
+              }, null, 2)
+            }
+          ]
+        };
+      }
+    }
+    case "getSetupInstructions": {
+      const toolId = args?.tool;
+      try {
+        const instructions = getSetupInstructions(toolId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: instructions
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: String(error),
+                availableTools: Object.keys(AI_TOOLS)
+              }, null, 2)
+            }
+          ]
+        };
+      }
+    }
+    case "searchTokens": {
+      const query = (args?.query).toLowerCase();
+      const tierFilter = args?.tier || "all";
+      const allTokens = flattenTokens(primitives2);
+      const matches = Object.entries(allTokens).filter(([path, value]) => {
+        const pathLower = path.toLowerCase();
+        const valueStr = String(value).toLowerCase();
+        const matchesQuery = pathLower.includes(query) || valueStr.includes(query);
+        if (!matchesQuery) return false;
+        if (tierFilter !== "all") {
+          const metadata = getTokenMetadata(path);
+          if (metadata.tier !== tierFilter) return false;
+        }
+        return true;
+      }).slice(0, 50).map(([path, value]) => {
+        const metadata = getTokenMetadata(path);
+        return {
+          path,
+          value,
+          cssVariable: getCssVariableName(path),
+          tier: metadata.tier,
+          mutable: metadata.mutable,
+          guidance: metadata.guidance
+        };
+      });
+      matches.sort((a, b) => {
+        if (a.tier === "semantic" && b.tier !== "semantic") return -1;
+        if (a.tier !== "semantic" && b.tier === "semantic") return 1;
+        return 0;
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              query,
+              tierFilter,
+              count: matches.length,
+              note: "Semantic tokens are listed first. Use semantic tokens for styling; primitives are for reference only.",
+              matches
+            }, null, 2)
+          }
+        ]
+      };
+    }
+    default:
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Unknown tool: ${name}` })
+          }
+        ]
+      };
+  }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "atomix://tokens/all",
+        name: "All Atomix Tokens",
+        description: "Complete design token reference",
+        mimeType: "application/json"
+      },
+      {
+        uri: "atomix://tokens/colors",
+        name: "Color Tokens",
+        description: "All color tokens (static, scales, modes)",
+        mimeType: "application/json"
+      },
+      {
+        uri: "atomix://tokens/typography",
+        name: "Typography Tokens",
+        description: "Font families, sizes, weights, line heights",
+        mimeType: "application/json"
+      },
+      {
+        uri: "atomix://tokens/spacing",
+        name: "Spacing Tokens",
+        description: "Spacing scale, insets, gaps",
+        mimeType: "application/json"
+      },
+      {
+        uri: "atomix://components",
+        name: "Component Tokens",
+        description: "Token mappings for all components",
+        mimeType: "application/json"
+      }
+    ]
+  };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const uri = request.params.uri;
+  switch (uri) {
+    case "atomix://tokens/all":
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(primitives2, null, 2)
+          }
+        ]
+      };
+    case "atomix://tokens/colors":
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(primitives2.colors, null, 2)
+          }
+        ]
+      };
+    case "atomix://tokens/typography":
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(primitives2.typography, null, 2)
+          }
+        ]
+      };
+    case "atomix://tokens/spacing":
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(primitives2.spacing, null, 2)
+          }
+        ]
+      };
+    case "atomix://components":
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(COMPONENT_TOKENS, null, 2)
+          }
+        ]
+      };
+    default:
+      throw new Error(`Unknown resource: ${uri}`);
+  }
+});
+function getTailwindClass(path, value) {
+  if (path.startsWith("colors.static.brand.primary")) return "bg-brand text-brand";
+  if (path.startsWith("spacing.") && !path.includes(".inset")) {
+    const size = path.split(".").pop();
+    return `p-${size} m-${size} gap-${size}`;
+  }
+  if (path.startsWith("radius.")) {
+    const size = path.split(".").pop();
+    return `rounded-${size}`;
+  }
+  return null;
+}
+function getSuggestedSemanticTokens(primitivePath) {
+  const suggestions = [];
+  if (primitivePath.startsWith("colors.scales.")) {
+    suggestions.push(
+      "colors.modes.light.bgPage (page background)",
+      "colors.modes.light.bgSurface (card/panel background)",
+      "colors.modes.light.textPrimary (main text)",
+      "colors.modes.light.borderPrimary (borders)",
+      "colors.modes.light.actionPrimary (interactive elements)"
+    );
+  }
+  if (primitivePath.startsWith("spacing.")) {
+    suggestions.push(
+      "Use spacing tokens (spacing.xs, spacing.sm, spacing.md, spacing.lg, etc.)",
+      "These resolve to CSS variables automatically"
+    );
+  }
+  if (primitivePath.startsWith("typography.fontSize.")) {
+    suggestions.push(
+      "typography.typeSets.title-lg (large titles)",
+      "typography.typeSets.title-md (medium titles)",
+      "typography.typeSets.text-normal-regular (body text)",
+      "typography.typeSets.label-md (form labels)"
+    );
+  }
+  if (primitivePath.startsWith("radius.")) {
+    suggestions.push(
+      "Use radius tokens (radius.sm, radius.md, radius.lg, radius.full, etc.)",
+      "Describe semantic usage in AI guidance (e.g., 'Buttons use @radius.md')"
+    );
+  }
+  if (primitivePath.startsWith("shadows.elevation.")) {
+    suggestions.push(
+      "Use elevation keys (none, sm, md, lg, xl) in component defaults",
+      "These resolve to CSS variables automatically"
+    );
+  }
+  return suggestions;
+}
+function validateValue(value, context) {
+  if (/^#[0-9A-Fa-f]{3,8}$/.test(value)) {
+    const allTokens = flattenTokens(primitives2);
+    const matches = Object.entries(allTokens).filter(([path, v]) => {
+      if (typeof v !== "string") return false;
+      return v.toLowerCase() === value.toLowerCase();
+    }).map(([path, v]) => ({
+      path,
+      value: v,
+      cssVariable: getCssVariableName(path)
+    }));
+    if (matches.length > 0) {
+      return {
+        valid: false,
+        issue: "Hardcoded hex color detected",
+        suggestion: `Use token instead: ${matches[0].cssVariable}`,
+        matchingTokens: matches
+      };
+    }
+    return {
+      valid: false,
+      issue: "Hardcoded hex color with no matching token",
+      suggestion: "Check colors.static, colors.scales, or colors.modes for appropriate tokens"
+    };
+  }
+  if (/^(rgb|rgba|hsl|hsla)\(/.test(value)) {
+    return {
+      valid: false,
+      issue: "Hardcoded color function detected",
+      suggestion: "Use CSS variable: var(--atomix-colors-*) or primitives.colors.*"
+    };
+  }
+  if (context === "spacing" && /^\d+px$/.test(value)) {
+    return {
+      valid: false,
+      issue: "Hardcoded pixel value for spacing",
+      suggestion: "Use spacing.* tokens (e.g., @spacing.md, @spacing.lg)"
+    };
+  }
+  if (/^\d+px$/.test(value)) {
+    return {
+      valid: false,
+      issue: "Hardcoded pixel value detected",
+      suggestion: "Consider using design tokens from spacing, sizing, or typography"
+    };
+  }
+  if (/\[.*\]/.test(value)) {
+    return {
+      valid: false,
+      issue: "Tailwind arbitrary value detected",
+      suggestion: "Replace with token-based class or CSS variable"
+    };
+  }
+  return { valid: true };
+}
+var primitives2 = {};
+var userGovernance;
+var isUserMode = false;
+var userDsId;
+async function main() {
+  const cliArgs = parseCLIArgs();
+  if (isUserDSMode(cliArgs)) {
+    console.error(`[atomix-mcp] User DS mode: loading design system ${cliArgs.dsId}`);
+    isUserMode = true;
+    userDsId = cliArgs.dsId;
+    const result = await fetchUserDesignSystem({
+      dsId: cliArgs.dsId,
+      apiKey: cliArgs.apiKey,
+      baseUrl: cliArgs.baseUrl
+    });
+    if (!result.success || !result.tokens) {
+      console.error(`[atomix-mcp] Failed to load user DS: ${result.error}`);
+      console.error("[atomix-mcp] Falling back to Atomix internal tokens");
+      primitives2 = await loadPrimitives();
+    } else {
+      primitives2 = transformUserTokens(result.tokens);
+      userGovernance = result.governance;
+      const meta = result.meta;
+      const dsName = meta?.name || cliArgs.dsId;
+      const tokenCategories = Object.keys(primitives2);
+      const rulesCount = userGovernance?.rules?.length || 0;
+      console.error("");
+      console.error(`[atomix-mcp] ========================================`);
+      console.error(`[atomix-mcp]  Design System: ${dsName}`);
+      console.error(`[atomix-mcp] ----------------------------------------`);
+      if (meta?.publishedAt) {
+        const publishedDate = new Date(meta.publishedAt);
+        const timeAgo = formatTimeAgo(meta.publishedAt);
+        console.error(`[atomix-mcp]  Published: ${timeAgo}`);
+        console.error(`[atomix-mcp]            (${publishedDate.toLocaleString()})`);
+      }
+      if (meta?.version) {
+        console.error(`[atomix-mcp]  Version: ${meta.version}`);
+      }
+      console.error(`[atomix-mcp] ----------------------------------------`);
+      console.error(`[atomix-mcp]  Tokens: ${tokenCategories.length} categories`);
+      console.error(`[atomix-mcp]          ${tokenCategories.join(", ")}`);
+      console.error(`[atomix-mcp]  Rules: ${rulesCount} governance rules`);
+      console.error(`[atomix-mcp] ========================================`);
+      console.error("");
+    }
+  } else {
+    console.error("[atomix-mcp] Loading Atomix internal primitives...");
+    primitives2 = await loadPrimitives();
+    console.error(`[atomix-mcp] Loaded ${Object.keys(primitives2).length} token categories`);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[atomix-mcp] Atomix MCP server started");
+  if (isUserMode) {
+    console.error(`[atomix-mcp] Serving design system: ${userDsId}`);
+  }
+}
+main().catch((error) => {
+  console.error("[atomix-mcp] Fatal error:", error);
+  process.exit(1);
+});
+export {
+  AI_TOOLS,
+  fetchUserDesignSystem,
+  generateAllMCPConfigs,
+  generateCursorRules,
+  generateMCPConfig,
+  generateRulesForAllTools,
+  generateRulesForTool,
+  generateToolSetupGuide,
+  getSetupInstructions,
+  getSupportedAITools,
+  isUserDSMode,
+  parseCLIArgs,
+  transformUserTokens
+};
+//# sourceMappingURL=index.js.map