react-mcu 1.3.0 → 1.3.2

package/dist/cli.js

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs from "fs";
+import * as path from "path";
+import { Command, Option } from "commander";
+
+// src/lib/builder.ts
+import {
+  argbFromHex,
+  Blend,
+  blueFromArgb,
+  DynamicColor,
+  DynamicScheme,
+  greenFromArgb,
+  Hct,
+  hexFromArgb,
+  MaterialDynamicColors,
+  redFromArgb,
+  SchemeContent,
+  SchemeExpressive,
+  SchemeFidelity,
+  SchemeMonochrome,
+  SchemeNeutral,
+  SchemeTonalSpot,
+  SchemeVibrant,
+  TonalPalette
+} from "@material/material-color-utilities";
+import { kebabCase, startCase, upperFirst } from "lodash-es";
+function adjustToneForContrast(baseTone, contrastLevel, adjustmentFactor = DEFAULT_CONTRAST_ADJUSTMENT_FACTOR) {
+  if (contrastLevel === 0) return baseTone;
+  const distanceToCenter = baseTone - 50;
+  const delta = distanceToCenter * contrastLevel * adjustmentFactor;
+  const adjustedTone = baseTone + delta;
+  return Math.max(0, Math.min(100, adjustedTone));
+}
+var schemeNames = [
+  "tonalSpot",
+  "monochrome",
+  "neutral",
+  "vibrant",
+  "expressive",
+  "fidelity",
+  "content"
+];
+var schemesMap = {
+  tonalSpot: SchemeTonalSpot,
+  monochrome: SchemeMonochrome,
+  neutral: SchemeNeutral,
+  vibrant: SchemeVibrant,
+  expressive: SchemeExpressive,
+  fidelity: SchemeFidelity,
+  content: SchemeContent
+};
+var DEFAULT_SCHEME = "tonalSpot";
+var DEFAULT_CONTRAST = 0;
+var DEFAULT_CUSTOM_COLORS = [];
+var DEFAULT_CONTRAST_ALL_COLORS = false;
+var DEFAULT_ADAPTIVE_SHADES = false;
+var DEFAULT_BLEND = true;
+var DEFAULT_CONTRAST_ADJUSTMENT_FACTOR = 0.2;
+var STANDARD_TONES = [
+  0,
+  5,
+  10,
+  15,
+  20,
+  25,
+  30,
+  35,
+  40,
+  50,
+  60,
+  70,
+  80,
+  90,
+  95,
+  98,
+  99,
+  100
+];
+var Variant = {
+  MONOCHROME: 0,
+  NEUTRAL: 1,
+  TONAL_SPOT: 2,
+  VIBRANT: 3,
+  EXPRESSIVE: 4,
+  FIDELITY: 5,
+  CONTENT: 6,
+  RAINBOW: 7,
+  FRUIT_SALAD: 8
+};
+var schemeToVariant = {
+  monochrome: Variant.MONOCHROME,
+  neutral: Variant.NEUTRAL,
+  tonalSpot: Variant.TONAL_SPOT,
+  vibrant: Variant.VIBRANT,
+  expressive: Variant.EXPRESSIVE,
+  fidelity: Variant.FIDELITY,
+  content: Variant.CONTENT
+};
+var tokenNames = [
+  "background",
+  "error",
+  "errorContainer",
+  "inverseOnSurface",
+  "inversePrimary",
+  "inverseSurface",
+  "onBackground",
+  "onError",
+  "onErrorContainer",
+  "onPrimary",
+  "onPrimaryContainer",
+  "onPrimaryFixed",
+  "onPrimaryFixedVariant",
+  "onSecondary",
+  "onSecondaryContainer",
+  "onSecondaryFixed",
+  "onSecondaryFixedVariant",
+  "onSurface",
+  "onSurfaceVariant",
+  "onTertiary",
+  "onTertiaryContainer",
+  "onTertiaryFixed",
+  "onTertiaryFixedVariant",
+  "outline",
+  "outlineVariant",
+  "primary",
+  "primaryContainer",
+  "primaryFixed",
+  "primaryFixedDim",
+  "scrim",
+  "secondary",
+  "secondaryContainer",
+  "secondaryFixed",
+  "secondaryFixedDim",
+  "shadow",
+  "surface",
+  "surfaceBright",
+  "surfaceContainer",
+  "surfaceContainerHigh",
+  "surfaceContainerHighest",
+  "surfaceContainerLow",
+  "surfaceContainerLowest",
+  "surfaceDim",
+  "surfaceTint",
+  "surfaceVariant",
+  "tertiary",
+  "tertiaryContainer",
+  "tertiaryFixed",
+  "tertiaryFixedDim"
+];
+function toRecord(arr, getEntry) {
+  return Object.fromEntries(arr.map(getEntry));
+}
+function getPalette(palettes, colorName) {
+  const palette = palettes[colorName];
+  if (!palette) {
+    throw new Error(
+      `Custom color palette not found for '${colorName}'. This is likely a bug in the implementation.`
+    );
+  }
+  return palette;
+}
+function mergeBaseAndCustomColors(scheme, customColors, colorPalettes, contrastAllColors) {
+  const baseVars = toRecord(tokenNames, (tokenName) => {
+    const dynamicColor = MaterialDynamicColors[tokenName];
+    const argb = dynamicColor.getArgb(scheme);
+    return [tokenName, argb];
+  });
+  const customVars = {};
+  customColors.forEach((color) => {
+    const colorname = color.name;
+    const getPaletteForColor = (s) => getPalette(colorPalettes, colorname);
+    const getTone = (baseTone) => (s) => {
+      if (!contrastAllColors) return baseTone;
+      return adjustToneForContrast(baseTone, s.contrastLevel);
+    };
+    const colorDynamicColor = new DynamicColor(
+      colorname,
+      getPaletteForColor,
+      (s) => getTone(s.isDark ? 80 : 40)(s),
+      // Main color: lighter in dark mode, darker in light mode
+      true
+      // background
+    );
+    const onColorDynamicColor = new DynamicColor(
+      `on${upperFirst(colorname)}`,
+      getPaletteForColor,
+      (s) => getTone(s.isDark ? 20 : 100)(s),
+      // Text on main color: high contrast (dark on light, light on dark)
+      false
+    );
+    const containerDynamicColor = new DynamicColor(
+      `${colorname}Container`,
+      getPaletteForColor,
+      (s) => getTone(s.isDark ? 30 : 90)(s),
+      // Container: subtle variant (darker in dark mode, lighter in light mode)
+      true
+      // background
+    );
+    const onContainerDynamicColor = new DynamicColor(
+      `on${upperFirst(colorname)}Container`,
+      getPaletteForColor,
+      (s) => getTone(s.isDark ? 90 : 30)(s),
+      // Text on container: high contrast against container background
+      false
+    );
+    customVars[colorname] = colorDynamicColor.getArgb(scheme);
+    customVars[`on${upperFirst(colorname)}`] = onColorDynamicColor.getArgb(scheme);
+    customVars[`${colorname}Container`] = containerDynamicColor.getArgb(scheme);
+    customVars[`on${upperFirst(colorname)}Container`] = onContainerDynamicColor.getArgb(scheme);
+  });
+  return { ...baseVars, ...customVars };
+}
+function createColorPalette(colorDef, baseScheme, effectiveSourceForHarmonization) {
+  const colorArgb = argbFromHex(colorDef.hex);
+  const harmonizedArgb = colorDef.blend ? Blend.harmonize(colorArgb, effectiveSourceForHarmonization) : colorArgb;
+  const hct = Hct.fromInt(harmonizedArgb);
+  let targetChroma;
+  if (colorDef.core && colorDef.chromaSource) {
+    if (colorDef.chromaSource === "neutral") {
+      targetChroma = baseScheme.neutralPalette.chroma;
+    } else if (colorDef.chromaSource === "neutralVariant") {
+      targetChroma = baseScheme.neutralVariantPalette.chroma;
+    } else {
+      targetChroma = baseScheme.primaryPalette.chroma;
+    }
+  } else {
+    targetChroma = baseScheme.primaryPalette.chroma;
+  }
+  return TonalPalette.fromHueAndChroma(hct.hue, targetChroma);
+}
+function builder(hexSource, {
+  scheme = DEFAULT_SCHEME,
+  contrast = DEFAULT_CONTRAST,
+  primary,
+  secondary,
+  tertiary,
+  neutral,
+  neutralVariant,
+  error,
+  customColors: hexCustomColors = DEFAULT_CUSTOM_COLORS,
+  contrastAllColors = DEFAULT_CONTRAST_ALL_COLORS,
+  adaptiveShades = DEFAULT_ADAPTIVE_SHADES
+} = {}) {
+  const sourceArgb = argbFromHex(hexSource);
+  const sourceHct = Hct.fromInt(sourceArgb);
+  const effectiveSource = primary || hexSource;
+  const effectiveSourceArgb = argbFromHex(effectiveSource);
+  const effectiveSourceForHarmonization = primary ? argbFromHex(primary) : sourceArgb;
+  const SchemeClass = schemesMap[scheme];
+  const primaryHct = Hct.fromInt(effectiveSourceArgb);
+  const baseScheme = new SchemeClass(primaryHct, false, contrast);
+  const allColors = [
+    // Core colors (hex may be undefined)
+    {
+      name: "primary",
+      hex: primary,
+      core: true,
+      chromaSource: "primary"
+    },
+    {
+      name: "secondary",
+      hex: secondary,
+      core: true,
+      chromaSource: "primary"
+    },
+    {
+      name: "tertiary",
+      hex: tertiary,
+      core: true,
+      chromaSource: "primary"
+    },
+    { name: "error", hex: error, core: true, chromaSource: "primary" },
+    {
+      name: "neutral",
+      hex: neutral,
+      core: true,
+      chromaSource: "neutral"
+    },
+    {
+      name: "neutralVariant",
+      hex: neutralVariant,
+      core: true,
+      chromaSource: "neutralVariant"
+    },
+    //
+    // Custom colors
+    //
+    ...hexCustomColors.map((c) => ({
+      name: c.name,
+      hex: c.hex,
+      blend: c.blend,
+      core: false
+    }))
+  ];
+  const definedColors = allColors.filter(
+    (c) => c.hex !== void 0
+  );
+  const colorPalettes = Object.fromEntries(
+    definedColors.map((colorDef) => [
+      colorDef.name,
+      createColorPalette(colorDef, baseScheme, effectiveSourceForHarmonization)
+    ])
+  );
+  const variant = schemeToVariant[scheme];
+  const schemeConfig = {
+    sourceColorArgb: effectiveSourceArgb,
+    variant,
+    contrastLevel: contrast,
+    primaryPalette: colorPalettes["primary"] || baseScheme.primaryPalette,
+    secondaryPalette: colorPalettes["secondary"] || baseScheme.secondaryPalette,
+    tertiaryPalette: colorPalettes["tertiary"] || baseScheme.tertiaryPalette,
+    neutralPalette: colorPalettes["neutral"] || baseScheme.neutralPalette,
+    neutralVariantPalette: colorPalettes["neutralVariant"] || baseScheme.neutralVariantPalette
+  };
+  const lightScheme = new DynamicScheme({ ...schemeConfig, isDark: false });
+  const darkScheme = new DynamicScheme({ ...schemeConfig, isDark: true });
+  const errorPalette = colorPalettes["error"];
+  if (errorPalette) {
+    lightScheme.errorPalette = errorPalette;
+    darkScheme.errorPalette = errorPalette;
+  }
+  const allPalettes = {
+    primary: lightScheme.primaryPalette,
+    secondary: lightScheme.secondaryPalette,
+    tertiary: lightScheme.tertiaryPalette,
+    error: lightScheme.errorPalette,
+    neutral: lightScheme.neutralPalette,
+    "neutral-variant": lightScheme.neutralVariantPalette,
+    // Add custom color palettes
+    ...Object.fromEntries(
+      definedColors.filter((c) => !c.core).map((colorDef) => [colorDef.name, colorPalettes[colorDef.name]])
+    )
+  };
+  const customColors = definedColors.filter((c) => !c.core).map((c) => ({
+    name: c.name,
+    blend: c.blend ?? DEFAULT_BLEND,
+    value: argbFromHex(c.hex)
+  }));
+  const mergedColorsLight = mergeBaseAndCustomColors(
+    lightScheme,
+    customColors,
+    colorPalettes,
+    contrastAllColors
+  );
+  const mergedColorsDark = mergeBaseAndCustomColors(
+    darkScheme,
+    customColors,
+    colorPalettes,
+    contrastAllColors
+  );
+  return {
+    //
+    //  ██████ ███████ ███████
+    // ██      ██      ██
+    // ██      ███████ ███████
+    // ██           ██      ██
+    //  ██████ ███████ ███████
+    //
+    toCss() {
+      function cssVar(colorName, colorValue) {
+        const name = `--mcu-${kebabCase(colorName)}`;
+        const value = hexFromArgb(colorValue);
+        return `${name}:${value};`;
+      }
+      function toCssVars(mergedColors) {
+        return Object.entries(mergedColors).map(([name, value]) => cssVar(name, value)).join(" ");
+      }
+      function generateTonalPaletteVars(paletteName, palette, scheme2, applyContrast, adaptiveShades2) {
+        return STANDARD_TONES.map((tone) => {
+          let toneToUse = tone;
+          if (adaptiveShades2 && scheme2.isDark) {
+            toneToUse = 100 - tone;
+          }
+          if (applyContrast) {
+            toneToUse = adjustToneForContrast(toneToUse, scheme2.contrastLevel);
+          }
+          const color = palette.tone(toneToUse);
+          return cssVar(`${paletteName}-${tone}`, color);
+        }).join(" ");
+      }
+      function generateTonalVars(s) {
+        return Object.entries(allPalettes).map(
+          ([name, palette]) => generateTonalPaletteVars(
+            kebabCase(name),
+            palette,
+            s,
+            contrastAllColors,
+            adaptiveShades
+          )
+        ).join(" ");
+      }
+      const lightVars = toCssVars(mergedColorsLight);
+      const darkVars = toCssVars(mergedColorsDark);
+      const lightTonalVars = generateTonalVars(lightScheme);
+      const darkTonalVars = generateTonalVars(darkScheme);
+      return `
+:root { ${lightVars} ${lightTonalVars} }
+.dark { ${darkVars} ${adaptiveShades ? darkTonalVars : lightTonalVars} }
+`;
+    },
+    //
+    //      ██ ███████  ██████  ███    ██
+    //      ██ ██      ██    ██ ████   ██
+    //      ██ ███████ ██    ██ ██ ██  ██
+    // ██   ██      ██ ██    ██ ██  ██ ██
+    //  █████  ███████  ██████  ██   ████
+    //
+    toJson() {
+      const fixtureTokenOrder = [
+        "primary",
+        "surfaceTint",
+        "onPrimary",
+        "primaryContainer",
+        "onPrimaryContainer",
+        "secondary",
+        "onSecondary",
+        "secondaryContainer",
+        "onSecondaryContainer",
+        "tertiary",
+        "onTertiary",
+        "tertiaryContainer",
+        "onTertiaryContainer",
+        "error",
+        "onError",
+        "errorContainer",
+        "onErrorContainer",
+        "background",
+        "onBackground",
+        "surface",
+        "onSurface",
+        "surfaceVariant",
+        "onSurfaceVariant",
+        "outline",
+        "outlineVariant",
+        "shadow",
+        "scrim",
+        "inverseSurface",
+        "inverseOnSurface",
+        "inversePrimary",
+        "primaryFixed",
+        "onPrimaryFixed",
+        "primaryFixedDim",
+        "onPrimaryFixedVariant",
+        "secondaryFixed",
+        "onSecondaryFixed",
+        "secondaryFixedDim",
+        "onSecondaryFixedVariant",
+        "tertiaryFixed",
+        "onTertiaryFixed",
+        "tertiaryFixedDim",
+        "onTertiaryFixedVariant",
+        "surfaceDim",
+        "surfaceBright",
+        "surfaceContainerLowest",
+        "surfaceContainerLow",
+        "surfaceContainer",
+        "surfaceContainerHigh",
+        "surfaceContainerHighest"
+      ];
+      const neuHct = neutral ? Hct.fromInt(argbFromHex(neutral)) : sourceHct;
+      const nvHct = neutralVariant ? Hct.fromInt(argbFromHex(neutralVariant)) : sourceHct;
+      const rawPalettes = {
+        primary: TonalPalette.fromInt(effectiveSourceArgb),
+        secondary: secondary ? TonalPalette.fromInt(argbFromHex(secondary)) : TonalPalette.fromHueAndChroma(sourceHct.hue, sourceHct.chroma / 3),
+        tertiary: tertiary ? TonalPalette.fromInt(argbFromHex(tertiary)) : TonalPalette.fromHueAndChroma(
+          (sourceHct.hue + 60) % 360,
+          sourceHct.chroma / 2
+        ),
+        neutral: TonalPalette.fromHueAndChroma(
+          neuHct.hue,
+          Math.min(neuHct.chroma / 12, 4)
+        ),
+        "neutral-variant": TonalPalette.fromHueAndChroma(
+          nvHct.hue,
+          Math.min(nvHct.chroma / 6, 8)
+        )
+      };
+      function buildJsonSchemes() {
+        function extractSchemeColors(scheme2, backgroundScheme) {
+          const colors = {};
+          for (const tokenName of fixtureTokenOrder) {
+            const dynamicColor = MaterialDynamicColors[tokenName];
+            const useScheme = backgroundScheme && (tokenName === "background" || tokenName === "onBackground") ? backgroundScheme : scheme2;
+            colors[tokenName] = hexFromArgb(
+              dynamicColor.getArgb(useScheme)
+            ).toUpperCase();
+          }
+          return colors;
+        }
+        function resolveOverridePalette(hex, role) {
+          if (!hex) return null;
+          return new SchemeClass(Hct.fromInt(argbFromHex(hex)), false, 0)[role];
+        }
+        const secPalette = resolveOverridePalette(secondary, "primaryPalette");
+        const terPalette = resolveOverridePalette(tertiary, "primaryPalette");
+        const errPalette = resolveOverridePalette(error, "primaryPalette");
+        const neuPalette = resolveOverridePalette(neutral, "neutralPalette");
+        const nvPalette = resolveOverridePalette(
+          neutralVariant,
+          "neutralVariantPalette"
+        );
+        const jsonSchemes = {};
+        const jsonContrastLevels = [
+          { name: "light", isDark: false, contrast: 0 },
+          { name: "light-medium-contrast", isDark: false, contrast: 0.5 },
+          { name: "light-high-contrast", isDark: false, contrast: 1 },
+          { name: "dark", isDark: true, contrast: 0 },
+          { name: "dark-medium-contrast", isDark: true, contrast: 0.5 },
+          { name: "dark-high-contrast", isDark: true, contrast: 1 }
+        ];
+        for (const { name, isDark, contrast: contrast2 } of jsonContrastLevels) {
+          const baseScheme2 = new SchemeClass(primaryHct, isDark, contrast2);
+          const composedScheme = new DynamicScheme({
+            sourceColorArgb: effectiveSourceArgb,
+            variant: schemeToVariant[scheme],
+            contrastLevel: contrast2,
+            isDark,
+            primaryPalette: baseScheme2.primaryPalette,
+            secondaryPalette: secPalette || baseScheme2.secondaryPalette,
+            tertiaryPalette: terPalette || baseScheme2.tertiaryPalette,
+            neutralPalette: neuPalette || baseScheme2.neutralPalette,
+            neutralVariantPalette: nvPalette || baseScheme2.neutralVariantPalette
+          });
+          if (errPalette) composedScheme.errorPalette = errPalette;
+          jsonSchemes[name] = extractSchemeColors(composedScheme, baseScheme2);
+        }
+        return jsonSchemes;
+      }
+      function rawPalettesToJson() {
+        const jsonPalettes = {};
+        const RAW_PALETTE_NAMES = [
+          "primary",
+          "secondary",
+          "tertiary",
+          "neutral",
+          "neutral-variant"
+        ];
+        for (const name of RAW_PALETTE_NAMES) {
+          const palette = rawPalettes[name];
+          const tones = {};
+          for (const tone of STANDARD_TONES) {
+            tones[tone.toString()] = hexFromArgb(
+              palette.tone(tone)
+            ).toUpperCase();
+          }
+          jsonPalettes[name] = tones;
+        }
+        return jsonPalettes;
+      }
+      function buildCoreColors(opts) {
+        const colors = { primary: opts.primary };
+        if (opts.secondary) colors.secondary = opts.secondary.toUpperCase();
+        if (opts.tertiary) colors.tertiary = opts.tertiary.toUpperCase();
+        if (opts.error) colors.error = opts.error.toUpperCase();
+        if (opts.neutral) colors.neutral = opts.neutral.toUpperCase();
+        if (opts.neutralVariant)
+          colors.neutralVariant = opts.neutralVariant.toUpperCase();
+        return colors;
+      }
+      const seed = hexSource.toUpperCase();
+      const coreColors = buildCoreColors({
+        primary: (primary || hexSource).toUpperCase(),
+        secondary,
+        tertiary,
+        error,
+        neutral,
+        neutralVariant
+      });
+      const extendedColors = hexCustomColors.map((c) => ({
+        name: c.name,
+        color: c.hex.toUpperCase(),
+        description: "",
+        harmonized: c.blend ?? DEFAULT_BLEND
+      }));
+      return {
+        seed,
+        coreColors,
+        extendedColors,
+        schemes: buildJsonSchemes(),
+        palettes: rawPalettesToJson()
+      };
+    },
+    //
+    // ███████ ██  ██████  ███    ███  █████
+    // ██      ██ ██       ████  ████ ██   ██
+    // █████   ██ ██   ███ ██ ████ ██ ███████
+    // ██      ██ ██    ██ ██  ██  ██ ██   ██
+    // ██      ██  ██████  ██      ██ ██   ██
+    //
+    toFigmaTokens() {
+      function argbToFigmaColorValue(argb) {
+        return {
+          colorSpace: "srgb",
+          components: [
+            redFromArgb(argb) / 255,
+            greenFromArgb(argb) / 255,
+            blueFromArgb(argb) / 255
+          ],
+          alpha: 1,
+          hex: hexFromArgb(argb).toUpperCase()
+        };
+      }
+      function figmaToken(argb) {
+        return {
+          $type: "color",
+          $value: argbToFigmaColorValue(argb),
+          $extensions: {
+            "com.figma.scopes": ["ALL_SCOPES"],
+            "com.figma.isOverride": true
+          }
+        };
+      }
+      function buildFigmaSchemeTokens(mergedColors) {
+        const tokens = {};
+        for (const [name, argb] of Object.entries(mergedColors)) {
+          tokens[startCase(name)] = figmaToken(argb);
+        }
+        return tokens;
+      }
+      function buildFigmaPaletteTokens(isDark) {
+        const palettes = {};
+        for (const [name, palette] of Object.entries(allPalettes)) {
+          const tones = {};
+          for (const tone of STANDARD_TONES) {
+            let toneToUse = tone;
+            if (adaptiveShades && isDark) {
+              toneToUse = 100 - tone;
+            }
+            if (contrastAllColors) {
+              toneToUse = adjustToneForContrast(toneToUse, contrast);
+            }
+            const argb = palette.tone(toneToUse);
+            tones[tone.toString()] = figmaToken(argb);
+          }
+          palettes[startCase(name)] = tones;
+        }
+        return palettes;
+      }
+      function buildModeFile(modeName, mergedColors, isDark) {
+        return {
+          Schemes: buildFigmaSchemeTokens(mergedColors),
+          Palettes: buildFigmaPaletteTokens(isDark),
+          $extensions: {
+            "com.figma.modeName": modeName
+          }
+        };
+      }
+      return {
+        "Light.tokens.json": buildModeFile("Light", mergedColorsLight, false),
+        "Dark.tokens.json": buildModeFile("Dark", mergedColorsDark, true)
+      };
+    },
+    //
+    // API
+    //
+    mergedColorsLight,
+    mergedColorsDark,
+    allPalettes
+  };
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("react-mcu").description("m3 color system for react");
+program.command("builder").description("Generate a color theme from a source color").argument("<source>", "Source color in hex format (e.g. #6750A4)").addOption(
+  new Option("--scheme <name>", "Color scheme variant").choices(schemeNames).default(DEFAULT_SCHEME)
+).option(
+  "--contrast <number>",
+  "Contrast level from -1.0 to 1.0",
+  parseFloat,
+  DEFAULT_CONTRAST
+).option("--primary <hex>", "Primary color override").option("--secondary <hex>", "Secondary color override").option("--tertiary <hex>", "Tertiary color override").option("--error <hex>", "Error color override").option("--neutral <hex>", "Neutral color override").option("--neutral-variant <hex>", "Neutral variant color override").option(
+  "--custom-colors <json>",
+  `Custom colors as JSON array (e.g. '[{"name":"brand","hex":"#FF5733","blend":true}]')`
+).option("--format <type>", "Output format: json, css, or figma", "figma").option("--output <dir>", "Output directory (required for figma format)").option(
+  "--adaptive-shades",
+  "Adapt tonal palette shades for dark mode",
+  DEFAULT_ADAPTIVE_SHADES
+).option(
+  "--contrast-all-colors",
+  "Apply contrast adjustment to tonal palette shades",
+  DEFAULT_CONTRAST_ALL_COLORS
+).action((source, opts) => {
+  let customColors = [];
+  if (opts.customColors) {
+    try {
+      const parsed = JSON.parse(opts.customColors);
+      customColors = parsed.map((c) => ({
+        name: c.name,
+        hex: c.hex,
+        blend: c.blend ?? DEFAULT_BLEND
+      }));
+    } catch {
+      console.error("Error: --custom-colors must be valid JSON");
+      process.exit(1);
+    }
+  }
+  const result = builder(source, {
+    scheme: opts.scheme,
+    contrast: opts.contrast,
+    primary: opts.primary,
+    secondary: opts.secondary,
+    tertiary: opts.tertiary,
+    error: opts.error,
+    neutral: opts.neutral,
+    neutralVariant: opts.neutralVariant,
+    customColors,
+    adaptiveShades: opts.adaptiveShades,
+    contrastAllColors: opts.contrastAllColors
+  });
+  if (opts.format === "css") {
+    process.stdout.write(result.toCss());
+  } else if (opts.format === "figma") {
+    const outputDir = opts.output ?? "mcu-theme";
+    fs.mkdirSync(outputDir, { recursive: true });
+    const files = result.toFigmaTokens();
+    for (const [filename, content] of Object.entries(files)) {
+      const filePath = path.join(outputDir, filename);
+      fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n");
+      console.error(`wrote ${filePath}`);
+    }
+  } else {
+    process.stdout.write(JSON.stringify(result.toJson(), null, 2) + "\n");
+  }
+});
+program.parse();

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import { CustomColor, TonalPalette } from '@material/material-color-utilities';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type HexCustomColor = Omit<CustomColor, "value"> & {
     hex: string;
@@ -34,39 +34,26 @@ type McuConfig = {
     colorMatch?: boolean;
     /**
      * Array of custom colors to include in the generated palette.
-     *
-     * @example
-     * ```ts
-     * customColors={[
-     *   { name: "brand", hex: "#FF5733", blend: true },
-     *   { name: "success", hex: "#28A745", blend: false }
-     * ]}
-     * ```
+     * Each custom color can be blended with the source color for harmonization.
      */
     customColors?: HexCustomColor[];
     /**
-     * When true, applies the contrast level to all colors including custom colors and tonal palette shades.
-     * When false (default), only core colors are affected by the contrast level.
+     * Apply contrast adjustment to tonal palette shades when true.
+     * When true, all tonal palette shades are adjusted based on the contrast level.
+     * When false (default), contrast adjustments only apply to core Material Design tokens.
      */
     contrastAllColors?: boolean;
     /**
-     * When true (default), tonal palette shades adapt to the theme (light/dark) with inverted tone values.
-     * In dark mode, high tones (light colors) map to low tones (dark colors) and vice versa.
-     * When false, shades remain the same across themes.
+     * Adapt tonal palette shades for dark mode.
+     * When true, tonal palette shades automatically invert for dark mode
+     * (high values become dark, low values become light).
+     * When false (default), tonal palette values remain constant across light/dark mode.
      */
     adaptiveShades?: boolean;
 };
 declare const schemeNames: readonly ["tonalSpot", "monochrome", "neutral", "vibrant", "expressive", "fidelity", "content"];
 type SchemeName = (typeof schemeNames)[number];
-declare const DEFAULT_SCHEME: SchemeName;
-declare const DEFAULT_CONTRAST = 0;
-declare const DEFAULT_CONTRAST_ALL_COLORS = false;
-declare const DEFAULT_ADAPTIVE_SHADES = false;
-declare const DEFAULT_BLEND = true;
-declare function Mcu({ source, scheme, contrast, primary, secondary, tertiary, neutral, neutralVariant, error, colorMatch, customColors, contrastAllColors, adaptiveShades, children, }: McuConfig & {
-    children?: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare const tokenNames: readonly ["background", "onBackground", "surface", "surfaceDim", "surfaceBright", "surfaceContainerLowest", "surfaceContainerLow", "surfaceContainer", "surfaceContainerHigh", "surfaceContainerHighest", "onSurface", "surfaceVariant", "onSurfaceVariant", "outline", "outlineVariant", "inverseSurface", "inverseOnSurface", "primary", "surfaceTint", "onPrimary", "primaryContainer", "onPrimaryContainer", "primaryFixed", "primaryFixedDim", "onPrimaryFixed", "onPrimaryFixedVariant", "inversePrimary", "secondary", "onSecondary", "secondaryContainer", "onSecondaryContainer", "secondaryFixed", "secondaryFixedDim", "onSecondaryFixed", "onSecondaryFixedVariant", "tertiary", "onTertiary", "tertiaryContainer", "onTertiaryContainer", "tertiaryFixed", "tertiaryFixedDim", "onTertiaryFixed", "onTertiaryFixedVariant", "error", "onError", "errorContainer", "onErrorContainer", "scrim", "shadow"];
+declare const tokenNames: readonly ["background", "error", "errorContainer", "inverseOnSurface", "inversePrimary", "inverseSurface", "onBackground", "onError", "onErrorContainer", "onPrimary", "onPrimaryContainer", "onPrimaryFixed", "onPrimaryFixedVariant", "onSecondary", "onSecondaryContainer", "onSecondaryFixed", "onSecondaryFixedVariant", "onSurface", "onSurfaceVariant", "onTertiary", "onTertiaryContainer", "onTertiaryFixed", "onTertiaryFixedVariant", "outline", "outlineVariant", "primary", "primaryContainer", "primaryFixed", "primaryFixedDim", "scrim", "secondary", "secondaryContainer", "secondaryFixed", "secondaryFixedDim", "shadow", "surface", "surfaceBright", "surfaceContainer", "surfaceContainerHigh", "surfaceContainerHighest", "surfaceContainerLow", "surfaceContainerLowest", "surfaceDim", "surfaceTint", "surfaceVariant", "tertiary", "tertiaryContainer", "tertiaryFixed", "tertiaryFixedDim"];
 type TokenName = (typeof tokenNames)[number];
 declare function builder(hexSource: McuConfig["source"], { scheme, contrast, primary, secondary, tertiary, neutral, neutralVariant, error, customColors: hexCustomColors, contrastAllColors, adaptiveShades, }?: Omit<McuConfig, "source">): {
     toCss(): string;
@@ -162,6 +149,10 @@ declare function builder(hexSource: McuConfig["source"], { scheme, contrast, pri
     };
 };
 
+declare function Mcu({ source, scheme, contrast, primary, secondary, tertiary, neutral, neutralVariant, error, colorMatch, customColors, contrastAllColors, adaptiveShades, children, }: McuConfig & {
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
 type Api = {
     initials: McuConfig;
     setMcuConfig: (config: McuConfig) => void;
@@ -170,4 +161,4 @@ type Api = {
 };
 declare const useMcu: () => Api;
 
-export { DEFAULT_ADAPTIVE_SHADES, DEFAULT_BLEND, DEFAULT_CONTRAST, DEFAULT_CONTRAST_ALL_COLORS, DEFAULT_SCHEME, Mcu, builder, schemeNames, useMcu };
+export { Mcu, builder, useMcu };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use client";
 
-// src/Mcu.tsx
+// src/lib/builder.ts
 import {
   argbFromHex,
   Blend,
@@ -9,7 +9,7 @@ import {
   DynamicScheme,
   greenFromArgb,
   Hct,
-  hexFromArgb as hexFromArgb2,
+  hexFromArgb,
   MaterialDynamicColors,
   redFromArgb,
   SchemeContent,
@@ -22,85 +22,6 @@ import {
   TonalPalette
 } from "@material/material-color-utilities";
 import { kebabCase, startCase, upperFirst } from "lodash-es";
-import { useMemo as useMemo2 } from "react";
-
-// src/Mcu.context.tsx
-import {
-  hexFromArgb
-} from "@material/material-color-utilities";
-import React, {
-  useCallback,
-  useInsertionEffect,
-  useMemo,
-  useState
-} from "react";
-
-// src/lib/createRequiredContext.ts
-import { createContext, useContext } from "react";
-var createRequiredContext = () => {
-  const Ctx = createContext(null);
-  const useCtx = () => {
-    const contextValue = useContext(Ctx);
-    if (contextValue === null) {
-      throw new Error("Context value is null");
-    }
-    return contextValue;
-  };
-  return [useCtx, Ctx.Provider, Ctx];
-};
-
-// src/Mcu.context.tsx
-import { jsx } from "react/jsx-runtime";
-var [useMcu, Provider, McuContext] = createRequiredContext();
-var McuProvider = ({
-  styleId,
-  children,
-  ...configProps
-}) => {
-  const [initials] = useState(() => configProps);
-  const [mcuConfig, setMcuConfig] = useState(initials);
-  const configKey = JSON.stringify(configProps);
-  React.useEffect(() => {
-    setMcuConfig(configProps);
-  }, [configKey]);
-  const { css, mergedColorsLight, mergedColorsDark, allPalettes } = useMemo(() => {
-    const { toCss, ...rest } = builder(mcuConfig.source, mcuConfig);
-    return { css: toCss(), ...rest };
-  }, [mcuConfig]);
-  useInsertionEffect(() => {
-    let tag = document.getElementById(styleId);
-    if (!tag) {
-      tag = document.createElement("style");
-      tag.id = styleId;
-      document.head.appendChild(tag);
-    }
-    tag.textContent = css;
-  }, [css, styleId]);
-  const getMcuColor = useCallback(
-    (colorName, theme) => {
-      const mergedColors = theme === "light" ? mergedColorsLight : mergedColorsDark;
-      const colorValue = mergedColors[colorName];
-      if (colorValue === void 0) {
-        throw new Error(`Unknown MCU token '${colorName}'`);
-      }
-      return hexFromArgb(colorValue);
-    },
-    [mergedColorsDark, mergedColorsLight]
-  );
-  const value = useMemo(
-    () => ({
-      initials,
-      setMcuConfig,
-      getMcuColor,
-      allPalettes
-    }),
-    [getMcuColor, initials, allPalettes]
-  );
-  return /* @__PURE__ */ jsx(Provider, { value, children });
-};
-
-// src/Mcu.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
 function adjustToneForContrast(baseTone, contrastLevel, adjustmentFactor = DEFAULT_CONTRAST_ADJUSTMENT_FACTOR) {
   if (contrastLevel === 0) return baseTone;
   const distanceToCenter = baseTone - 50;
@@ -108,15 +29,6 @@ function adjustToneForContrast(baseTone, contrastLevel, adjustmentFactor = DEFAU
   const adjustedTone = baseTone + delta;
   return Math.max(0, Math.min(100, adjustedTone));
 }
-var schemeNames = [
-  "tonalSpot",
-  "monochrome",
-  "neutral",
-  "vibrant",
-  "expressive",
-  "fidelity",
-  "content"
-];
 var schemesMap = {
   tonalSpot: SchemeTonalSpot,
   monochrome: SchemeMonochrome,
@@ -128,7 +40,6 @@ var schemesMap = {
 };
 var DEFAULT_SCHEME = "tonalSpot";
 var DEFAULT_CONTRAST = 0;
-var DEFAULT_COLOR_MATCH = false;
 var DEFAULT_CUSTOM_COLORS = [];
 var DEFAULT_CONTRAST_ALL_COLORS = false;
 var DEFAULT_ADAPTIVE_SHADES = false;
@@ -166,116 +77,64 @@ var Variant = {
   FRUIT_SALAD: 8
 };
 var schemeToVariant = {
-  tonalSpot: Variant.TONAL_SPOT,
   monochrome: Variant.MONOCHROME,
   neutral: Variant.NEUTRAL,
+  tonalSpot: Variant.TONAL_SPOT,
   vibrant: Variant.VIBRANT,
   expressive: Variant.EXPRESSIVE,
   fidelity: Variant.FIDELITY,
   content: Variant.CONTENT
 };
-var mcuStyleId = "mcu-styles";
-function Mcu({
-  source,
-  scheme = DEFAULT_SCHEME,
-  contrast = DEFAULT_CONTRAST,
-  primary,
-  secondary,
-  tertiary,
-  neutral,
-  neutralVariant,
-  error,
-  colorMatch = DEFAULT_COLOR_MATCH,
-  customColors = DEFAULT_CUSTOM_COLORS,
-  contrastAllColors = DEFAULT_CONTRAST_ALL_COLORS,
-  adaptiveShades = DEFAULT_ADAPTIVE_SHADES,
-  children
-}) {
-  const config = useMemo2(
-    () => ({
-      source,
-      scheme,
-      contrast,
-      primary,
-      secondary,
-      tertiary,
-      neutral,
-      neutralVariant,
-      error,
-      colorMatch,
-      customColors,
-      // extras features
-      contrastAllColors,
-      adaptiveShades
-    }),
-    [
-      contrast,
-      customColors,
-      scheme,
-      source,
-      primary,
-      secondary,
-      tertiary,
-      neutral,
-      neutralVariant,
-      error,
-      colorMatch,
-      contrastAllColors,
-      adaptiveShades
-    ]
-  );
-  return /* @__PURE__ */ jsx2(McuProvider, { ...config, styleId: mcuStyleId, children });
-}
 var tokenNames = [
   "background",
+  "error",
+  "errorContainer",
+  "inverseOnSurface",
+  "inversePrimary",
+  "inverseSurface",
   "onBackground",
-  "surface",
-  "surfaceDim",
-  "surfaceBright",
-  "surfaceContainerLowest",
-  "surfaceContainerLow",
-  "surfaceContainer",
-  "surfaceContainerHigh",
-  "surfaceContainerHighest",
+  "onError",
+  "onErrorContainer",
+  "onPrimary",
+  "onPrimaryContainer",
+  "onPrimaryFixed",
+  "onPrimaryFixedVariant",
+  "onSecondary",
+  "onSecondaryContainer",
+  "onSecondaryFixed",
+  "onSecondaryFixedVariant",
   "onSurface",
-  "surfaceVariant",
   "onSurfaceVariant",
+  "onTertiary",
+  "onTertiaryContainer",
+  "onTertiaryFixed",
+  "onTertiaryFixedVariant",
   "outline",
   "outlineVariant",
-  "inverseSurface",
-  "inverseOnSurface",
   "primary",
-  "surfaceTint",
-  "onPrimary",
   "primaryContainer",
-  "onPrimaryContainer",
   "primaryFixed",
   "primaryFixedDim",
-  "onPrimaryFixed",
-  "onPrimaryFixedVariant",
-  "inversePrimary",
+  "scrim",
   "secondary",
-  "onSecondary",
   "secondaryContainer",
-  "onSecondaryContainer",
   "secondaryFixed",
   "secondaryFixedDim",
-  "onSecondaryFixed",
-  "onSecondaryFixedVariant",
+  "shadow",
+  "surface",
+  "surfaceBright",
+  "surfaceContainer",
+  "surfaceContainerHigh",
+  "surfaceContainerHighest",
+  "surfaceContainerLow",
+  "surfaceContainerLowest",
+  "surfaceDim",
+  "surfaceTint",
+  "surfaceVariant",
   "tertiary",
-  "onTertiary",
   "tertiaryContainer",
-  "onTertiaryContainer",
   "tertiaryFixed",
-  "tertiaryFixedDim",
-  "onTertiaryFixed",
-  "onTertiaryFixedVariant",
-  "error",
-  "onError",
-  "errorContainer",
-  "onErrorContainer",
-  "scrim",
-  "shadow"
+  "tertiaryFixedDim"
 ];
 function toRecord(arr, getEntry) {
   return Object.fromEntries(arr.map(getEntry));
@@ -489,7 +348,7 @@ function builder(hexSource, {
     toCss() {
       function cssVar(colorName, colorValue) {
         const name = `--mcu-${kebabCase(colorName)}`;
-        const value = hexFromArgb2(colorValue);
+        const value = hexFromArgb(colorValue);
         return `${name}:${value};`;
       }
       function toCssVars(mergedColors) {
@@ -611,7 +470,7 @@ function builder(hexSource, {
           for (const tokenName of fixtureTokenOrder) {
             const dynamicColor = MaterialDynamicColors[tokenName];
             const useScheme = backgroundScheme && (tokenName === "background" || tokenName === "onBackground") ? backgroundScheme : scheme2;
-            colors[tokenName] = hexFromArgb2(
+            colors[tokenName] = hexFromArgb(
               dynamicColor.getArgb(useScheme)
             ).toUpperCase();
           }
@@ -669,7 +528,7 @@ function builder(hexSource, {
           const palette = rawPalettes[name];
           const tones = {};
           for (const tone of STANDARD_TONES) {
-            tones[tone.toString()] = hexFromArgb2(
+            tones[tone.toString()] = hexFromArgb(
               palette.tone(tone)
             ).toUpperCase();
           }
@@ -727,7 +586,7 @@ function builder(hexSource, {
             blueFromArgb(argb) / 255
           ],
           alpha: 1,
-          hex: hexFromArgb2(argb).toUpperCase()
+          hex: hexFromArgb(argb).toUpperCase()
         };
       }
       function figmaToken(argb) {
@@ -788,14 +647,142 @@ function builder(hexSource, {
     allPalettes
   };
 }
+
+// src/Mcu.tsx
+import { useMemo as useMemo2 } from "react";
+
+// src/Mcu.context.tsx
+import {
+  hexFromArgb as hexFromArgb2
+} from "@material/material-color-utilities";
+import React, {
+  useCallback,
+  useInsertionEffect,
+  useMemo,
+  useState
+} from "react";
+
+// src/lib/createRequiredContext.ts
+import { createContext, useContext } from "react";
+var createRequiredContext = () => {
+  const Ctx = createContext(null);
+  const useCtx = () => {
+    const contextValue = useContext(Ctx);
+    if (contextValue === null) {
+      throw new Error("Context value is null");
+    }
+    return contextValue;
+  };
+  return [useCtx, Ctx.Provider, Ctx];
+};
+
+// src/Mcu.context.tsx
+import { jsx } from "react/jsx-runtime";
+var [useMcu, Provider, McuContext] = createRequiredContext();
+var McuProvider = ({
+  styleId,
+  children,
+  ...configProps
+}) => {
+  const [initials] = useState(() => configProps);
+  const [mcuConfig, setMcuConfig] = useState(initials);
+  const configKey = JSON.stringify(configProps);
+  React.useEffect(() => {
+    setMcuConfig(configProps);
+  }, [configKey]);
+  const { css, mergedColorsLight, mergedColorsDark, allPalettes } = useMemo(() => {
+    const { toCss, ...rest } = builder(mcuConfig.source, mcuConfig);
+    return { css: toCss(), ...rest };
+  }, [mcuConfig]);
+  useInsertionEffect(() => {
+    let tag = document.getElementById(styleId);
+    if (!tag) {
+      tag = document.createElement("style");
+      tag.id = styleId;
+      document.head.appendChild(tag);
+    }
+    tag.textContent = css;
+  }, [css, styleId]);
+  const getMcuColor = useCallback(
+    (colorName, theme) => {
+      const mergedColors = theme === "light" ? mergedColorsLight : mergedColorsDark;
+      const colorValue = mergedColors[colorName];
+      if (colorValue === void 0) {
+        throw new Error(`Unknown MCU token '${colorName}'`);
+      }
+      return hexFromArgb2(colorValue);
+    },
+    [mergedColorsDark, mergedColorsLight]
+  );
+  const value = useMemo(
+    () => ({
+      initials,
+      setMcuConfig,
+      getMcuColor,
+      allPalettes
+    }),
+    [getMcuColor, initials, allPalettes]
+  );
+  return /* @__PURE__ */ jsx(Provider, { value, children });
+};
+
+// src/Mcu.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var mcuStyleId = "mcu-styles";
+var DEFAULT_COLOR_MATCH = false;
+function Mcu({
+  source,
+  scheme = DEFAULT_SCHEME,
+  contrast = DEFAULT_CONTRAST,
+  primary,
+  secondary,
+  tertiary,
+  neutral,
+  neutralVariant,
+  error,
+  colorMatch = DEFAULT_COLOR_MATCH,
+  customColors = DEFAULT_CUSTOM_COLORS,
+  contrastAllColors = DEFAULT_CONTRAST_ALL_COLORS,
+  adaptiveShades = DEFAULT_ADAPTIVE_SHADES,
+  children
+}) {
+  const config = useMemo2(
+    () => ({
+      source,
+      scheme,
+      contrast,
+      primary,
+      secondary,
+      tertiary,
+      neutral,
+      neutralVariant,
+      error,
+      colorMatch,
+      customColors,
+      // extras features
+      contrastAllColors,
+      adaptiveShades
+    }),
+    [
+      contrast,
+      customColors,
+      scheme,
+      source,
+      primary,
+      secondary,
+      tertiary,
+      neutral,
+      neutralVariant,
+      error,
+      colorMatch,
+      contrastAllColors,
+      adaptiveShades
+    ]
+  );
+  return /* @__PURE__ */ jsx2(McuProvider, { ...config, styleId: mcuStyleId, children });
+}
 export {
-  DEFAULT_ADAPTIVE_SHADES,
-  DEFAULT_BLEND,
-  DEFAULT_CONTRAST,
-  DEFAULT_CONTRAST_ALL_COLORS,
-  DEFAULT_SCHEME,
   Mcu,
   builder,
-  schemeNames,
   useMcu
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-mcu",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A React component library",
   "keywords": [
     "react",
@@ -29,7 +29,7 @@
     "src/tailwind.css"
   ],
   "bin": {
-    "react-mcu": "./src/cli.ts"
+    "react-mcu": "./dist/cli.js"
   },
   "type": "module",
   "devDependencies": {
@@ -81,8 +81,7 @@
   "dependencies": {
     "@material/material-color-utilities": "^0.3.0",
     "commander": "^14.0.3",
-    "lodash-es": "^4.17.22",
-    "tsx": "^4.21.0"
+    "lodash-es": "^4.17.22"
   },
   "scripts": {
     "build": "tsup",

package/src/cli.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env tsx
-
-// @example
-
-// ```sh
-// $ npx tsx src/cli.ts builder '#6750A4'
-// $ npx tsx src/cli.ts builder '#6750A4' --format css
-// $ npx tsx src/cli.ts builder '#6750A4' --adaptive-shades --format figma
-// ```
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-import { Command, Option } from "commander";
-import {
-  builder,
-  DEFAULT_ADAPTIVE_SHADES,
-  DEFAULT_BLEND,
-  DEFAULT_CONTRAST,
-  DEFAULT_CONTRAST_ALL_COLORS,
-  DEFAULT_SCHEME,
-  schemeNames,
-} from "react-mcu";
-
-const program = new Command();
-
-program.name("react-mcu").description("m3 color system for react");
-
-program
-  .command("builder")
-  .description("Generate a color theme from a source color")
-  .argument("<source>", "Source color in hex format (e.g. #6750A4)")
-  .addOption(
-    new Option("--scheme <name>", "Color scheme variant")
-      .choices(schemeNames)
-      .default(DEFAULT_SCHEME),
-  )
-  .option(
-    "--contrast <number>",
-    "Contrast level from -1.0 to 1.0",
-    parseFloat,
-    DEFAULT_CONTRAST,
-  )
-  .option("--primary <hex>", "Primary color override")
-  .option("--secondary <hex>", "Secondary color override")
-  .option("--tertiary <hex>", "Tertiary color override")
-  .option("--error <hex>", "Error color override")
-  .option("--neutral <hex>", "Neutral color override")
-  .option("--neutral-variant <hex>", "Neutral variant color override")
-  .option(
-    "--custom-colors <json>",
-    'Custom colors as JSON array (e.g. \'[{"name":"brand","hex":"#FF5733","blend":true}]\')',
-  )
-  .option("--format <type>", "Output format: json, css, or figma", "figma")
-  .option("--output <dir>", "Output directory (required for figma format)")
-  .option(
-    "--adaptive-shades",
-    "Adapt tonal palette shades for dark mode",
-    DEFAULT_ADAPTIVE_SHADES,
-  )
-  .option(
-    "--contrast-all-colors",
-    "Apply contrast adjustment to tonal palette shades",
-    DEFAULT_CONTRAST_ALL_COLORS,
-  )
-  .action((source: string, opts) => {
-    let customColors: { name: string; hex: string; blend: boolean }[] = [];
-    if (opts.customColors) {
-      try {
-        const parsed = JSON.parse(opts.customColors) as {
-          name: string;
-          hex: string;
-          blend?: boolean;
-        }[];
-        customColors = parsed.map((c) => ({
-          name: c.name,
-          hex: c.hex,
-          blend: c.blend ?? DEFAULT_BLEND,
-        }));
-      } catch {
-        console.error("Error: --custom-colors must be valid JSON");
-        process.exit(1);
-      }
-    }
-
-    const result = builder(source, {
-      scheme: opts.scheme,
-      contrast: opts.contrast,
-      primary: opts.primary,
-      secondary: opts.secondary,
-      tertiary: opts.tertiary,
-      error: opts.error,
-      neutral: opts.neutral,
-      neutralVariant: opts.neutralVariant,
-      customColors,
-      adaptiveShades: opts.adaptiveShades,
-      contrastAllColors: opts.contrastAllColors,
-    });
-
-    if (opts.format === "css") {
-      process.stdout.write(result.toCss());
-    } else if (opts.format === "figma") {
-      const outputDir = opts.output ?? "mcu-theme";
-      fs.mkdirSync(outputDir, { recursive: true });
-      const files = result.toFigmaTokens();
-      for (const [filename, content] of Object.entries(files)) {
-        const filePath = path.join(outputDir, filename);
-        fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + "\n");
-        console.error(`wrote ${filePath}`);
-      }
-    } else {
-      process.stdout.write(JSON.stringify(result.toJson(), null, 2) + "\n");
-    }
-  });
-
-program.parse();