@ryndesign/cli 0.1.1

package/dist/bin.cjs

@@ -0,0 +1,1332 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  default: () => init_default
+});
+function generateConfig(platforms, darkMode) {
+  const imports = [];
+  const generators = [];
+  for (const platform of platforms) {
+    const pkgName = `@ryndesign/generator-${platform}`;
+    const varName = platform.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    imports.push(`import ${varName} from '${pkgName}';`);
+    if (["react", "vue", "svelte"].includes(platform)) {
+      generators.push(`    ${varName}({
+      outDir: 'generated/${platform}',
+      cssStrategy: 'css-variables',
+      typescript: true,${darkMode ? "\n      darkMode: 'media+class'," : ""}
+    })`);
+    } else {
+      generators.push(`    ${varName}({
+      outDir: 'generated/${platform}',
+    })`);
+    }
+  }
+  return `import { defineConfig } from '@ryndesign/cli';
+${imports.join("\n")}
+
+export default defineConfig({
+  tokens: ['tokens/**/*.tokens.json'],
+  components: ['components/**/*.component.json'],
+  outDir: 'generated',
+${darkMode ? `
+  themes: {
+    default: 'light',
+    dark: { file: 'tokens/dark.tokens.json' },
+  },
+` : ""}
+  generators: [
+${generators.join(",\n")}
+  ],
+
+  preview: { port: 4400, open: true },
+});
+`;
+}
+function getDefaultTokens() {
+  return {
+    color: {
+      $type: "color",
+      primary: { $value: "#3B82F6" },
+      white: { $value: "#FFFFFF" },
+      black: { $value: "#000000" },
+      gray: {
+        50: { $value: "#F9FAFB" },
+        900: { $value: "#111827" }
+      }
+    },
+    spacing: {
+      $type: "dimension",
+      sm: { $value: "8px" },
+      md: { $value: "16px" },
+      lg: { $value: "24px" }
+    }
+  };
+}
+function getSemanticTokens() {
+  return {
+    color: {
+      $type: "color",
+      background: {
+        primary: { $value: "{color.white}" },
+        secondary: { $value: "{color.gray.50}" }
+      },
+      text: {
+        primary: { $value: "{color.gray.900}" }
+      }
+    }
+  };
+}
+function getDarkTokens() {
+  return {
+    $description: "Dark theme overrides",
+    $extensions: { "com.ryndesign.theme": { name: "dark", extends: "default" } },
+    color: {
+      $type: "color",
+      background: {
+        primary: { $value: "{color.gray.900}" },
+        secondary: { $value: "{color.gray.800}" }
+      },
+      text: {
+        primary: { $value: "{color.gray.50}" }
+      }
+    }
+  };
+}
+var import_citty, p, import_picocolors, import_promises, import_node_path, import_meta, init_default;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    import_citty = require("citty");
+    p = __toESM(require("@clack/prompts"), 1);
+    import_picocolors = __toESM(require("picocolors"), 1);
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    import_meta = {};
+    init_default = (0, import_citty.defineCommand)({
+      meta: {
+        name: "init",
+        description: "Initialize a new RynDesign project"
+      },
+      args: {
+        template: {
+          type: "string",
+          description: "Template to use (minimal or full)",
+          default: "minimal"
+        },
+        platforms: {
+          type: "string",
+          description: "Comma-separated list of target platforms"
+        }
+      },
+      async run({ args }) {
+        p.intro(import_picocolors.default.bgCyan(import_picocolors.default.black(" RynDesign Init ")));
+        const template = args.template || await p.select({
+          message: "Choose a template:",
+          options: [
+            { value: "minimal", label: "Minimal", hint: "Basic color, spacing, typography tokens" },
+            { value: "full", label: "Full", hint: "Complete token set with shadows, borders, gradients" }
+          ]
+        });
+        if (p.isCancel(template)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const platformsInput = args.platforms || await p.multiselect({
+          message: "Select target platforms:",
+          initialValues: ["react", "swiftui"],
+          options: [
+            { value: "react", label: "React", hint: "recommended" },
+            { value: "swiftui", label: "SwiftUI", hint: "recommended" },
+            { value: "vue", label: "Vue" },
+            { value: "svelte", label: "Svelte" },
+            { value: "rails", label: "Rails" },
+            { value: "uikit", label: "UIKit" },
+            { value: "compose", label: "Jetpack Compose" },
+            { value: "android-view", label: "Android View" }
+          ],
+          required: true
+        });
+        if (p.isCancel(platformsInput)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const platforms = Array.isArray(platformsInput) ? platformsInput : platformsInput.split(",").map((s2) => s2.trim());
+        const darkMode = await p.confirm({
+          message: "Enable dark mode support?",
+          initialValue: true
+        });
+        if (p.isCancel(darkMode)) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const s = p.spinner();
+        s.start("Creating project files...");
+        const cwd = process.cwd();
+        await import_promises.default.mkdir(import_node_path.default.join(cwd, "tokens"), { recursive: true });
+        await import_promises.default.mkdir(import_node_path.default.join(cwd, "components"), { recursive: true });
+        await import_promises.default.mkdir(import_node_path.default.join(cwd, "generated"), { recursive: true });
+        const templateDir = import_node_path.default.resolve(
+          typeof __dirname !== "undefined" ? import_node_path.default.resolve(__dirname, "../../templates") : import_node_path.default.resolve(new URL(".", import_meta.url).pathname, "../../templates")
+        );
+        const templateFile = template === "full" ? "full.tokens.json" : "minimal.tokens.json";
+        try {
+          const templateContent = await import_promises.default.readFile(
+            import_node_path.default.join(templateDir, templateFile),
+            "utf-8"
+          );
+          await import_promises.default.writeFile(
+            import_node_path.default.join(cwd, "tokens", "base.tokens.json"),
+            templateContent
+          );
+        } catch {
+          await import_promises.default.writeFile(
+            import_node_path.default.join(cwd, "tokens", "base.tokens.json"),
+            JSON.stringify(getDefaultTokens(), null, 2)
+          );
+        }
+        await import_promises.default.writeFile(
+          import_node_path.default.join(cwd, "tokens", "semantic.tokens.json"),
+          JSON.stringify(getSemanticTokens(), null, 2)
+        );
+        if (darkMode) {
+          try {
+            const darkContent = await import_promises.default.readFile(
+              import_node_path.default.join(templateDir, "dark.tokens.json"),
+              "utf-8"
+            );
+            await import_promises.default.writeFile(
+              import_node_path.default.join(cwd, "tokens", "dark.tokens.json"),
+              darkContent
+            );
+          } catch {
+            await import_promises.default.writeFile(
+              import_node_path.default.join(cwd, "tokens", "dark.tokens.json"),
+              JSON.stringify(getDarkTokens(), null, 2)
+            );
+          }
+        }
+        const configContent = generateConfig(platforms, darkMode);
+        await import_promises.default.writeFile(import_node_path.default.join(cwd, "ryndesign.config.ts"), configContent);
+        try {
+          const buttonComp = await import_promises.default.readFile(
+            import_node_path.default.join(templateDir, "../components/button.component.json"),
+            "utf-8"
+          );
+          await import_promises.default.writeFile(
+            import_node_path.default.join(cwd, "components", "button.component.json"),
+            buttonComp
+          );
+        } catch {
+        }
+        const gitignorePath = import_node_path.default.join(cwd, ".gitignore");
+        try {
+          let gitignore = "";
+          try {
+            gitignore = await import_promises.default.readFile(gitignorePath, "utf-8");
+          } catch {
+          }
+          if (!gitignore.includes("generated/")) {
+            gitignore += (gitignore.endsWith("\n") || gitignore === "" ? "" : "\n") + "generated/\n";
+            await import_promises.default.writeFile(gitignorePath, gitignore);
+          }
+        } catch {
+        }
+        try {
+          const pkgJsonPath = import_node_path.default.join(cwd, "package.json");
+          const pkgContent = await import_promises.default.readFile(pkgJsonPath, "utf-8");
+          const pkg = JSON.parse(pkgContent);
+          if (!pkg.scripts) pkg.scripts = {};
+          if (!pkg.scripts["generate"]) pkg.scripts["generate"] = "ryndesign generate";
+          if (!pkg.scripts["preview"]) pkg.scripts["preview"] = "ryndesign preview";
+          await import_promises.default.writeFile(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+        } catch {
+        }
+        s.stop("Project files created!");
+        p.note(
+          [
+            `${import_picocolors.default.green("tokens/")}       - Your design tokens`,
+            `${import_picocolors.default.green("components/")}    - Component definitions`,
+            `${import_picocolors.default.green("generated/")}     - Generated output (gitignored)`,
+            `${import_picocolors.default.green("ryndesign.config.ts")} - Configuration`
+          ].join("\n"),
+          "Project structure"
+        );
+        p.outro(import_picocolors.default.green("Run `ryndesign generate` to generate your design system!"));
+      }
+    });
+  }
+});
+
+// src/config.ts
+async function loadConfig(configPath) {
+  const cwd = process.cwd();
+  if (configPath) {
+    return loadConfigFile(import_node_path2.default.resolve(cwd, configPath));
+  }
+  for (const name of CONFIG_NAMES) {
+    const absolutePath = import_node_path2.default.resolve(cwd, name);
+    try {
+      await import_promises2.default.access(absolutePath);
+      return loadConfigFile(absolutePath);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function loadConfigFile(absolutePath) {
+  try {
+    await import_promises2.default.access(absolutePath);
+  } catch {
+    return null;
+  }
+  if (absolutePath.endsWith(".json")) {
+    try {
+      const content = await import_promises2.default.readFile(absolutePath, "utf-8");
+      const config = JSON.parse(content);
+      return validateConfig(config, absolutePath);
+    } catch (err) {
+      throw new Error(`Failed to parse config ${absolutePath}: ${err.message}`);
+    }
+  }
+  try {
+    const { createJiti } = await import("jiti");
+    const loader = createJiti(absolutePath, {
+      interopDefault: true
+    });
+    const config = await loader.import(absolutePath);
+    const resolved = config.default ?? config;
+    return validateConfig(resolved, absolutePath);
+  } catch (err) {
+    try {
+      const mod = await import(absolutePath);
+      const resolved = mod.default ?? mod;
+      return validateConfig(resolved, absolutePath);
+    } catch {
+      throw new Error(`Failed to load config ${absolutePath}: ${err.message}`);
+    }
+  }
+}
+function validateConfig(config, filePath) {
+  if (!config.tokens || !Array.isArray(config.tokens) || config.tokens.length === 0) {
+    throw new Error(`Invalid config in ${filePath}: "tokens" must be a non-empty array of glob patterns`);
+  }
+  if (config.components && !Array.isArray(config.components)) {
+    throw new Error(`Invalid config in ${filePath}: "components" must be an array of glob patterns`);
+  }
+  if (config.generators && !Array.isArray(config.generators)) {
+    throw new Error(`Invalid config in ${filePath}: "generators" must be an array`);
+  }
+  return config;
+}
+var import_node_path2, import_promises2, import_plugin_api, CONFIG_NAMES;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_node_path2 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_plugin_api = require("@ryndesign/plugin-api");
+    CONFIG_NAMES = [
+      "ryndesign.config.ts",
+      "ryndesign.config.js",
+      "ryndesign.config.mjs",
+      "ryndesign.config.json"
+    ];
+  }
+});
+
+// src/commands/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  default: () => generate_default
+});
+var import_citty2, import_picocolors2, import_node_path3, import_promises3, import_core, generate_default;
+var init_generate = __esm({
+  "src/commands/generate.ts"() {
+    "use strict";
+    import_citty2 = require("citty");
+    import_picocolors2 = __toESM(require("picocolors"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_core = require("@ryndesign/core");
+    init_config();
+    generate_default = (0, import_citty2.defineCommand)({
+      meta: {
+        name: "generate",
+        description: "Generate design system files for target platforms"
+      },
+      args: {
+        platforms: {
+          type: "string",
+          description: "Comma-separated list of platforms to generate"
+        },
+        watch: {
+          type: "boolean",
+          description: "Watch for changes and regenerate",
+          default: false
+        },
+        clean: {
+          type: "boolean",
+          description: "Clean output directory before generating",
+          default: false
+        },
+        "dry-run": {
+          type: "boolean",
+          description: "Show what would be generated without writing files",
+          default: false
+        },
+        config: {
+          type: "string",
+          description: "Path to config file",
+          default: "ryndesign.config.ts"
+        }
+      },
+      async run({ args }) {
+        const dryRun = args["dry-run"];
+        console.log(import_picocolors2.default.cyan(`\u26A1 RynDesign Generate${dryRun ? " (dry run)" : ""}
+`));
+        const config = await loadConfig(args.config);
+        if (!config) {
+          console.error(import_picocolors2.default.red("Config file not found. Run `ryndesign init` first."));
+          process.exit(1);
+        }
+        const cwd = process.cwd();
+        if (args.clean && config.outDir) {
+          const outDir = import_node_path3.default.resolve(cwd, config.outDir);
+          await import_promises3.default.rm(outDir, { recursive: true, force: true });
+          await import_promises3.default.mkdir(outDir, { recursive: true });
+          console.log(import_picocolors2.default.yellow(`Cleaned ${config.outDir}/`));
+        }
+        console.log(import_picocolors2.default.gray("Building token set..."));
+        const tokenSet = await (0, import_core.buildTokenSet)({
+          tokens: config.tokens,
+          basePath: cwd,
+          themes: config.themes,
+          name: "design-system"
+        });
+        console.log(import_picocolors2.default.green(`\u2713 Resolved ${tokenSet.tokens.length} tokens`));
+        if (Object.keys(tokenSet.themes.themes).length > 0) {
+          console.log(import_picocolors2.default.green(`\u2713 Resolved themes: ${Object.keys(tokenSet.themes.themes).join(", ")}`));
+        }
+        let generators = config.generators ?? [];
+        if (args.platforms) {
+          const targetPlatforms = args.platforms.split(",").map((s) => s.trim());
+          generators = generators.filter((g) => targetPlatforms.includes(g.name));
+        }
+        if (generators.length === 0) {
+          console.log(import_picocolors2.default.yellow("No generators configured. Add generators to your ryndesign.config.ts"));
+          return;
+        }
+        const components = config.components ? await (0, import_core.loadComponents)(config.components, cwd) : [];
+        if (components.length > 0) {
+          console.log(import_picocolors2.default.green(`\u2713 Loaded ${components.length} component(s)`));
+        }
+        const resolvedComponents = components.map((compDef) => (0, import_core.resolveComponent)(compDef, tokenSet));
+        const allFiles = [];
+        const summary = [];
+        for (const generator of generators) {
+          console.log(import_picocolors2.default.gray(`
+Generating ${generator.displayName}...`));
+          let genFiles = 0;
+          let genBytes = 0;
+          const ctx = {
+            tokenSet,
+            config: { outDir: config.outDir ?? "generated", ...generator },
+            outputDir: import_node_path3.default.resolve(cwd, config.outDir ?? "generated"),
+            helpers: (0, import_core.createGeneratorHelpers)(),
+            components: resolvedComponents
+          };
+          try {
+            const tokenFiles = await generator.generateTokens(ctx);
+            allFiles.push(...tokenFiles);
+            for (const file of tokenFiles) {
+              genFiles++;
+              genBytes += Buffer.byteLength(file.content, "utf-8");
+              if (!dryRun) {
+                const filePath = import_node_path3.default.resolve(ctx.outputDir, file.path);
+                await import_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+                await import_promises3.default.writeFile(filePath, file.content, "utf-8");
+              }
+            }
+            for (const resolvedComp of resolvedComponents) {
+              const compFiles = await generator.generateComponent(resolvedComp, ctx);
+              allFiles.push(...compFiles);
+              for (const file of compFiles) {
+                genFiles++;
+                genBytes += Buffer.byteLength(file.content, "utf-8");
+                if (!dryRun) {
+                  const filePath = import_node_path3.default.resolve(ctx.outputDir, file.path);
+                  await import_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+                  await import_promises3.default.writeFile(filePath, file.content, "utf-8");
+                }
+              }
+            }
+            console.log(import_picocolors2.default.green(`  \u2713 ${genFiles} files generated for ${generator.displayName}`));
+            summary.push({ name: generator.displayName, files: genFiles, bytes: genBytes });
+          } catch (err) {
+            console.error(import_picocolors2.default.red(`  \u2717 ${generator.displayName} failed: ${err.message}`));
+          }
+        }
+        if (summary.length > 0) {
+          console.log(import_picocolors2.default.gray("\n  Platform          Files    Size"));
+          console.log(import_picocolors2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+          for (const s of summary) {
+            const sizeStr = s.bytes < 1024 ? `${s.bytes} B` : `${(s.bytes / 1024).toFixed(1)} KB`;
+            console.log(`  ${s.name.padEnd(18)} ${String(s.files).padStart(5)}    ${sizeStr}`);
+          }
+        }
+        if (config.hooks?.["generate:complete"]) {
+          await config.hooks["generate:complete"](allFiles);
+        }
+        console.log(import_picocolors2.default.green(`
+\u2713 Generation complete! ${allFiles.length} files ${dryRun ? "would be written" : "written"}.`));
+        if (args.watch) {
+          console.log(import_picocolors2.default.cyan("\nWatching for changes..."));
+          const { watch } = await import("chokidar");
+          const watchPatterns = [...config.tokens, ...config.components ?? []];
+          const watcher = watch(watchPatterns, {
+            cwd,
+            ignoreInitial: true
+          });
+          watcher.on("change", async (changedPath) => {
+            console.log(import_picocolors2.default.gray(`
+File changed: ${changedPath}`));
+            try {
+              const newTokenSet = await (0, import_core.buildTokenSet)({
+                tokens: config.tokens,
+                basePath: cwd,
+                themes: config.themes
+              });
+              const newComponents = config.components ? await (0, import_core.loadComponents)(config.components, cwd) : [];
+              const newResolvedComponents = newComponents.map((c) => (0, import_core.resolveComponent)(c, newTokenSet));
+              for (const generator of generators) {
+                try {
+                  const ctx = {
+                    tokenSet: newTokenSet,
+                    config: { outDir: config.outDir ?? "generated", ...generator },
+                    outputDir: import_node_path3.default.resolve(cwd, config.outDir ?? "generated"),
+                    helpers: (0, import_core.createGeneratorHelpers)(),
+                    components: newResolvedComponents
+                  };
+                  const tokenFiles = await generator.generateTokens(ctx);
+                  for (const file of tokenFiles) {
+                    const filePath = import_node_path3.default.resolve(ctx.outputDir, file.path);
+                    await import_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+                    await import_promises3.default.writeFile(filePath, file.content, "utf-8");
+                  }
+                  for (const resolvedComp of newResolvedComponents) {
+                    const compFiles = await generator.generateComponent(resolvedComp, ctx);
+                    for (const file of compFiles) {
+                      const filePath = import_node_path3.default.resolve(ctx.outputDir, file.path);
+                      await import_promises3.default.mkdir(import_node_path3.default.dirname(filePath), { recursive: true });
+                      await import_promises3.default.writeFile(filePath, file.content, "utf-8");
+                    }
+                  }
+                } catch (err) {
+                  console.error(import_picocolors2.default.red(`  \u2717 ${generator.displayName}: ${err.message}`));
+                }
+              }
+              console.log(import_picocolors2.default.green("\u2713 Rebuilt and regenerated"));
+            } catch (err) {
+              console.error(import_picocolors2.default.red(`Error: ${err.message}`));
+            }
+          });
+        }
+      }
+    });
+  }
+});
+
+// src/commands/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  default: () => validate_default
+});
+var import_citty3, import_picocolors3, import_core2, validate_default;
+var init_validate = __esm({
+  "src/commands/validate.ts"() {
+    "use strict";
+    import_citty3 = require("citty");
+    import_picocolors3 = __toESM(require("picocolors"), 1);
+    import_core2 = require("@ryndesign/core");
+    validate_default = (0, import_citty3.defineCommand)({
+      meta: {
+        name: "validate",
+        description: "Validate design token files"
+      },
+      args: {
+        path: {
+          type: "positional",
+          description: "Path to token file(s)",
+          required: false
+        },
+        strict: {
+          type: "boolean",
+          description: "Treat warnings as errors",
+          default: false
+        }
+      },
+      async run({ args }) {
+        console.log(import_picocolors3.default.cyan("  RynDesign Validate\n"));
+        const patterns = args.path ? [args.path] : ["tokens/**/*.tokens.json"];
+        try {
+          const tree = await (0, import_core2.readAndMergeTokenFiles)(patterns);
+          (0, import_core2.validateTree)(tree);
+          const tokenSet = await (0, import_core2.buildTokenSet)({
+            tokens: patterns,
+            basePath: process.cwd()
+          });
+          const issues = (0, import_core2.postValidate)(tokenSet.tokens, tokenSet.themes);
+          const errors = issues.filter((i) => i.severity === "error");
+          const warnings = issues.filter((i) => i.severity === "warning");
+          console.log(import_picocolors3.default.green(`  ${tokenSet.tokens.length} tokens resolved`));
+          console.log(import_picocolors3.default.green(`  ${tokenSet.groups.length} groups`));
+          const themeCount = Object.keys(tokenSet.themes.themes).length;
+          if (themeCount > 0) {
+            console.log(import_picocolors3.default.green(`  ${themeCount} theme(s): ${Object.keys(tokenSet.themes.themes).join(", ")}`));
+          }
+          if (errors.length > 0) {
+            console.error(import_picocolors3.default.red(`
+  ${errors.length} error(s):
+`));
+            for (const issue of errors) {
+              console.error(`  ${import_picocolors3.default.red("x")} ${issue.path}: ${issue.message}`);
+            }
+          }
+          if (warnings.length > 0) {
+            console.log(import_picocolors3.default.yellow(`
+  ${warnings.length} warning(s):
+`));
+            for (const issue of warnings) {
+              console.log(`  ${import_picocolors3.default.yellow("!")} ${issue.path}: ${issue.message}`);
+            }
+          }
+          if (errors.length === 0 && warnings.length === 0) {
+            console.log(import_picocolors3.default.green("\n  All tokens are valid!"));
+          } else if (errors.length === 0) {
+            console.log(import_picocolors3.default.green("\n  Tokens are valid (with warnings)"));
+          }
+          if (args.strict && (errors.length > 0 || warnings.length > 0)) {
+            process.exit(1);
+          }
+          if (errors.length > 0) {
+            process.exit(1);
+          }
+        } catch (err) {
+          if (err instanceof import_core2.TokenValidationError) {
+            console.error(import_picocolors3.default.red(`  Validation failed with ${err.errors.length} issue(s):
+`));
+            for (const issue of err.errors) {
+              const icon = issue.severity === "error" ? import_picocolors3.default.red("x") : import_picocolors3.default.yellow("!");
+              console.error(`  ${icon} ${issue.path.join(".")}: ${issue.message}`);
+            }
+            process.exit(1);
+          }
+          throw err;
+        }
+      }
+    });
+  }
+});
+
+// src/commands/preview.ts
+var preview_exports = {};
+__export(preview_exports, {
+  default: () => preview_default
+});
+var import_citty4, import_picocolors4, preview_default;
+var init_preview = __esm({
+  "src/commands/preview.ts"() {
+    "use strict";
+    import_citty4 = require("citty");
+    import_picocolors4 = __toESM(require("picocolors"), 1);
+    preview_default = (0, import_citty4.defineCommand)({
+      meta: {
+        name: "preview",
+        description: "Start the design system preview server"
+      },
+      args: {
+        port: {
+          type: "string",
+          description: "Port to run the preview server on",
+          default: "4400"
+        },
+        open: {
+          type: "boolean",
+          description: "Open browser automatically",
+          default: true
+        }
+      },
+      async run({ args }) {
+        console.log(import_picocolors4.default.cyan("\u{1F5A5}  RynDesign Preview\n"));
+        try {
+          const { startPreviewServer } = await import("@ryndesign/preview");
+          await startPreviewServer({
+            port: parseInt(args.port, 10),
+            open: args.open
+          });
+        } catch {
+          console.log(import_picocolors4.default.yellow("Preview package not found. Install @ryndesign/preview"));
+          console.log(import_picocolors4.default.gray("  pnpm add @ryndesign/preview"));
+        }
+      }
+    });
+  }
+});
+
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  default: () => add_default
+});
+var import_citty5, p2, import_picocolors5, import_promises4, import_node_path4, import_meta2, AVAILABLE_COMPONENTS, COMPONENT_TOKENS, add_default;
+var init_add = __esm({
+  "src/commands/add.ts"() {
+    "use strict";
+    import_citty5 = require("citty");
+    p2 = __toESM(require("@clack/prompts"), 1);
+    import_picocolors5 = __toESM(require("picocolors"), 1);
+    import_promises4 = __toESM(require("fs/promises"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    import_meta2 = {};
+    AVAILABLE_COMPONENTS = ["button", "input", "card", "checkbox", "toggle", "badge", "avatar"];
+    COMPONENT_TOKENS = {
+      button: {
+        "component.button": {
+          $type: "color",
+          primary: {
+            background: { $value: "{color.primary}" },
+            text: { $value: "{color.white}" },
+            hover: { background: { $value: "{color.primary}" } },
+            pressed: { background: { $value: "{color.primary}" } }
+          },
+          secondary: {
+            background: { $value: "{color.secondary}" },
+            text: { $value: "{color.white}" }
+          },
+          borderRadius: { $type: "dimension", $value: "8px" },
+          sm: { paddingX: { $type: "dimension", $value: "12px" }, paddingY: { $type: "dimension", $value: "6px" }, fontSize: { $type: "dimension", $value: "14px" } },
+          md: { paddingX: { $type: "dimension", $value: "16px" }, paddingY: { $type: "dimension", $value: "10px" }, fontSize: { $type: "dimension", $value: "16px" } },
+          lg: { paddingX: { $type: "dimension", $value: "24px" }, paddingY: { $type: "dimension", $value: "14px" }, fontSize: { $type: "dimension", $value: "18px" } },
+          disabled: { background: { $value: "{color.gray.300}" } }
+        }
+      }
+    };
+    add_default = (0, import_citty5.defineCommand)({
+      meta: {
+        name: "add",
+        description: "Add a component definition"
+      },
+      args: {
+        name: {
+          type: "positional",
+          description: "Component name to add",
+          required: false
+        },
+        "with-tokens": {
+          type: "boolean",
+          description: "Also scaffold component tokens",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const name = args.name || await p2.select({
+          message: "Choose a component to add:",
+          options: AVAILABLE_COMPONENTS.map((c) => ({
+            value: c,
+            label: c.charAt(0).toUpperCase() + c.slice(1)
+          }))
+        });
+        if (p2.isCancel(name)) {
+          p2.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const cwd = process.cwd();
+        const componentsDir = import_node_path4.default.join(cwd, "components");
+        await import_promises4.default.mkdir(componentsDir, { recursive: true });
+        const destPath = import_node_path4.default.join(componentsDir, `${name}.component.json`);
+        try {
+          await import_promises4.default.access(destPath);
+          console.log(import_picocolors5.default.yellow(`Component ${name} already exists at ${destPath}`));
+          return;
+        } catch {
+        }
+        let copied = false;
+        const searchPaths = [
+          import_node_path4.default.resolve(__dirname, `../../components/${name}.component.json`),
+          // ESM fallback
+          typeof __dirname !== "undefined" ? import_node_path4.default.resolve(__dirname, `../../components/${name}.component.json`) : import_node_path4.default.resolve(new URL(".", import_meta2.url).pathname, `../../components/${name}.component.json`)
+        ];
+        for (const srcPath of searchPaths) {
+          try {
+            const content = await import_promises4.default.readFile(srcPath, "utf-8");
+            await import_promises4.default.writeFile(destPath, content);
+            console.log(import_picocolors5.default.green(`  Added ${name} component to ${destPath}`));
+            copied = true;
+            break;
+          } catch {
+            continue;
+          }
+        }
+        if (!copied) {
+          console.error(import_picocolors5.default.red(`Component "${name}" not found in available components.`));
+          console.log(import_picocolors5.default.gray(`Available: ${AVAILABLE_COMPONENTS.join(", ")}`));
+          return;
+        }
+        const withTokens = args["with-tokens"];
+        if (withTokens && COMPONENT_TOKENS[name]) {
+          const tokensDir = import_node_path4.default.join(cwd, "tokens");
+          await import_promises4.default.mkdir(tokensDir, { recursive: true });
+          const tokenFile = import_node_path4.default.join(tokensDir, `${name}.tokens.json`);
+          try {
+            await import_promises4.default.access(tokenFile);
+            console.log(import_picocolors5.default.yellow(`  Token file already exists: ${tokenFile}`));
+          } catch {
+            await import_promises4.default.writeFile(tokenFile, JSON.stringify(COMPONENT_TOKENS[name], null, 2));
+            console.log(import_picocolors5.default.green(`  Created component tokens: ${tokenFile}`));
+          }
+        }
+      }
+    });
+  }
+});
+
+// src/commands/figma-pull.ts
+var figma_pull_exports = {};
+__export(figma_pull_exports, {
+  default: () => figma_pull_default
+});
+async function readJsonSafe(absolutePath) {
+  try {
+    const content = await import_promises5.default.readFile(absolutePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+var import_citty6, import_picocolors6, import_promises5, import_node_path5, figma_pull_default;
+var init_figma_pull = __esm({
+  "src/commands/figma-pull.ts"() {
+    "use strict";
+    import_citty6 = require("citty");
+    import_picocolors6 = __toESM(require("picocolors"), 1);
+    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
+    init_config();
+    figma_pull_default = (0, import_citty6.defineCommand)({
+      meta: {
+        name: "pull",
+        description: "Pull design tokens from Figma"
+      },
+      args: {
+        "file-key": {
+          type: "string",
+          description: "Figma file key"
+        },
+        token: {
+          type: "string",
+          description: "Figma personal access token"
+        },
+        config: {
+          type: "string",
+          description: "Path to config file",
+          default: "ryndesign.config.ts"
+        },
+        merge: {
+          type: "boolean",
+          description: "Merge with existing local tokens instead of overwriting",
+          default: false
+        },
+        strategy: {
+          type: "string",
+          description: "Merge strategy: prefer-remote, prefer-local, remote-only-new",
+          default: "prefer-remote"
+        }
+      },
+      async run({ args }) {
+        console.log(import_picocolors6.default.cyan("\u{1F4E5} Figma Pull\n"));
+        const config = await loadConfig(args.config);
+        const fileKey = args["file-key"] || config?.figma?.fileKey;
+        const pat = args.token || config?.figma?.personalAccessToken || process.env.FIGMA_TOKEN;
+        if (!fileKey) {
+          console.error(import_picocolors6.default.red("Missing Figma file key. Use --file-key or set in config."));
+          process.exit(1);
+        }
+        if (!pat) {
+          console.error(import_picocolors6.default.red("Missing Figma token. Use --token, set FIGMA_TOKEN env var, or configure in ryndesign.config.ts"));
+          process.exit(1);
+        }
+        const shouldMerge = args.merge;
+        const strategy = args.strategy;
+        const validStrategies = ["prefer-remote", "prefer-local", "remote-only-new"];
+        if (shouldMerge && !validStrategies.includes(strategy)) {
+          console.error(import_picocolors6.default.red(`Invalid merge strategy "${strategy}". Use: ${validStrategies.join(", ")}`));
+          process.exit(1);
+        }
+        try {
+          const { fetchFigmaVariables, mapFigmaToTokens, resolveFigmaModes, mergeTokens } = await import("@ryndesign/figma");
+          console.log(import_picocolors6.default.gray("Fetching variables from Figma..."));
+          const variables = await fetchFigmaVariables({
+            fileKey,
+            personalAccessToken: pat
+          });
+          console.log(import_picocolors6.default.green(`\u2713 Fetched ${variables.length} variables`));
+          const cwd = process.cwd();
+          const modeMapping = config?.figma?.modeMapping;
+          if (modeMapping) {
+            const modeFiles = resolveFigmaModes(variables, modeMapping);
+            for (const [filePath, tree] of Object.entries(modeFiles)) {
+              const absolutePath = import_node_path5.default.resolve(cwd, filePath);
+              await import_promises5.default.mkdir(import_node_path5.default.dirname(absolutePath), { recursive: true });
+              if (shouldMerge) {
+                const existing = await readJsonSafe(absolutePath);
+                if (existing) {
+                  const modeTokens = variables.filter((t) => {
+                    const modeName = Object.keys(modeMapping).find((m) => modeMapping[m] === filePath);
+                    return modeName && t.modes[modeName] !== void 0;
+                  });
+                  const result = mergeTokens(existing, modeTokens, { strategy });
+                  await import_promises5.default.writeFile(absolutePath, JSON.stringify(result.merged, null, 2), "utf-8");
+                  console.log(import_picocolors6.default.green(`  \u2713 Merged ${filePath}`) + import_picocolors6.default.gray(` (+${result.stats.added} new, ${result.stats.updated} updated, ${result.stats.kept} kept)`));
+                  continue;
+                }
+              }
+              await import_promises5.default.writeFile(absolutePath, JSON.stringify(tree, null, 2), "utf-8");
+              console.log(import_picocolors6.default.green(`  \u2713 Written ${filePath}`));
+            }
+          } else {
+            const outPath = import_node_path5.default.resolve(cwd, "tokens/figma.tokens.json");
+            await import_promises5.default.mkdir(import_node_path5.default.dirname(outPath), { recursive: true });
+            if (shouldMerge) {
+              const existing = await readJsonSafe(outPath);
+              if (existing) {
+                const result = mergeTokens(existing, variables, { strategy });
+                await import_promises5.default.writeFile(outPath, JSON.stringify(result.merged, null, 2), "utf-8");
+                console.log(import_picocolors6.default.green(`  \u2713 Merged tokens/figma.tokens.json`) + import_picocolors6.default.gray(` (+${result.stats.added} new, ${result.stats.updated} updated, ${result.stats.kept} kept)`));
+              } else {
+                const tree = mapFigmaToTokens(variables);
+                await import_promises5.default.writeFile(outPath, JSON.stringify(tree, null, 2), "utf-8");
+                console.log(import_picocolors6.default.green(`  \u2713 Written tokens/figma.tokens.json`));
+              }
+            } else {
+              const tree = mapFigmaToTokens(variables);
+              await import_promises5.default.writeFile(outPath, JSON.stringify(tree, null, 2), "utf-8");
+              console.log(import_picocolors6.default.green(`  \u2713 Written tokens/figma.tokens.json`));
+            }
+          }
+          console.log(import_picocolors6.default.green("\n\u2713 Figma pull complete!"));
+        } catch (err) {
+          console.error(import_picocolors6.default.red(`Error: ${err.message}`));
+          process.exit(1);
+        }
+      }
+    });
+  }
+});
+
+// src/commands/figma-push.ts
+var figma_push_exports = {};
+__export(figma_push_exports, {
+  default: () => figma_push_default
+});
+var import_citty7, import_picocolors7, import_core3, figma_push_default;
+var init_figma_push = __esm({
+  "src/commands/figma-push.ts"() {
+    "use strict";
+    import_citty7 = require("citty");
+    import_picocolors7 = __toESM(require("picocolors"), 1);
+    import_core3 = require("@ryndesign/core");
+    init_config();
+    figma_push_default = (0, import_citty7.defineCommand)({
+      meta: {
+        name: "push",
+        description: "Push design tokens to Figma"
+      },
+      args: {
+        "file-key": {
+          type: "string",
+          description: "Figma file key"
+        },
+        token: {
+          type: "string",
+          description: "Figma personal access token"
+        },
+        config: {
+          type: "string",
+          description: "Path to config file",
+          default: "ryndesign.config.ts"
+        }
+      },
+      async run({ args }) {
+        console.log(import_picocolors7.default.cyan("\u{1F4E4} Figma Push\n"));
+        const config = await loadConfig(args.config);
+        const fileKey = args["file-key"] || config?.figma?.fileKey;
+        const pat = args.token || config?.figma?.personalAccessToken || process.env.FIGMA_TOKEN;
+        if (!fileKey) {
+          console.error(import_picocolors7.default.red("Missing Figma file key. Use --file-key or set in config."));
+          process.exit(1);
+        }
+        if (!pat) {
+          console.error(import_picocolors7.default.red("Missing Figma token. Use --token, set FIGMA_TOKEN env var, or configure in ryndesign.config.ts"));
+          process.exit(1);
+        }
+        try {
+          const { pushVariablesToFigma } = await import("@ryndesign/figma");
+          const cwd = process.cwd();
+          console.log(import_picocolors7.default.gray("Building token set..."));
+          const tokenSet = await (0, import_core3.buildTokenSet)({
+            tokens: config?.tokens ?? ["tokens/**/*.tokens.json"],
+            basePath: cwd,
+            themes: config?.themes
+          });
+          console.log(import_picocolors7.default.green(`\u2713 Resolved ${tokenSet.tokens.length} tokens`));
+          console.log(import_picocolors7.default.gray("Pushing to Figma..."));
+          const darkTokens = tokenSet.themes.themes["dark"]?.tokens;
+          await pushVariablesToFigma({
+            fileKey,
+            personalAccessToken: pat,
+            tokens: tokenSet.tokens,
+            darkTokens
+          });
+          console.log(import_picocolors7.default.green("\n\u2713 Figma push complete!"));
+        } catch (err) {
+          console.error(import_picocolors7.default.red(`Error: ${err.message}`));
+          process.exit(1);
+        }
+      }
+    });
+  }
+});
+
+// src/commands/figma-diff.ts
+var figma_diff_exports = {};
+__export(figma_diff_exports, {
+  default: () => figma_diff_default
+});
+var import_citty8, import_picocolors8, import_core4, figma_diff_default;
+var init_figma_diff = __esm({
+  "src/commands/figma-diff.ts"() {
+    "use strict";
+    import_citty8 = require("citty");
+    import_picocolors8 = __toESM(require("picocolors"), 1);
+    import_core4 = require("@ryndesign/core");
+    init_config();
+    figma_diff_default = (0, import_citty8.defineCommand)({
+      meta: {
+        name: "diff",
+        description: "Compare local tokens with Figma"
+      },
+      args: {
+        "file-key": {
+          type: "string",
+          description: "Figma file key"
+        },
+        token: {
+          type: "string",
+          description: "Figma personal access token"
+        },
+        config: {
+          type: "string",
+          description: "Path to config file",
+          default: "ryndesign.config.ts"
+        }
+      },
+      async run({ args }) {
+        console.log(import_picocolors8.default.cyan("\u{1F50D} Figma Diff\n"));
+        const config = await loadConfig(args.config);
+        const fileKey = args["file-key"] || config?.figma?.fileKey;
+        const pat = args.token || config?.figma?.personalAccessToken || process.env.FIGMA_TOKEN;
+        if (!fileKey) {
+          console.error(import_picocolors8.default.red("Missing Figma file key. Use --file-key or set in config."));
+          process.exit(1);
+        }
+        if (!pat) {
+          console.error(import_picocolors8.default.red("Missing Figma token. Use --token, set FIGMA_TOKEN env var, or configure in ryndesign.config.ts"));
+          process.exit(1);
+        }
+        try {
+          const { fetchFigmaVariables, diffFigmaTokens } = await import("@ryndesign/figma");
+          const cwd = process.cwd();
+          console.log(import_picocolors8.default.gray("Building local token set..."));
+          const tokenSet = await (0, import_core4.buildTokenSet)({
+            tokens: config?.tokens ?? ["tokens/**/*.tokens.json"],
+            basePath: cwd,
+            themes: config?.themes
+          });
+          console.log(import_picocolors8.default.gray("Fetching Figma variables..."));
+          const remoteTokens = await fetchFigmaVariables({
+            fileKey,
+            personalAccessToken: pat
+          });
+          const result = diffFigmaTokens(tokenSet.tokens, remoteTokens);
+          if (result.added.length > 0) {
+            console.log(import_picocolors8.default.green(`
++ Added (local only): ${result.added.length}`));
+            for (const entry of result.added) {
+              console.log(import_picocolors8.default.green(`  + ${entry.path}: ${JSON.stringify(entry.local)}`));
+            }
+          }
+          if (result.removed.length > 0) {
+            console.log(import_picocolors8.default.red(`
+- Removed (Figma only): ${result.removed.length}`));
+            for (const entry of result.removed) {
+              console.log(import_picocolors8.default.red(`  - ${entry.path}: ${JSON.stringify(entry.remote)}`));
+            }
+          }
+          if (result.modified.length > 0) {
+            console.log(import_picocolors8.default.yellow(`
+~ Modified: ${result.modified.length}`));
+            for (const entry of result.modified) {
+              console.log(import_picocolors8.default.yellow(`  ~ ${entry.path}: ${JSON.stringify(entry.local)} \u2190 ${JSON.stringify(entry.remote)}`));
+            }
+          }
+          console.log(import_picocolors8.default.gray(`
+  Unchanged: ${result.unchanged}`));
+          const total = result.added.length + result.removed.length + result.modified.length;
+          if (total === 0) {
+            console.log(import_picocolors8.default.green("\n\u2713 Local and Figma tokens are in sync!"));
+          } else {
+            console.log(import_picocolors8.default.yellow(`
+${total} difference(s) found.`));
+          }
+        } catch (err) {
+          console.error(import_picocolors8.default.red(`Error: ${err.message}`));
+          process.exit(1);
+        }
+      }
+    });
+  }
+});
+
+// src/commands/figma.ts
+var figma_exports = {};
+__export(figma_exports, {
+  default: () => figma_default
+});
+var import_citty9, import_picocolors9, import_node_path6, import_promises6, figma_default;
+var init_figma = __esm({
+  "src/commands/figma.ts"() {
+    "use strict";
+    import_citty9 = require("citty");
+    import_picocolors9 = require("picocolors");
+    import_node_path6 = require("path");
+    import_promises6 = require("fs/promises");
+    init_config();
+    figma_default = (0, import_citty9.defineCommand)({
+      meta: {
+        name: "figma",
+        description: "Figma integration commands"
+      },
+      subCommands: {
+        pull: () => Promise.resolve().then(() => (init_figma_pull(), figma_pull_exports)).then((m) => m.default),
+        push: () => Promise.resolve().then(() => (init_figma_push(), figma_push_exports)).then((m) => m.default),
+        diff: () => Promise.resolve().then(() => (init_figma_diff(), figma_diff_exports)).then((m) => m.default)
+      }
+    });
+  }
+});
+
+// src/commands/eject.ts
+var eject_exports = {};
+__export(eject_exports, {
+  default: () => eject_default
+});
+async function copyDir(src, dest) {
+  await import_promises7.default.mkdir(dest, { recursive: true });
+  const entries = await import_promises7.default.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_node_path7.default.join(src, entry.name);
+    const destPath = import_node_path7.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await import_promises7.default.copyFile(srcPath, destPath);
+    }
+  }
+}
+async function createSkeletonGenerator(dir, name) {
+  const pascalName = name.charAt(0).toUpperCase() + name.slice(1).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const indexContent = `import type { GeneratorPlugin, GeneratorContext, GeneratedFile, ResolvedComponent } from '@ryndesign/plugin-api';
+
+export default function ${name.replace(/-/g, "")}Generator(options = {}): GeneratorPlugin {
+  return {
+    name: '${name}',
+    displayName: '${pascalName}',
+    platform: 'web',
+    outputExtensions: ['.ts', '.css'],
+
+    async generateTokens(ctx: GeneratorContext): Promise<GeneratedFile[]> {
+      // TODO: Implement token generation
+      return [];
+    },
+
+    async generateComponent(comp: ResolvedComponent, ctx: GeneratorContext): Promise<GeneratedFile[]> {
+      // TODO: Implement component generation
+      return [];
+    },
+  };
+}
+`;
+  await import_promises7.default.writeFile(import_node_path7.default.join(dir, "index.ts"), indexContent, "utf-8");
+}
+var import_citty10, p3, import_picocolors10, import_promises7, import_node_path7, GENERATORS, eject_default;
+var init_eject = __esm({
+  "src/commands/eject.ts"() {
+    "use strict";
+    import_citty10 = require("citty");
+    p3 = __toESM(require("@clack/prompts"), 1);
+    import_picocolors10 = __toESM(require("picocolors"), 1);
+    import_promises7 = __toESM(require("fs/promises"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
+    GENERATORS = ["react", "vue", "svelte", "rails", "swiftui", "uikit", "compose", "android-view"];
+    eject_default = (0, import_citty10.defineCommand)({
+      meta: {
+        name: "eject",
+        description: "Eject a generator for customization"
+      },
+      args: {
+        name: {
+          type: "positional",
+          description: "Generator name to eject",
+          required: false
+        }
+      },
+      async run({ args }) {
+        p3.intro(import_picocolors10.default.bgYellow(import_picocolors10.default.black(" RynDesign Eject ")));
+        const name = args.name || await p3.select({
+          message: "Select a generator to eject:",
+          options: GENERATORS.map((g) => ({ value: g, label: `@ryndesign/generator-${g}` }))
+        });
+        if (p3.isCancel(name)) {
+          p3.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        if (!GENERATORS.includes(name)) {
+          console.error(import_picocolors10.default.red(`Unknown generator: ${name}`));
+          console.log(import_picocolors10.default.gray(`Available: ${GENERATORS.join(", ")}`));
+          process.exit(1);
+        }
+        const cwd = process.cwd();
+        const destDir = import_node_path7.default.join(cwd, "generators", name);
+        try {
+          await import_promises7.default.access(destDir);
+          console.error(import_picocolors10.default.yellow(`Generator "${name}" already ejected at generators/${name}/`));
+          process.exit(0);
+        } catch {
+        }
+        const confirm3 = await p3.confirm({
+          message: `Eject @ryndesign/generator-${name} to generators/${name}/?`,
+          initialValue: true
+        });
+        if (p3.isCancel(confirm3) || !confirm3) {
+          p3.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const s = p3.spinner();
+        s.start(`Ejecting generator-${name}...`);
+        try {
+          const pkgPath = require.resolve(`@ryndesign/generator-${name}/package.json`, {
+            paths: [cwd]
+          });
+          const pkgDir = import_node_path7.default.dirname(pkgPath);
+          const srcDir = import_node_path7.default.join(pkgDir, "src");
+          let sourceDir;
+          try {
+            await import_promises7.default.access(srcDir);
+            sourceDir = srcDir;
+          } catch {
+            sourceDir = import_node_path7.default.join(pkgDir, "dist");
+          }
+          await import_promises7.default.mkdir(destDir, { recursive: true });
+          await copyDir(sourceDir, destDir);
+          s.stop(`Generator ejected!`);
+          p3.note(
+            [
+              `Files copied to: ${import_picocolors10.default.green(`generators/${name}/`)}`,
+              "",
+              "Update your ryndesign.config.ts:",
+              import_picocolors10.default.gray(`  import customGenerator from './generators/${name}/index.js';`),
+              "",
+              "Replace the original generator with your custom one."
+            ].join("\n"),
+            "Next steps"
+          );
+        } catch (err) {
+          s.stop("Eject failed");
+          console.error(import_picocolors10.default.red(`Error: ${err.message}`));
+          s.start("Creating skeleton generator...");
+          await createSkeletonGenerator(destDir, name);
+          s.stop("Skeleton generator created!");
+          p3.note(
+            [
+              `Skeleton created at: ${import_picocolors10.default.green(`generators/${name}/`)}`,
+              "",
+              "Customize the generator files and update your config."
+            ].join("\n"),
+            "Next steps"
+          );
+        }
+        p3.outro(import_picocolors10.default.green("Done!"));
+      }
+    });
+  }
+});
+
+// src/bin.ts
+var import_citty12 = require("citty");
+
+// src/commands/main.ts
+var import_citty11 = require("citty");
+var main = (0, import_citty11.defineCommand)({
+  meta: {
+    name: "ryndesign",
+    version: "0.1.0",
+    description: "Multi-platform design system generator"
+  },
+  subCommands: {
+    init: () => Promise.resolve().then(() => (init_init(), init_exports)).then((m) => m.default),
+    generate: () => Promise.resolve().then(() => (init_generate(), generate_exports)).then((m) => m.default),
+    validate: () => Promise.resolve().then(() => (init_validate(), validate_exports)).then((m) => m.default),
+    preview: () => Promise.resolve().then(() => (init_preview(), preview_exports)).then((m) => m.default),
+    add: () => Promise.resolve().then(() => (init_add(), add_exports)).then((m) => m.default),
+    figma: () => Promise.resolve().then(() => (init_figma(), figma_exports)).then((m) => m.default),
+    eject: () => Promise.resolve().then(() => (init_eject(), eject_exports)).then((m) => m.default)
+  }
+});
+
+// src/bin.ts
+(0, import_citty12.runMain)(main);
+//# sourceMappingURL=bin.cjs.map