@clafoutis/cli 1.1.2 → 1.2.1

package/dist/index.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import * as p2 from '@clack/prompts';
 import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { logger } from '@clafoutis/shared';
 import { generate } from '@clafoutis/generators/figma';
 import { generate as generate$1 } from '@clafoutis/generators/tailwind';
-import { logger } from '@clafoutis/shared';
-import path from 'path';
 import StyleDictionary from 'style-dictionary';
 import { register } from 'tsx/esm/api';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Ajv } from 'ajv';
-import fs from 'fs/promises';
-import fs2 from 'fs';
+import fs2 from 'fs/promises';
 import { spawn } from 'child_process';
 
 // src/utils/errors.ts
@@ -88,7 +88,128 @@ function tokensDirNotFoundError(tokensDir) {
   );
 }
 
-// src/cli/validation.ts
+// src/utils/cwd.ts
+function resolveCommandCwd(cwdOverride) {
+  const cwd = cwdOverride?.trim() ? cwdOverride : process.cwd();
+  return path.resolve(cwd);
+}
+function resolveInCwd(commandCwd, targetPath) {
+  return path.isAbsolute(targetPath) ? path.resolve(targetPath) : path.resolve(commandCwd, targetPath);
+}
+function displayPath(commandCwd, absolutePath) {
+  const rel = path.relative(commandCwd, absolutePath);
+  return rel && !rel.startsWith("..") ? rel : absolutePath;
+}
+function validateCwdOption(cwdOverride) {
+  if (cwdOverride !== void 0 && cwdOverride.trim() === "") {
+    throw new ClafoutisError(
+      "Invalid --cwd value",
+      "--cwd cannot be empty",
+      "Provide a valid directory path, for example: --cwd ./packages/design-system"
+    );
+  }
+}
+
+// src/commands/format.ts
+function loadTokenFiles(dirPath) {
+  const files = [];
+  function walk(dir, prefix) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(fullPath, relativePath);
+      } else if (entry.name.endsWith(".json")) {
+        try {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          files.push({ relativePath, fullPath, content });
+        } catch (err) {
+          logger.warn(
+            `Failed to read ${relativePath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+  }
+  walk(dirPath, "");
+  return files;
+}
+function formatJson(content) {
+  const parsed = JSON.parse(content);
+  return JSON.stringify(parsed, null, 2) + "\n";
+}
+function formatCommand(options) {
+  validateCwdOption(options.cwd);
+  const commandCwd = resolveCommandCwd(options.cwd);
+  const tokensDir = resolveInCwd(commandCwd, options.tokens || "./tokens");
+  if (!fs.existsSync(tokensDir)) {
+    throw tokensDirNotFoundError(tokensDir);
+  }
+  logger.info(`Formatting token files in ${tokensDir}...`);
+  const files = loadTokenFiles(tokensDir);
+  const fileCount = files.length;
+  if (fileCount === 0) {
+    logger.warn(`No JSON files found in ${tokensDir}`);
+    return;
+  }
+  let changedCount = 0;
+  const unformattedFiles = [];
+  for (const { relativePath, fullPath, content } of files) {
+    try {
+      const formatted = formatJson(content);
+      if (content !== formatted) {
+        if (options.check) {
+          unformattedFiles.push(relativePath);
+          changedCount++;
+        } else if (options.dryRun) {
+          logger.info(`Would format: ${relativePath}`);
+          changedCount++;
+        } else {
+          fs.writeFileSync(fullPath, formatted, "utf-8");
+          logger.info(`Formatted: ${relativePath}`);
+          changedCount++;
+        }
+      }
+    } catch (err) {
+      logger.error(
+        `Failed to format ${relativePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err;
+    }
+  }
+  if (options.check) {
+    if (changedCount > 0) {
+      logger.error(
+        `${changedCount} of ${fileCount} files are not formatted correctly:`
+      );
+      for (const file of unformattedFiles) {
+        logger.error(`  - ${file}`);
+      }
+      logger.info(
+        `Run 'npx clafoutis format --tokens ${tokensDir}' to fix formatting.`
+      );
+      process.exit(1);
+    }
+    logger.success(`All ${fileCount} files are correctly formatted`);
+    return;
+  }
+  if (options.dryRun) {
+    if (changedCount > 0) {
+      logger.info(`Would format ${changedCount} of ${fileCount} files`);
+    } else {
+      logger.info(`All ${fileCount} files are already formatted`);
+    }
+    return;
+  }
+  if (changedCount > 0) {
+    logger.success(`Formatted ${changedCount} of ${fileCount} files`);
+  } else {
+    logger.success(`All ${fileCount} files are already formatted`);
+  }
+}
 function validateRepo(value) {
   if (!value) {
     return "Repository is required";
@@ -163,8 +284,8 @@ function findUnknownFields(config, schemaProperties, prefix = "") {
   }
   return unknown;
 }
-function hasField(config, path5) {
-  const parts = path5.split(".");
+function hasField(config, path8) {
+  const parts = path8.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -378,7 +499,7 @@ var log3 = {
 };
 async function readConfig(configPath) {
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs2.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -386,7 +507,7 @@ async function readConfig(configPath) {
 }
 async function readProducerConfig(configPath) {
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs2.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -394,7 +515,7 @@ async function readProducerConfig(configPath) {
 }
 async function fileExists(filePath) {
   try {
-    await fs.access(filePath);
+    await fs2.access(filePath);
     return true;
   } catch {
     return false;
@@ -496,9 +617,9 @@ var __filename$1 = fileURLToPath(import.meta.url);
 var __dirname$1 = path.dirname(__filename$1);
 function getTokensDir() {
   const devPath = path.resolve(__dirname$1, "tokens");
-  if (fs2.existsSync(devPath)) return devPath;
+  if (fs.existsSync(devPath)) return devPath;
   const distPath = path.resolve(__dirname$1, "templates", "tokens");
-  if (fs2.existsSync(distPath)) return distPath;
+  if (fs.existsSync(distPath)) return distPath;
   throw new Error(
     `Starter token templates not found. Searched:
   ${devPath}
@@ -507,7 +628,7 @@ function getTokensDir() {
 }
 function walkTokensDir(dir, base = "") {
   const result = [];
-  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const relPath = base ? path.join(base, entry.name) : entry.name;
     const fullPath = path.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -515,7 +636,7 @@ function walkTokensDir(dir, base = "") {
     } else if (entry.name.endsWith(".json")) {
       result.push({
         path: relPath,
-        content: fs2.readFileSync(fullPath, "utf-8")
+        content: fs.readFileSync(fullPath, "utf-8")
       });
     }
   }
@@ -535,6 +656,7 @@ on:
     branches: [main]
     paths:
       - 'tokens/**'
+      - '.clafoutis/producer.json'
 
 jobs:
   release:
@@ -554,9 +676,24 @@ jobs:
       - name: Install Clafoutis
         run: npm install -D @clafoutis/cli
 
+      - name: Check token file formatting
+        run: npx clafoutis format --tokens tokens --check
+
       - name: Generate tokens
         run: npx clafoutis generate
 
+      - name: Commit generated build artifacts
+        run: |
+          if [ -z "$(git status --porcelain build)" ]; then
+            echo "No build changes to commit"
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add build
+          git commit -m "chore: update generated build artifacts"
+          git push
+
       - name: Get next version
         id: version
         run: |
@@ -640,15 +777,17 @@ async function initCommand(options) {
       "Choose one: --producer for design system repos, --consumer for application repos"
     );
   }
+  validateCwdOption(options.cwd);
+  const commandCwd = resolveCommandCwd(options.cwd);
   const isInteractive = !options.nonInteractive && process.stdin.isTTY;
   const isDryRun = options.dryRun ?? false;
   if (isInteractive) {
-    await runInteractiveInit(options, isDryRun);
+    await runInteractiveInit(options, isDryRun, commandCwd);
   } else {
-    await runNonInteractiveInit(options, isDryRun);
+    await runNonInteractiveInit(options, isDryRun, commandCwd);
   }
 }
-async function runInteractiveInit(options, isDryRun) {
+async function runInteractiveInit(options, isDryRun, commandCwd) {
   showIntro(isDryRun);
   let mode;
   if (options.producer) {
@@ -668,13 +807,23 @@ async function runInteractiveInit(options, isDryRun) {
     if (!answers) {
       return;
     }
-    await createProducerConfig(answers, options.force ?? false, isDryRun);
+    await createProducerConfig(
+      answers,
+      options.force ?? false,
+      isDryRun,
+      commandCwd
+    );
   } else {
     const answers = await runConsumerWizard();
     if (!answers) {
       return;
     }
-    await createConsumerConfig(answers, options.force ?? false, isDryRun);
+    await createConsumerConfig(
+      answers,
+      options.force ?? false,
+      isDryRun,
+      commandCwd
+    );
   }
   if (isDryRun) {
     showOutro("No files were written. Remove --dry-run to apply changes.");
@@ -682,7 +831,7 @@ async function runInteractiveInit(options, isDryRun) {
     showOutro("Setup complete!");
   }
 }
-async function runNonInteractiveInit(options, isDryRun) {
+async function runNonInteractiveInit(options, isDryRun, commandCwd) {
   if (!options.producer && !options.consumer) {
     throw new ClafoutisError(
       "Mode required",
@@ -705,7 +854,12 @@ async function runNonInteractiveInit(options, isDryRun) {
       output: options.output ?? "./build",
       workflow: options.workflow ?? true
     };
-    await createProducerConfig(answers, options.force ?? false, isDryRun);
+    await createProducerConfig(
+      answers,
+      options.force ?? false,
+      isDryRun,
+      commandCwd
+    );
   } else {
     const errors = validateConsumerFlags(options);
     if (errors.length > 0) {
@@ -759,11 +913,16 @@ async function runNonInteractiveInit(options, isDryRun) {
       repo: options.repo,
       files
     };
-    await createConsumerConfig(answers, options.force ?? false, isDryRun);
+    await createConsumerConfig(
+      answers,
+      options.force ?? false,
+      isDryRun,
+      commandCwd
+    );
   }
 }
-async function createProducerConfig(answers, force, dryRun) {
-  const configPath = ".clafoutis/producer.json";
+async function createProducerConfig(answers, force, dryRun, commandCwd) {
+  const configPath = resolveInCwd(commandCwd, ".clafoutis/producer.json");
   if (!force && await fileExists(configPath)) {
     throw new ClafoutisError(
       "Configuration already exists",
@@ -796,7 +955,10 @@ async function createProducerConfig(answers, force, dryRun) {
   ];
   const starterTokens = getAllStarterTokens();
   for (const token of starterTokens) {
-    const tokenPath = path.join(answers.tokens, token.path);
+    const tokenPath = resolveInCwd(
+      commandCwd,
+      path.join(answers.tokens, token.path)
+    );
     if (!force && await fileExists(tokenPath)) {
       continue;
     }
@@ -807,7 +969,7 @@ async function createProducerConfig(answers, force, dryRun) {
     });
   }
   if (answers.workflow) {
-    const workflowPath = getWorkflowPath();
+    const workflowPath = resolveInCwd(commandCwd, getWorkflowPath());
     if (force || !await fileExists(workflowPath)) {
       filesToCreate.push({
         path: workflowPath,
@@ -816,22 +978,23 @@ async function createProducerConfig(answers, force, dryRun) {
       });
     }
   }
-  if (force || !await fileExists(".gitignore")) {
+  const gitignorePath = resolveInCwd(commandCwd, ".gitignore");
+  if (force || !await fileExists(gitignorePath)) {
     filesToCreate.push({
-      path: ".gitignore",
+      path: gitignorePath,
       content: getProducerGitignore(),
       description: "Ignore build artifacts and release-assets"
     });
   }
   if (dryRun) {
-    showDryRunOutput(filesToCreate);
+    showDryRunOutput(filesToCreate, commandCwd);
   } else {
-    await writeFiles(filesToCreate);
+    await writeFiles(filesToCreate, commandCwd);
     showNextSteps("producer", answers);
   }
 }
-async function createConsumerConfig(answers, force, dryRun) {
-  const configPath = ".clafoutis/consumer.json";
+async function createConsumerConfig(answers, force, dryRun, commandCwd) {
+  const configPath = resolveInCwd(commandCwd, ".clafoutis/consumer.json");
   if (!force && await fileExists(configPath)) {
     throw new ClafoutisError(
       "Configuration already exists",
@@ -851,10 +1014,10 @@ async function createConsumerConfig(answers, force, dryRun) {
       description: `repo: "${answers.repo}"`
     }
   ];
-  const gitignorePath = ".gitignore";
+  const gitignorePath = resolveInCwd(commandCwd, ".gitignore");
   const consumerIgnore = getConsumerGitignore();
   if (await fileExists(gitignorePath)) {
-    const existingContent = await fs.readFile(gitignorePath, "utf-8");
+    const existingContent = await fs2.readFile(gitignorePath, "utf-8");
     if (!existingContent.includes(".clafoutis/cache")) {
       filesToCreate.push({
         path: gitignorePath,
@@ -870,30 +1033,30 @@ async function createConsumerConfig(answers, force, dryRun) {
     });
   }
   if (dryRun) {
-    showDryRunOutput(filesToCreate);
+    showDryRunOutput(filesToCreate, commandCwd);
   } else {
-    await writeFiles(filesToCreate);
+    await writeFiles(filesToCreate, commandCwd);
     showNextSteps("consumer", answers);
   }
 }
-function showDryRunOutput(files) {
+function showDryRunOutput(files, commandCwd) {
   log3.message("");
   log3.step("Would create the following files:");
   log3.message("");
   for (const file of files) {
-    log3.message(`  ${file.path}`);
+    log3.message(`  ${displayPath(commandCwd, file.path)}`);
     if (file.description) {
       log3.message(`  \u2514\u2500 ${file.description}`);
     }
   }
   log3.message("");
 }
-async function writeFiles(files) {
+async function writeFiles(files, commandCwd) {
   for (const file of files) {
     const dir = path.dirname(file.path);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(file.path, file.content);
-    log3.success(`Created ${file.path}`);
+    await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(file.path, file.content);
+    log3.success(`Created ${displayPath(commandCwd, file.path)}`);
   }
 }
 function showNextSteps(mode, answers) {
@@ -904,23 +1067,34 @@ function showNextSteps(mode, 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");
+    if (producerAnswers.workflow) {
+      log3.message(
+        "  2. Push to GitHub - the workflow will generate outputs and create a release automatically"
+      );
+    } else {
+      log3.message("  2. Run: npx clafoutis generate");
+      log3.message("  3. Push to GitHub to share your design system");
+    }
   } else {
     log3.message("  1. Run: npx clafoutis sync");
   }
 }
 
 // src/commands/generate.ts
-async function loadPlugin(pluginPath) {
-  const absolutePath = path.resolve(process.cwd(), pluginPath);
+async function loadPlugin(pluginPath, commandCwd) {
+  const absolutePath = resolveInCwd(commandCwd, pluginPath);
   if (pluginPath.endsWith(".ts")) {
     register();
   }
   return import(pathToFileURL(absolutePath).href);
 }
 async function generateCommand(options) {
-  const configPath = options.config || ".clafoutis/producer.json";
+  validateCwdOption(options.cwd);
+  const commandCwd = resolveCommandCwd(options.cwd);
+  const configPath = resolveInCwd(
+    commandCwd,
+    options.config || ".clafoutis/producer.json"
+  );
   let config = await readProducerConfig(configPath);
   if (!config) {
     if (await fileExists(configPath)) {
@@ -933,7 +1107,7 @@ async function generateCommand(options) {
     if (process.stdin.isTTY) {
       const shouldRunWizard = await offerWizard("producer");
       if (shouldRunWizard) {
-        await initCommand({ producer: true });
+        await initCommand({ producer: true, cwd: commandCwd });
         config = await readProducerConfig(configPath);
         if (!config) {
           throw configNotFoundError(configPath, false);
@@ -959,8 +1133,8 @@ async function generateCommand(options) {
   if (options.output) {
     config.output = options.output;
   }
-  const tokensDir = path.resolve(process.cwd(), config.tokens || "./tokens");
-  const outputDir = path.resolve(process.cwd(), config.output || "./build");
+  const tokensDir = resolveInCwd(commandCwd, config.tokens || "./tokens");
+  const outputDir = resolveInCwd(commandCwd, config.output || "./build");
   if (!await fileExists(tokensDir)) {
     throw tokensDirNotFoundError(tokensDir);
   }
@@ -986,7 +1160,7 @@ async function generateCommand(options) {
       let generatorModule;
       if (typeof value === "string") {
         try {
-          generatorModule = await loadPlugin(value);
+          generatorModule = await loadPlugin(value, commandCwd);
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
           throw pluginLoadError(value, errorMessage);
@@ -1033,10 +1207,18 @@ async function generateCommand(options) {
   logger.success("Generation complete");
 }
 var CACHE_DIR = ".clafoutis";
-var CACHE_FILE = `${CACHE_DIR}/cache`;
-async function readCache() {
+var CACHE_FILE = "cache";
+function getCachePaths(commandCwd) {
+  const dir = path.resolve(commandCwd, CACHE_DIR);
+  return {
+    dir,
+    file: path.join(dir, CACHE_FILE)
+  };
+}
+async function readCache(commandCwd = process.cwd()) {
+  const { file } = getCachePaths(commandCwd);
   try {
-    return (await fs.readFile(CACHE_FILE, "utf-8")).trim();
+    return (await fs2.readFile(file, "utf-8")).trim();
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") {
       return null;
@@ -1044,9 +1226,10 @@ async function readCache() {
     throw err;
   }
 }
-async function writeCache(version) {
-  await fs.mkdir(CACHE_DIR, { recursive: true });
-  await fs.writeFile(CACHE_FILE, version);
+async function writeCache(version, commandCwd = process.cwd()) {
+  const { dir, file } = getCachePaths(commandCwd);
+  await fs2.mkdir(dir, { recursive: true });
+  await fs2.writeFile(file, version);
 }
 async function downloadRelease(config) {
   const token = process.env.CLAFOUTIS_REPO_TOKEN;
@@ -1112,18 +1295,23 @@ async function downloadRelease(config) {
 }
 
 // src/commands/sync.ts
-async function writeOutput(config, files) {
+async function writeOutput(config, files, commandCwd) {
   for (const [assetName, content] of files) {
     const configPath = config.files[assetName];
     if (!configPath) continue;
-    const outputPath = path.resolve(process.cwd(), configPath);
-    await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, content);
+    const outputPath = resolveInCwd(commandCwd, configPath);
+    await fs2.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, content);
     logger.success(`Written: ${outputPath}`);
   }
 }
 async function syncCommand(options) {
-  const configPath = options.config || ".clafoutis/consumer.json";
+  validateCwdOption(options.cwd);
+  const commandCwd = resolveCommandCwd(options.cwd);
+  const configPath = resolveInCwd(
+    commandCwd,
+    options.config || ".clafoutis/consumer.json"
+  );
   let config = await readConfig(configPath);
   if (!config) {
     if (await fileExists(configPath)) {
@@ -1136,7 +1324,7 @@ async function syncCommand(options) {
     if (process.stdin.isTTY) {
       const shouldRunWizard = await offerWizard("consumer");
       if (shouldRunWizard) {
-        await initCommand({ consumer: true });
+        await initCommand({ consumer: true, cwd: commandCwd });
         config = await readConfig(configPath);
         if (!config) {
           throw configNotFoundError(configPath, true);
@@ -1149,7 +1337,7 @@ async function syncCommand(options) {
     }
   }
   validateConsumerConfig(config);
-  const cachedVersion = await readCache();
+  const cachedVersion = await readCache(commandCwd);
   const isLatest = config.version === "latest";
   logger.info(`Repo: ${config.repo}`);
   logger.info(`Pinned: ${config.version}`);
@@ -1163,7 +1351,7 @@ async function syncCommand(options) {
     }
     return;
   }
-  const resolveOutputPaths = () => Object.values(config.files).map((p5) => path.resolve(process.cwd(), p5));
+  const resolveOutputPaths = () => Object.values(config.files).map((p5) => resolveInCwd(commandCwd, p5));
   if (!isLatest && !options.force && config.version === cachedVersion) {
     const outputPaths = resolveOutputPaths();
     const existsResults = await Promise.all(
@@ -1188,14 +1376,14 @@ async function syncCommand(options) {
       return;
     }
   }
-  await writeOutput(config, files);
-  await writeCache(resolvedTag);
+  await writeOutput(config, files, commandCwd);
+  await writeCache(resolvedTag, commandCwd);
   logger.success(`Synced to ${resolvedTag}`);
   if (config.postSync) {
-    await runPostSync(config.postSync);
+    await runPostSync(config.postSync, commandCwd);
   }
 }
-async function runPostSync(command) {
+async function runPostSync(command, commandCwd) {
   logger.info(`Running postSync: ${command}`);
   const isWindows = process.platform === "win32";
   const shell = isWindows ? "cmd.exe" : "/bin/sh";
@@ -1203,7 +1391,8 @@ async function runPostSync(command) {
   return new Promise((resolve, reject) => {
     const child = spawn(shell, shellArgs, {
       stdio: ["inherit", "pipe", "pipe"],
-      env: process.env
+      env: process.env,
+      cwd: commandCwd
     });
     let stdout = "";
     let stderr = "";
@@ -1300,19 +1489,23 @@ program.command("generate").description("Generate platform outputs from design t
   "-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));
+).option("--tailwind", "Generate Tailwind output").option("--figma", "Generate Figma variables").option("-o, --output <dir>", "Output directory", "./build").option("--cwd <path>", "Run command as if from this directory").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));
+).option("--cwd <path>", "Run command as if from this directory").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));
+).option("--force", "Overwrite existing configuration").option("--dry-run", "Preview changes without writing files").option("--non-interactive", "Skip prompts, use defaults or flags").option("--cwd <path>", "Run command as if from this directory").action(withErrorHandling(initCommand));
+program.command("format").description("Format token JSON files for consistent formatting").option("-t, --tokens <path>", "Token directory path", "./tokens").option(
+  "--check",
+  "Check formatting without modifying files (fails if unformatted)"
+).option("--cwd <path>", "Run command as if from this directory").option("--dry-run", "Preview changes without writing files").action(withErrorHandling(formatCommand));
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map