@clafoutis/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1369 @@
+#!/usr/bin/env node
+import * as p2 from '@clack/prompts';
+import { Command } from 'commander';
+import { logger } from '@clafoutis/shared';
+import path2 from 'path';
+import StyleDictionary from 'style-dictionary';
+import { pathToFileURL } from 'url';
+import { Ajv } from 'ajv';
+import fs from 'fs/promises';
+import { spawn } from 'child_process';
+
+// src/utils/errors.ts
+var colors = {
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`
+};
+var ClafoutisError = class extends Error {
+  constructor(title, detail, suggestion) {
+    super(`${title}: ${detail}`);
+    this.title = title;
+    this.detail = detail;
+    this.suggestion = suggestion;
+    this.name = "ClafoutisError";
+  }
+  /**
+   * Formats the error for display in the terminal with colors and structure.
+   */
+  format() {
+    let output = `
+${colors.red("Error:")} ${this.title}
+`;
+    output += `
+${this.detail}
+`;
+    if (this.suggestion) {
+      output += `
+${colors.cyan("Suggestion:")} ${this.suggestion}
+`;
+    }
+    return output;
+  }
+};
+function configNotFoundError(configPath, isConsumer) {
+  return new ClafoutisError(
+    "Configuration not found",
+    `Could not find ${configPath}`,
+    `Run: npx clafoutis init --${isConsumer ? "consumer" : "producer"}`
+  );
+}
+function releaseNotFoundError(version, repo) {
+  return new ClafoutisError(
+    "Release not found",
+    `Version ${version} does not exist in ${repo}`,
+    `Check available releases: gh release list -R ${repo}`
+  );
+}
+function authRequiredError() {
+  return new ClafoutisError(
+    "Authentication required",
+    "CLAFOUTIS_REPO_TOKEN is required for private repositories",
+    "Set the environment variable: export CLAFOUTIS_REPO_TOKEN=ghp_xxx"
+  );
+}
+function generatorNotFoundError(name) {
+  return new ClafoutisError(
+    "Generator not found",
+    `Built-in generator "${name}" does not exist`,
+    "Available generators: tailwind, figma"
+  );
+}
+function pluginLoadError(pluginPath, errorMessage) {
+  return new ClafoutisError(
+    "Plugin load failed",
+    `Could not load generator from ${pluginPath}: ${errorMessage}`,
+    'Ensure the file exports a "generate" function'
+  );
+}
+function tokensDirNotFoundError(tokensDir) {
+  return new ClafoutisError(
+    "Tokens directory not found",
+    `Directory "${tokensDir}" does not exist`,
+    "Create the directory and add token JSON files"
+  );
+}
+
+// src/cli/validation.ts
+function validateRepo(value) {
+  if (!value) {
+    return "Repository is required";
+  }
+  if (!/^[\w-]+\/[\w.-]+$/.test(value)) {
+    return "Repository must be in format: org/repo-name";
+  }
+  return void 0;
+}
+function validatePath(value) {
+  if (!value) {
+    return "Path is required";
+  }
+  if (!value.startsWith("./") && !value.startsWith("/") && value !== ".") {
+    return 'Path must start with ./ or /, or be "."';
+  }
+  return void 0;
+}
+var DEPRECATED_FIELDS = {
+  "generators.css": 'Use "generators.tailwind" instead',
+  buildDir: 'Renamed to "output"'
+};
+function validateConfig(config, schema, configPath) {
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  const validate = ajv.compile(schema);
+  if (!validate(config)) {
+    const errors = validate.errors?.map((e) => `  - ${e.instancePath || "root"}: ${e.message}`).join("\n");
+    throw new ClafoutisError(
+      "Invalid configuration",
+      `${configPath}:
+${errors}`,
+      'Check the config against the schema or run "clafoutis init --force" to regenerate'
+    );
+  }
+  const schemaObj = schema;
+  if (schemaObj.properties) {
+    const unknownFields = findUnknownFields(config, schemaObj.properties);
+    if (unknownFields.length > 0) {
+      p2.log.warn(
+        `Unknown fields in ${configPath}: ${unknownFields.join(", ")}`
+      );
+      p2.log.info(
+        "These fields will be ignored. Check for typos or outdated config."
+      );
+    }
+  }
+  for (const [field, message] of Object.entries(DEPRECATED_FIELDS)) {
+    if (hasField(config, field)) {
+      p2.log.warn(`Deprecated field "${field}": ${message}`);
+    }
+  }
+}
+function findUnknownFields(config, schemaProperties, prefix = "") {
+  const unknown = [];
+  for (const key of Object.keys(config)) {
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    if (!(key in schemaProperties)) {
+      unknown.push(fullPath);
+    } else {
+      const value = config[key];
+      const schemaProp = schemaProperties[key];
+      if (value && typeof value === "object" && !Array.isArray(value) && schemaProp?.properties) {
+        unknown.push(
+          ...findUnknownFields(
+            value,
+            schemaProp.properties,
+            fullPath
+          )
+        );
+      }
+    }
+  }
+  return unknown;
+}
+function hasField(config, path4) {
+  const parts = path4.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function validateProducerFlags(options) {
+  const errors = [];
+  if (options.tokens) {
+    const tokenError = validatePath(options.tokens);
+    if (tokenError) {
+      errors.push(`--tokens: ${tokenError}`);
+    }
+  }
+  if (options.output) {
+    const outputError = validatePath(options.output);
+    if (outputError) {
+      errors.push(`--output: ${outputError}`);
+    }
+  }
+  if (options.generators) {
+    const builtInGenerators = ["tailwind", "figma"];
+    const generators = options.generators.split(",").map((g) => g.trim());
+    for (const gen of generators) {
+      const colonIdx = gen.indexOf(":");
+      if (colonIdx > 0) {
+        const name = gen.slice(0, colonIdx).trim();
+        const pluginPath = gen.slice(colonIdx + 1).trim();
+        if (!name) {
+          errors.push(
+            `--generators: Custom generator "${gen}" has an empty name`
+          );
+        }
+        if (!pluginPath) {
+          errors.push(
+            `--generators: Custom generator "${name}" is missing a path`
+          );
+        }
+      } else if (!builtInGenerators.includes(gen)) {
+        errors.push(
+          `--generators: Invalid generator "${gen}". Built-in options: ${builtInGenerators.join(", ")}. For custom generators use "name:./path/to/plugin.js"`
+        );
+      }
+    }
+  }
+  return errors;
+}
+function validateConsumerFlags(options) {
+  const errors = [];
+  if (options.repo) {
+    const repoError = validateRepo(options.repo);
+    if (repoError) {
+      errors.push(`--repo: ${repoError}`);
+    }
+  }
+  if (options.files) {
+    const mappings = options.files.split(",");
+    for (const mapping of mappings) {
+      if (!mapping.includes(":")) {
+        errors.push(
+          `--files: Invalid format "${mapping}". Use format: asset:destination`
+        );
+      }
+    }
+  }
+  return errors;
+}
+
+// src/cli/wizard.ts
+function showIntro(dryRun = false) {
+  const suffix = dryRun ? " (DRY RUN)" : "";
+  p2.intro(`Clafoutis - GitOps Design Token Generator${suffix}`);
+}
+function showOutro(message) {
+  p2.outro(message);
+}
+async function selectMode() {
+  const mode = await p2.select({
+    message: "What would you like to set up?",
+    options: [
+      {
+        value: "producer",
+        label: "Producer",
+        hint: "I maintain a design system"
+      },
+      {
+        value: "consumer",
+        label: "Consumer",
+        hint: "I consume tokens from a design system"
+      }
+    ]
+  });
+  if (p2.isCancel(mode)) {
+    return null;
+  }
+  return mode;
+}
+async function runProducerWizard() {
+  const answers = await p2.group(
+    {
+      generators: () => p2.multiselect({
+        message: "Which generators would you like to enable?",
+        options: [
+          { value: "tailwind", label: "Tailwind CSS", hint: "recommended" },
+          { value: "figma", label: "Figma Variables" }
+        ],
+        required: true,
+        initialValues: ["tailwind"]
+      }),
+      tokens: () => p2.text({
+        message: "Where are your design tokens located?",
+        placeholder: "./tokens",
+        initialValue: "./tokens",
+        validate: validatePath
+      }),
+      output: () => p2.text({
+        message: "Where should generated files be output?",
+        placeholder: "./build",
+        initialValue: "./build",
+        validate: validatePath
+      }),
+      workflow: () => p2.confirm({
+        message: "Create GitHub Actions workflow for auto-releases?",
+        initialValue: true
+      })
+    },
+    {
+      onCancel: () => {
+        p2.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return answers;
+}
+async function runConsumerWizard() {
+  const repo = await p2.text({
+    message: "GitHub repository (org/repo):",
+    placeholder: "Acme/design-system",
+    validate: validateRepo
+  });
+  if (p2.isCancel(repo)) {
+    p2.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const filesInput = await p2.text({
+    message: "Which files do you want to sync? (comma-separated)",
+    placeholder: "tailwind.base.css, tailwind.config.js",
+    initialValue: "tailwind.base.css, tailwind.config.js"
+  });
+  if (p2.isCancel(filesInput)) {
+    p2.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const fileNames = filesInput.split(",").map((f) => f.trim()).filter(Boolean);
+  const files = {};
+  for (const fileName of fileNames) {
+    const defaultDest = suggestDestination(fileName);
+    const dest = await p2.text({
+      message: `Where should ${fileName} be saved?`,
+      placeholder: defaultDest,
+      initialValue: defaultDest,
+      validate: validatePath
+    });
+    if (p2.isCancel(dest)) {
+      p2.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    files[fileName] = dest;
+  }
+  return {
+    repo,
+    files
+  };
+}
+function suggestDestination(fileName) {
+  if (fileName.includes("tailwind.config")) {
+    return "./tailwind.config.js";
+  }
+  if (fileName.includes(".css")) {
+    return `./src/styles/${fileName}`;
+  }
+  if (fileName.includes(".scss")) {
+    return `./src/styles/${fileName}`;
+  }
+  return `./${fileName}`;
+}
+async function offerWizard(configType) {
+  p2.log.error(`Configuration not found: .clafoutis/${configType}.json`);
+  const runWizard = await p2.confirm({
+    message: "Would you like to create one now?",
+    initialValue: true
+  });
+  if (p2.isCancel(runWizard)) {
+    p2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return runWizard;
+}
+var log3 = {
+  info: (message) => p2.log.info(message),
+  success: (message) => p2.log.success(message),
+  warn: (message) => p2.log.warn(message),
+  error: (message) => p2.log.error(message),
+  step: (message) => p2.log.step(message),
+  message: (message) => p2.log.message(message)
+};
+async function readConfig(configPath) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readProducerConfig(configPath) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// schemas/consumer-config.json
+var consumer_config_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  required: ["repo", "version", "files"],
+  properties: {
+    repo: {
+      type: "string",
+      pattern: "^[\\w.-]+/[\\w.-]+$",
+      description: "GitHub repository in org/name format"
+    },
+    version: {
+      type: "string",
+      pattern: "^(latest|v\\d+\\.\\d+\\.\\d+)$",
+      description: "Release tag (e.g., v1.0.0) or 'latest'"
+    },
+    files: {
+      type: "object",
+      additionalProperties: { type: "string" },
+      minProperties: 1,
+      description: "Mapping of release asset names to local file paths"
+    },
+    postSync: {
+      type: "string",
+      description: "Optional command to run after sync"
+    }
+  },
+  additionalProperties: false
+};
+
+// schemas/producer-config.json
+var producer_config_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  required: ["tokens", "output", "generators"],
+  properties: {
+    tokens: {
+      type: "string",
+      description: "Path to tokens directory"
+    },
+    output: {
+      type: "string",
+      description: "Output directory for generated files"
+    },
+    generators: {
+      type: "object",
+      additionalProperties: {
+        oneOf: [
+          { type: "boolean" },
+          { type: "string" }
+        ]
+      },
+      description: "Generators to run (true for built-in, string path for custom)"
+    }
+  },
+  additionalProperties: false
+};
+
+// src/utils/validate.ts
+function validateConsumerConfig(config) {
+  validateConfig(
+    config,
+    consumer_config_default,
+    ".clafoutis/consumer.json"
+  );
+}
+function validateProducerConfig(config) {
+  validateConfig(
+    config,
+    producer_config_default,
+    ".clafoutis/producer.json"
+  );
+}
+
+// src/templates/tokens.ts
+var colorPrimitives = {
+  color: {
+    primary: {
+      50: { $value: "#eff6ff" },
+      100: { $value: "#dbeafe" },
+      200: { $value: "#bfdbfe" },
+      300: { $value: "#93c5fd" },
+      400: { $value: "#60a5fa" },
+      500: { $value: "#3b82f6" },
+      600: { $value: "#2563eb" },
+      700: { $value: "#1d4ed8" },
+      800: { $value: "#1e40af" },
+      900: { $value: "#1e3a8a" }
+    },
+    neutral: {
+      50: { $value: "#fafafa" },
+      100: { $value: "#f5f5f5" },
+      200: { $value: "#e5e5e5" },
+      300: { $value: "#d4d4d4" },
+      400: { $value: "#a3a3a3" },
+      500: { $value: "#737373" },
+      600: { $value: "#525252" },
+      700: { $value: "#404040" },
+      800: { $value: "#262626" },
+      900: { $value: "#171717" }
+    },
+    success: {
+      500: { $value: "#22c55e" }
+    },
+    warning: {
+      500: { $value: "#f59e0b" }
+    },
+    error: {
+      500: { $value: "#ef4444" }
+    }
+  }
+};
+var colorDarkPrimitives = {
+  color: {
+    // Background colors - use lighter neutrals in dark mode
+    background: {
+      default: { $value: "{color.neutral.900}" },
+      subtle: { $value: "{color.neutral.800}" },
+      muted: { $value: "{color.neutral.700}" }
+    },
+    // Foreground/text colors - use darker neutrals (which are lighter) in dark mode
+    foreground: {
+      default: { $value: "{color.neutral.50}" },
+      muted: { $value: "{color.neutral.400}" },
+      subtle: { $value: "{color.neutral.500}" }
+    },
+    // Border colors
+    border: {
+      default: { $value: "{color.neutral.700}" },
+      muted: { $value: "{color.neutral.800}" }
+    }
+  }
+};
+var spacingPrimitives = {
+  spacing: {
+    0: { $value: "0" },
+    1: { $value: "0.25rem" },
+    2: { $value: "0.5rem" },
+    3: { $value: "0.75rem" },
+    4: { $value: "1rem" },
+    5: { $value: "1.25rem" },
+    6: { $value: "1.5rem" },
+    8: { $value: "2rem" },
+    10: { $value: "2.5rem" },
+    12: { $value: "3rem" },
+    16: { $value: "4rem" },
+    20: { $value: "5rem" },
+    24: { $value: "6rem" }
+  }
+};
+var typographyPrimitives = {
+  fontFamily: {
+    sans: { $value: "ui-sans-serif, system-ui, sans-serif" },
+    serif: { $value: "ui-serif, Georgia, serif" },
+    mono: { $value: "ui-monospace, monospace" }
+  },
+  fontSize: {
+    xs: { $value: "0.75rem" },
+    sm: { $value: "0.875rem" },
+    base: { $value: "1rem" },
+    lg: { $value: "1.125rem" },
+    xl: { $value: "1.25rem" },
+    "2xl": { $value: "1.5rem" },
+    "3xl": { $value: "1.875rem" },
+    "4xl": { $value: "2.25rem" }
+  },
+  fontWeight: {
+    normal: { $value: "400" },
+    medium: { $value: "500" },
+    semibold: { $value: "600" },
+    bold: { $value: "700" }
+  },
+  lineHeight: {
+    tight: { $value: "1.25" },
+    normal: { $value: "1.5" },
+    relaxed: { $value: "1.75" }
+  }
+};
+var starterTokens = {
+  "colors/primitives.json": colorPrimitives,
+  "colors/primitives.dark.json": colorDarkPrimitives,
+  "spacing/primitives.json": spacingPrimitives,
+  "typography/primitives.json": typographyPrimitives
+};
+function getStarterTokenContent(fileName) {
+  const tokens = starterTokens[fileName];
+  if (!tokens) {
+    throw new Error(`Unknown starter token file: ${fileName}`);
+  }
+  return JSON.stringify(tokens, null, 2) + "\n";
+}
+function getAllStarterTokens() {
+  return Object.keys(starterTokens).map((fileName) => ({
+    path: fileName,
+    content: getStarterTokenContent(fileName)
+  }));
+}
+
+// src/templates/workflow.ts
+function getWorkflowTemplate() {
+  return `name: Design Token Release
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'tokens/**'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Install Clafoutis
+        run: npm install -D clafoutis
+
+      - name: Generate tokens
+        run: npx clafoutis generate
+
+      - name: Get next version
+        id: version
+        run: |
+          LATEST=$(git tag -l 'v*' | grep -E '^v[0-9]+\\.[0-9]+\\.[0-9]+$' | sort -V | tail -n1)
+          if [ -z "$LATEST" ]; then
+            echo "version=1.0.0" >> $GITHUB_OUTPUT
+          else
+            VERSION=\${LATEST#v}
+            IFS='.' read -r MAJOR MINOR PATCH <<< "$VERSION"
+            PATCH=$((PATCH + 1))
+            echo "version=\${MAJOR}.\${MINOR}.\${PATCH}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Prepare release assets
+        run: |
+          mkdir -p release-assets
+          while IFS= read -r -d '' file; do
+            relative="\${file#build/}"
+            flat_name="\${relative//\\//.}"
+            target="release-assets/$flat_name"
+            if [ -e "$target" ]; then
+              echo "::error::Collision detected: '$relative' flattens to '$flat_name' which already exists"
+              exit 1
+            fi
+            cp "$file" "$target"
+          done < <(find build -type f -print0)
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v\${{ steps.version.outputs.version }}
+          name: Design Tokens v\${{ steps.version.outputs.version }}
+          generate_release_notes: true
+          files: release-assets/*
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+`;
+}
+function getWorkflowPath() {
+  return ".github/workflows/clafoutis-release.yml";
+}
+
+// src/commands/init.ts
+function parseGenerators(generatorsString) {
+  const entries = generatorsString.split(",").map((g) => g.trim());
+  const invalidEntries = [];
+  for (const entry of entries) {
+    if (!entry) {
+      invalidEntries.push("(empty entry - check for extra commas)");
+      continue;
+    }
+    const colonIdx = entry.indexOf(":");
+    if (colonIdx === 0) {
+      invalidEntries.push(`"${entry}" (missing generator name before ":")`);
+    } else if (colonIdx > 0) {
+      const name = entry.slice(0, colonIdx).trim();
+      const pluginPath = entry.slice(colonIdx + 1).trim();
+      if (!name) {
+        invalidEntries.push(`"${entry}" (empty generator name)`);
+      }
+      if (!pluginPath) {
+        invalidEntries.push(`"${entry}" (missing path after ":")`);
+      }
+    }
+  }
+  if (invalidEntries.length > 0) {
+    throw new ClafoutisError(
+      "Invalid generator entries",
+      `The following entries are malformed:
+  - ${invalidEntries.join("\n  - ")}`,
+      'Use format "tailwind,figma" for built-ins or "name:./path/to/plugin.js" for custom generators'
+    );
+  }
+  return entries.filter((e) => e.length > 0);
+}
+async function initCommand(options) {
+  if (options.producer && options.consumer) {
+    throw new ClafoutisError(
+      "Conflicting flags",
+      "Cannot specify both --producer and --consumer",
+      "Choose one: --producer for design system repos, --consumer for application repos"
+    );
+  }
+  const isInteractive = !options.nonInteractive && process.stdin.isTTY;
+  const isDryRun = options.dryRun ?? false;
+  if (isInteractive) {
+    await runInteractiveInit(options, isDryRun);
+  } else {
+    await runNonInteractiveInit(options, isDryRun);
+  }
+}
+async function runInteractiveInit(options, isDryRun) {
+  showIntro(isDryRun);
+  let mode;
+  if (options.producer) {
+    mode = "producer";
+  } else if (options.consumer) {
+    mode = "consumer";
+  } else {
+    const selectedMode = await selectMode();
+    if (!selectedMode) {
+      p2.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    mode = selectedMode;
+  }
+  if (mode === "producer") {
+    const answers = await runProducerWizard();
+    if (!answers) {
+      return;
+    }
+    await createProducerConfig(answers, options.force ?? false, isDryRun);
+  } else {
+    const answers = await runConsumerWizard();
+    if (!answers) {
+      return;
+    }
+    await createConsumerConfig(answers, options.force ?? false, isDryRun);
+  }
+  if (isDryRun) {
+    showOutro("No files were written. Remove --dry-run to apply changes.");
+  } else {
+    showOutro("Setup complete!");
+  }
+}
+async function runNonInteractiveInit(options, isDryRun) {
+  if (!options.producer && !options.consumer) {
+    throw new ClafoutisError(
+      "Mode required",
+      "In non-interactive mode, you must specify --producer or --consumer",
+      "Add --producer or --consumer flag"
+    );
+  }
+  if (options.producer) {
+    const errors = validateProducerFlags(options);
+    if (errors.length > 0) {
+      throw new ClafoutisError(
+        "Invalid flags",
+        errors.join("\n"),
+        "Fix the invalid flags and try again"
+      );
+    }
+    const answers = {
+      generators: options.generators ? parseGenerators(options.generators) : ["tailwind"],
+      tokens: options.tokens ?? "./tokens",
+      output: options.output ?? "./build",
+      workflow: options.workflow ?? true
+    };
+    await createProducerConfig(answers, options.force ?? false, isDryRun);
+  } else {
+    const errors = validateConsumerFlags(options);
+    if (errors.length > 0) {
+      throw new ClafoutisError(
+        "Invalid flags",
+        errors.join("\n"),
+        "Fix the invalid flags and try again"
+      );
+    }
+    if (!options.repo) {
+      throw new ClafoutisError(
+        "Repository required",
+        "In non-interactive mode, --repo is required for consumer setup",
+        "Add --repo=org/repo-name flag"
+      );
+    }
+    const files = {};
+    if (options.files) {
+      for (const mapping of options.files.split(",")) {
+        const colonIdx = mapping.indexOf(":");
+        if (colonIdx === -1) {
+          throw new ClafoutisError(
+            "Invalid file mapping",
+            `Mapping "${mapping.trim()}" is missing a colon separator`,
+            'Use the format "source:destination" (e.g., "tokens.css:./src/styles/tokens.css")'
+          );
+        }
+        const source = mapping.slice(0, colonIdx).trim();
+        const dest = mapping.slice(colonIdx + 1).trim();
+        if (!source) {
+          throw new ClafoutisError(
+            "Invalid file mapping",
+            `Mapping "${mapping.trim()}" has an empty source`,
+            'Provide a valid asset name before the colon (e.g., "tokens.css:./path")'
+          );
+        }
+        if (!dest) {
+          throw new ClafoutisError(
+            "Invalid file mapping",
+            `Mapping "${mapping.trim()}" has an empty destination`,
+            'Provide a valid path after the colon (e.g., "tokens.css:./path")'
+          );
+        }
+        files[source] = dest;
+      }
+    } else {
+      files["tailwind.base.css"] = "./src/styles/base.css";
+      files["tailwind.config.js"] = "./tailwind.config.js";
+    }
+    const answers = {
+      repo: options.repo,
+      files
+    };
+    await createConsumerConfig(answers, options.force ?? false, isDryRun);
+  }
+}
+async function createProducerConfig(answers, force, dryRun) {
+  const configPath = ".clafoutis/producer.json";
+  if (!force && await fileExists(configPath)) {
+    throw new ClafoutisError(
+      "Configuration already exists",
+      configPath,
+      "Use --force to overwrite the existing configuration"
+    );
+  }
+  const generators = {};
+  for (const entry of answers.generators) {
+    const colonIdx = entry.indexOf(":");
+    if (colonIdx > 0) {
+      const name = entry.slice(0, colonIdx).trim();
+      const pluginPath = entry.slice(colonIdx + 1).trim();
+      generators[name] = pluginPath;
+    } else {
+      generators[entry] = true;
+    }
+  }
+  const config = {
+    tokens: answers.tokens,
+    output: answers.output,
+    generators
+  };
+  const filesToCreate = [
+    {
+      path: configPath,
+      content: JSON.stringify(config, null, 2) + "\n",
+      description: `tokens: "${answers.tokens}", output: "${answers.output}"`
+    }
+  ];
+  const starterTokens2 = getAllStarterTokens();
+  for (const token of starterTokens2) {
+    const tokenPath = path2.join(answers.tokens, token.path);
+    if (!force && await fileExists(tokenPath)) {
+      continue;
+    }
+    filesToCreate.push({
+      path: tokenPath,
+      content: token.content,
+      description: "Starter token template"
+    });
+  }
+  if (answers.workflow) {
+    const workflowPath = getWorkflowPath();
+    if (force || !await fileExists(workflowPath)) {
+      filesToCreate.push({
+        path: workflowPath,
+        content: getWorkflowTemplate(),
+        description: "Auto-release workflow on push to main"
+      });
+    }
+  }
+  if (dryRun) {
+    showDryRunOutput(filesToCreate);
+  } else {
+    await writeFiles(filesToCreate);
+    showNextSteps("producer", answers);
+  }
+}
+async function createConsumerConfig(answers, force, dryRun) {
+  const configPath = ".clafoutis/consumer.json";
+  if (!force && await fileExists(configPath)) {
+    throw new ClafoutisError(
+      "Configuration already exists",
+      configPath,
+      "Use --force to overwrite the existing configuration"
+    );
+  }
+  const config = {
+    repo: answers.repo,
+    version: "latest",
+    files: answers.files
+  };
+  const filesToCreate = [
+    {
+      path: configPath,
+      content: JSON.stringify(config, null, 2) + "\n",
+      description: `repo: "${answers.repo}"`
+    }
+  ];
+  if (dryRun) {
+    showDryRunOutput(filesToCreate);
+  } else {
+    await writeFiles(filesToCreate);
+    showNextSteps("consumer", answers);
+  }
+}
+function showDryRunOutput(files) {
+  log3.message("");
+  log3.step("Would create the following files:");
+  log3.message("");
+  for (const file of files) {
+    log3.message(`  ${file.path}`);
+    if (file.description) {
+      log3.message(`  \u2514\u2500 ${file.description}`);
+    }
+  }
+  log3.message("");
+}
+async function writeFiles(files) {
+  for (const file of files) {
+    const dir = path2.dirname(file.path);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(file.path, file.content);
+    log3.success(`Created ${file.path}`);
+  }
+}
+function showNextSteps(mode, answers) {
+  log3.message("");
+  log3.step("Next steps:");
+  if (mode === "producer") {
+    const producerAnswers = answers;
+    log3.message(
+      `  1. Edit ${producerAnswers.tokens}/colors/primitives.json with your design tokens`
+    );
+    log3.message("  2. Run: npx clafoutis generate");
+    log3.message("  3. Push to GitHub - releases will be created automatically");
+  } else {
+    log3.message("  1. Run: npx clafoutis sync");
+    log3.message("  2. Add .clafoutis/cache to .gitignore");
+  }
+}
+
+// src/commands/generate.ts
+async function loadPlugin(pluginPath) {
+  const absolutePath = path2.resolve(process.cwd(), pluginPath);
+  if (pluginPath.endsWith(".ts")) {
+    const { register } = await import('tsx/esm/api');
+    register();
+  }
+  return import(pathToFileURL(absolutePath).href);
+}
+async function generateCommand(options) {
+  const configPath = options.config || ".clafoutis/producer.json";
+  let config = await readProducerConfig(configPath);
+  if (!config) {
+    if (await fileExists(configPath)) {
+      throw new ClafoutisError(
+        "Invalid configuration",
+        `Could not parse ${configPath}`,
+        "Ensure the file contains valid JSON"
+      );
+    }
+    if (process.stdin.isTTY) {
+      const shouldRunWizard = await offerWizard("producer");
+      if (shouldRunWizard) {
+        await initCommand({ producer: true });
+        config = await readProducerConfig(configPath);
+        if (!config) {
+          throw configNotFoundError(configPath, false);
+        }
+      } else {
+        throw configNotFoundError(configPath, false);
+      }
+    } else {
+      throw configNotFoundError(configPath, false);
+    }
+  }
+  validateProducerConfig(config);
+  if (options.tailwind !== void 0 || options.figma !== void 0) {
+    config = {
+      ...config,
+      generators: {
+        ...config.generators || {},
+        ...options.tailwind !== void 0 && { tailwind: options.tailwind },
+        ...options.figma !== void 0 && { figma: options.figma }
+      }
+    };
+  }
+  if (options.output) {
+    config.output = options.output;
+  }
+  const tokensDir = path2.resolve(process.cwd(), config.tokens || "./tokens");
+  const outputDir = path2.resolve(process.cwd(), config.output || "./build");
+  if (!await fileExists(tokensDir)) {
+    throw tokensDirNotFoundError(tokensDir);
+  }
+  const generators = config.generators || { tailwind: true, figma: true };
+  if (options.dryRun) {
+    logger.info("[dry-run] Would read tokens from: " + tokensDir);
+    logger.info("[dry-run] Would write to: " + outputDir);
+    for (const [name, value] of Object.entries(generators)) {
+      if (value !== false) {
+        const type = typeof value === "string" ? "custom" : "built-in";
+        logger.info(`[dry-run] Would run generator: ${name} (${type})`);
+      }
+    }
+    return;
+  }
+  logger.info(`Tokens: ${tokensDir}`);
+  logger.info(`Output: ${outputDir}`);
+  let hadFailure = false;
+  for (const [name, value] of Object.entries(generators)) {
+    if (value === false) continue;
+    logger.info(`Running ${name} generator...`);
+    try {
+      let generatorModule;
+      if (typeof value === "string") {
+        try {
+          generatorModule = await loadPlugin(value);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          throw pluginLoadError(value, errorMessage);
+        }
+        if (typeof generatorModule.generate !== "function") {
+          throw pluginLoadError(
+            value,
+            'Module does not export a "generate" function'
+          );
+        }
+      } else {
+        const builtInGenerators = {
+          tailwind: async () => import('@clafoutis/generators/tailwind'),
+          figma: async () => import('@clafoutis/generators/figma')
+        };
+        if (!builtInGenerators[name]) {
+          throw generatorNotFoundError(name);
+        }
+        try {
+          generatorModule = await builtInGenerators[name]();
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          throw pluginLoadError(`@clafoutis/generators/${name}`, errorMessage);
+        }
+      }
+      const context = {
+        tokensDir,
+        outputDir: path2.join(outputDir, name),
+        config,
+        StyleDictionary
+      };
+      await generatorModule.generate(context);
+      logger.success(`${name} complete`);
+    } catch (err) {
+      if (err instanceof ClafoutisError) {
+        throw err;
+      }
+      logger.error(`${name} failed: ${err}`);
+      hadFailure = true;
+    }
+  }
+  if (hadFailure) {
+    throw new ClafoutisError(
+      "Generation failed",
+      "One or more generators failed",
+      "Check the error messages above and fix the issues"
+    );
+  }
+  logger.success("Generation complete");
+}
+var CACHE_DIR = ".clafoutis";
+var CACHE_FILE = `${CACHE_DIR}/cache`;
+async function readCache() {
+  try {
+    return (await fs.readFile(CACHE_FILE, "utf-8")).trim();
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
+async function writeCache(version) {
+  await fs.mkdir(CACHE_DIR, { recursive: true });
+  await fs.writeFile(CACHE_FILE, version);
+}
+async function downloadRelease(config) {
+  const token = process.env.CLAFOUTIS_REPO_TOKEN;
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "clafoutis-cli"
+  };
+  if (token) {
+    headers["Authorization"] = `token ${token}`;
+  }
+  const isLatest = config.version === "latest";
+  const releaseUrl = isLatest ? `https://api.github.com/repos/${config.repo}/releases/latest` : `https://api.github.com/repos/${config.repo}/releases/tags/${config.version}`;
+  const releaseRes = await fetch(releaseUrl, { headers });
+  if (!releaseRes.ok) {
+    if (releaseRes.status === 404) {
+      throw releaseNotFoundError(config.version, config.repo);
+    } else if (releaseRes.status === 401 || releaseRes.status === 403) {
+      throw authRequiredError();
+    } else {
+      logger.error(`GitHub API error: ${releaseRes.status}`);
+      process.exit(1);
+    }
+  }
+  const release = await releaseRes.json();
+  const resolvedTag = release.tag_name;
+  if (isLatest) {
+    logger.info(`Resolved "latest" to ${resolvedTag}`);
+  }
+  const files = /* @__PURE__ */ new Map();
+  const missingAssets = [];
+  const failedDownloads = [];
+  for (const assetName of Object.keys(config.files)) {
+    const asset = release.assets.find((a) => a.name === assetName);
+    if (!asset) {
+      missingAssets.push(assetName);
+      continue;
+    }
+    logger.info(`Downloading ${assetName}...`);
+    const downloadHeaders = { ...headers, Accept: "application/octet-stream" };
+    const fileRes = await fetch(asset.url, { headers: downloadHeaders });
+    if (!fileRes.ok) {
+      failedDownloads.push(assetName);
+      continue;
+    }
+    files.set(assetName, await fileRes.text());
+  }
+  const errors = [];
+  if (missingAssets.length > 0) {
+    errors.push(`Assets not found in release: ${missingAssets.join(", ")}`);
+  }
+  if (failedDownloads.length > 0) {
+    errors.push(`Failed to download: ${failedDownloads.join(", ")}`);
+  }
+  if (errors.length > 0) {
+    const availableAssets = release.assets.map((a) => a.name).join(", ");
+    throw new ClafoutisError(
+      "Download failed",
+      errors.join("\n"),
+      `Available assets in ${resolvedTag}: ${availableAssets || "none"}`
+    );
+  }
+  return { files, resolvedTag };
+}
+
+// src/commands/sync.ts
+async function writeOutput(config, files) {
+  for (const [assetName, content] of files) {
+    const configPath = config.files[assetName];
+    if (!configPath) continue;
+    const outputPath = path2.resolve(process.cwd(), configPath);
+    await fs.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, content);
+    logger.success(`Written: ${outputPath}`);
+  }
+}
+async function syncCommand(options) {
+  const configPath = options.config || ".clafoutis/consumer.json";
+  let config = await readConfig(configPath);
+  if (!config) {
+    if (await fileExists(configPath)) {
+      throw new ClafoutisError(
+        "Invalid configuration",
+        `Could not parse ${configPath}`,
+        "Ensure the file contains valid JSON"
+      );
+    }
+    if (process.stdin.isTTY) {
+      const shouldRunWizard = await offerWizard("consumer");
+      if (shouldRunWizard) {
+        await initCommand({ consumer: true });
+        config = await readConfig(configPath);
+        if (!config) {
+          throw configNotFoundError(configPath, true);
+        }
+      } else {
+        throw configNotFoundError(configPath, true);
+      }
+    } else {
+      throw configNotFoundError(configPath, true);
+    }
+  }
+  validateConsumerConfig(config);
+  const cachedVersion = await readCache();
+  const isLatest = config.version === "latest";
+  logger.info(`Repo: ${config.repo}`);
+  logger.info(`Pinned: ${config.version}`);
+  logger.info(`Cached: ${cachedVersion || "none"}`);
+  if (options.dryRun) {
+    logger.info(
+      "[dry-run] Would download from: " + config.repo + " " + config.version
+    );
+    for (const [assetName, outputPath] of Object.entries(config.files)) {
+      logger.info(`[dry-run] ${assetName} \u2192 ${outputPath}`);
+    }
+    return;
+  }
+  const resolveOutputPaths = () => Object.values(config.files).map((p5) => path2.resolve(process.cwd(), p5));
+  if (!isLatest && !options.force && config.version === cachedVersion) {
+    const outputPaths = resolveOutputPaths();
+    const existsResults = await Promise.all(
+      outputPaths.map((p5) => fileExists(p5))
+    );
+    const allOutputsExist = existsResults.every((exists) => exists);
+    if (allOutputsExist) {
+      logger.success(`Already at ${config.version} - no sync needed`);
+      return;
+    }
+  }
+  logger.warn(`Syncing ${config.version}...`);
+  const { files, resolvedTag } = await downloadRelease(config);
+  if (isLatest && !options.force && resolvedTag === cachedVersion) {
+    const outputPaths = resolveOutputPaths();
+    const existsResults = await Promise.all(
+      outputPaths.map((p5) => fileExists(p5))
+    );
+    const allOutputsExist = existsResults.every((exists) => exists);
+    if (allOutputsExist) {
+      logger.success(`Already at ${resolvedTag} (latest) - no sync needed`);
+      return;
+    }
+  }
+  await writeOutput(config, files);
+  await writeCache(resolvedTag);
+  logger.success(`Synced to ${resolvedTag}`);
+  if (config.postSync) {
+    await runPostSync(config.postSync);
+  }
+}
+async function runPostSync(command) {
+  logger.info(`Running postSync: ${command}`);
+  const isWindows = process.platform === "win32";
+  const shell = isWindows ? "cmd.exe" : "/bin/sh";
+  const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+  return new Promise((resolve, reject) => {
+    const child = spawn(shell, shellArgs, {
+      stdio: ["inherit", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (err) => {
+      reject(
+        new ClafoutisError(
+          "postSync failed",
+          `Failed to spawn command: ${err.message}`,
+          "Check that the command is valid and executable"
+        )
+      );
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        if (stdout.trim()) {
+          logger.info(stdout.trim());
+        }
+        logger.success("postSync completed");
+        resolve();
+      } else {
+        const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+        logger.error(`postSync output:
+${output || "(no output)"}`);
+        reject(
+          new ClafoutisError(
+            "postSync failed",
+            `Command exited with code ${code}`,
+            "Review the command output above and fix any issues"
+          )
+        );
+      }
+    });
+  });
+}
+
+// src/index.ts
+var program = new Command();
+function displayError(err) {
+  if (process.stdin.isTTY) {
+    p2.log.error(`${err.title}: ${err.detail}`);
+    if (err.suggestion) {
+      p2.log.info(`Suggestion: ${err.suggestion}`);
+    }
+  } else {
+    console.error(err.format());
+  }
+}
+function withErrorHandling(fn) {
+  return async (options) => {
+    try {
+      await fn(options);
+    } catch (err) {
+      if (err instanceof ClafoutisError) {
+        displayError(err);
+        process.exit(1);
+      }
+      throw err;
+    }
+  };
+}
+function handleUnexpectedError(err) {
+  if (err instanceof ClafoutisError) {
+    displayError(err);
+  } else {
+    const message = err instanceof Error ? err.message : String(err);
+    if (process.stdin.isTTY) {
+      p2.log.error(`Unexpected error: ${message}`);
+      p2.log.info(
+        "Please report this issue at: https://github.com/Dessert-Labs/clafoutis/issues"
+      );
+    } else {
+      console.error(`
+Unexpected error: ${message}
+`);
+      console.error(
+        "Please report this issue at: https://github.com/Dessert-Labs/clafoutis/issues"
+      );
+    }
+  }
+  process.exit(1);
+}
+process.on("uncaughtException", handleUnexpectedError);
+process.on("unhandledRejection", (reason) => {
+  handleUnexpectedError(reason);
+});
+program.name("clafoutis").description("GitOps powered design system - generate and sync design tokens").version("0.1.0");
+program.command("generate").description("Generate platform outputs from design tokens (for producers)").option(
+  "-c, --config <path>",
+  "Path to config file",
+  ".clafoutis/producer.json"
+).option("--tailwind", "Generate Tailwind output").option("--figma", "Generate Figma variables").option("-o, --output <dir>", "Output directory", "./build").option("--dry-run", "Preview changes without writing files").action(withErrorHandling(generateCommand));
+program.command("sync").description("Sync design tokens from GitHub Release (for consumers)").option("-f, --force", "Force sync even if versions match").option(
+  "-c, --config <path>",
+  "Path to config file",
+  ".clafoutis/consumer.json"
+).option("--dry-run", "Preview changes without writing files").action(withErrorHandling(syncCommand));
+program.command("init").description("Initialize Clafoutis configuration").option("--producer", "Set up as a design token producer").option("--consumer", "Set up as a design token consumer").option("-r, --repo <repo>", "GitHub repo for consumer mode (org/name)").option("-t, --tokens <path>", "Token directory path (default: ./tokens)").option("-o, --output <path>", "Output directory path (default: ./build)").option(
+  "-g, --generators <list>",
+  "Comma-separated generators: tailwind, figma"
+).option("--workflow", "Create GitHub Actions workflow (default: true)").option("--no-workflow", "Skip GitHub Actions workflow").option(
+  "--files <mapping>",
+  "File mappings for consumer: asset:dest,asset:dest"
+).option("--force", "Overwrite existing configuration").option("--dry-run", "Preview changes without writing files").option("--non-interactive", "Skip prompts, use defaults or flags").action(withErrorHandling(initCommand));
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map