stera-ui 0.5.0 → 0.6.1

package/dist/cli.js

@@ -1,1353 +1,33 @@
 #!/usr/bin/env node
-
-// src/cli.ts
-import { Command } from "commander";
-
-// src/commands/add.ts
-import path6 from "path";
-
-// src/utils/resolve-config.ts
-import fs from "fs";
-import path from "path";
-var CONFIG_FILE = "stera.config.json";
-var LEGACY_CONFIG_FILE = "components.json";
-function migrateConfig(raw) {
-  if (!("version" in raw) && "tailwind" in raw) {
-    const legacy = raw;
-    return {
-      version: 1,
-      css: legacy.tailwind.css || "src/styles/globals.css",
-      aliases: legacy.aliases
-    };
-  }
-  return raw;
-}
-var warnedLegacyFilename = false;
-function warnLegacyFilenameOnce(legacyPath) {
-  if (warnedLegacyFilename) return;
-  warnedLegacyFilename = true;
-  console.warn(
-    `  \u26A0 Found ${LEGACY_CONFIG_FILE}. Rename to ${CONFIG_FILE} \u2014 legacy filename support will be removed in a future release.
-    (${legacyPath})`
-  );
-}
-function findConfigPath(cwd) {
-  let dir = path.resolve(cwd);
-  while (true) {
-    const configPath = path.join(dir, CONFIG_FILE);
-    if (fs.existsSync(configPath)) return configPath;
-    const legacyPath = path.join(dir, LEGACY_CONFIG_FILE);
-    if (fs.existsSync(legacyPath)) return legacyPath;
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function loadConfig(cwd) {
-  const configPath = findConfigPath(cwd);
-  if (!configPath) return null;
-  if (path.basename(configPath) === LEGACY_CONFIG_FILE) {
-    warnLegacyFilenameOnce(configPath);
-  }
-  try {
-    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    return migrateConfig(raw);
-  } catch {
-    return null;
-  }
-}
-
-// src/registry/index.ts
-var REGISTRY_URL = process.env.REGISTRY_URL ?? "https://ui.stera.sh/r";
-var _indexCache = null;
-async function fetchJSON(url) {
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
-  }
-  return res.json();
-}
-async function fetchRegistryIndex() {
-  if (_indexCache) return _indexCache;
-  const data = await fetchJSON(
-    `${REGISTRY_URL}/index.json`
-  );
-  _indexCache = data.items;
-  return _indexCache;
-}
-async function fetchRegistryItem(name) {
-  return fetchJSON(`${REGISTRY_URL}/${name}.json`);
-}
-async function getComponent(name) {
-  const index = await fetchRegistryIndex();
-  return index.find((item) => item.name === name);
-}
-async function getAllComponents() {
-  return fetchRegistryIndex();
-}
-async function resolveDependencies(names) {
-  const resolved = /* @__PURE__ */ new Map();
-  const queue = [...names];
-  while (queue.length > 0) {
-    const name = queue.shift();
-    if (resolved.has(name)) continue;
-    let item;
-    try {
-      item = await fetchRegistryItem(name);
-    } catch {
-      console.error(`Component "${name}" not found in registry.`);
-      process.exit(1);
-    }
-    resolved.set(name, item);
-    if (item.registryDependencies) {
-      for (const dep of item.registryDependencies) {
-        if (!resolved.has(dep)) {
-          queue.push(dep);
-        }
-      }
-    }
-  }
-  return Array.from(resolved.values());
-}
-
-// src/utils/write-files.ts
-import fs2 from "fs";
-import path3 from "path";
-import readline from "readline/promises";
-
-// src/utils/resolve-paths.ts
-import path2 from "path";
-import { loadConfig as loadConfig2, createMatchPath } from "tsconfig-paths";
-var TYPE_TO_ALIAS = {
-  "registry:ui": "ui",
-  "registry:lib": "lib",
-  "registry:hook": "hooks",
-  "registry:component": "components"
-};
-function resolveAlias(alias, projectRoot) {
-  const tsConfig = loadConfig2(projectRoot);
-  if (tsConfig.resultType === "success" && Object.keys(tsConfig.paths).length > 0) {
-    const hasMatchingPrefix = Object.keys(tsConfig.paths).some((key) => {
-      const prefix = key.replace(/\/\*$/, "");
-      return alias === prefix || alias.startsWith(`${prefix}/`);
-    });
-    if (hasMatchingPrefix) {
-      const match = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths);
-      const resolved = match(alias, void 0, () => true, [".ts", ".tsx"]);
-      if (resolved) {
-        return path2.relative(projectRoot, resolved);
-      }
-    }
-  }
-  throw new Error(
-    `Could not resolve alias "${alias}" from tsconfig.json. Ensure compilerOptions.paths defines a mapping for it (e.g. "${alias}/*"), then re-run. See https://ui.stera.sh/docs/installation.`
-  );
-}
-function resolveOutputPath(config, projectRoot, file) {
-  const alias = TYPE_TO_ALIAS[file.type];
-  if (alias) {
-    const dir = resolveAlias(config.aliases[alias], projectRoot);
-    const filename = path2.basename(file.path);
-    return path2.join(projectRoot, dir, filename);
-  }
-  if (file.type === "registry:style") {
-    const cssDir = path2.dirname(config.css);
-    const filename = path2.basename(file.path);
-    return path2.join(projectRoot, cssDir, filename);
-  }
-  return path2.join(projectRoot, file.path);
-}
-
-// src/utils/write-files.ts
-async function confirmOverwrite(relativePath) {
-  if (!process.stdin.isTTY) {
-    console.log(`  Skipping ${relativePath} (already exists, use --overwrite to replace)`);
-    return false;
-  }
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const answer = await rl.question(`  ${relativePath} already exists. Overwrite? (y/N) `);
-  rl.close();
-  return answer.toLowerCase() === "y";
-}
-async function writeComponentFiles(items, config, projectRoot, options = {}) {
-  const written = [];
-  const skipped = [];
-  for (const item of items) {
-    for (const file of item.files ?? []) {
-      const outputPath = resolveOutputPath(config, projectRoot, file);
-      const relativePath = path3.relative(projectRoot, outputPath);
-      if (fs2.existsSync(outputPath)) {
-        const existing = fs2.readFileSync(outputPath, "utf-8");
-        if (existing === file.content) {
-          skipped.push(relativePath);
-          continue;
-        }
-        if (!options.overwrite) {
-          const confirmed = await confirmOverwrite(relativePath);
-          if (!confirmed) {
-            skipped.push(relativePath);
-            continue;
-          }
-        }
-      }
-      const dir = path3.dirname(outputPath);
-      fs2.mkdirSync(dir, { recursive: true });
-      fs2.writeFileSync(outputPath, file.content ?? "", "utf-8");
-      written.push(relativePath);
-    }
-  }
-  return { written, skipped };
-}
-
-// src/utils/install-deps.ts
-import fs3 from "fs";
-import path4 from "path";
-import { detect } from "@antfu/ni";
-import { execa } from "execa";
-
-// src/utils/format.ts
-var BRAND = "\x1B[38;2;166;244;48m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
-var enabled = process.stdout.isTTY && !process.env.NO_COLOR;
-var wrap = (code, text) => enabled ? `${code}${text}${RESET}` : text;
-var brand = (text) => wrap(BRAND, text);
-var dim = (text) => wrap(DIM, text);
-var LOGO = brand("\u273B");
-var CHECK = brand("\u2713");
-var CROSS = "\u2717";
-
-// src/utils/spinner.ts
-var FRAMES = ["\u2022", "\u2726", "\u2736", "\u273B"].map(brand);
-var INTERVAL_MS = 150;
-function createSpinner(text) {
-  const isTTY = process.stdout.isTTY;
-  if (!isTTY) {
-    process.stdout.write(`  ${text}...
-`);
-    return {
-      succeed(msg) {
-        process.stdout.write(`  ${CHECK}  ${msg}
-`);
-      },
-      fail(msg) {
-        process.stdout.write(`  ${CROSS}  ${msg}
-`);
-      }
-    };
-  }
-  let frameIndex = 0;
-  const interval = setInterval(() => {
-    process.stdout.write(`\r  ${FRAMES[frameIndex % FRAMES.length]}  ${text}`);
-    frameIndex++;
-  }, INTERVAL_MS);
-  const clear = () => {
-    clearInterval(interval);
-    process.stdout.write("\r" + " ".repeat(text.length + 6) + "\r");
-  };
-  return {
-    succeed(msg) {
-      clear();
-      process.stdout.write(`  ${CHECK}  ${msg}
-`);
-    },
-    fail(msg) {
-      clear();
-      process.stdout.write(`  ${CROSS}  ${msg}
-`);
-    }
-  };
-}
-
-// src/utils/install-deps.ts
-async function detectPackageManager(cwd) {
-  const detected = await detect({ programmatic: true, cwd });
-  if (detected === "pnpm@6" || detected === "pnpm") return "pnpm";
-  if (detected === "yarn@berry" || detected === "yarn") return "yarn";
-  if (detected === "bun") return "bun";
-  if (detected === "npm") return "npm";
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (userAgent.startsWith("pnpm")) return "pnpm";
-  if (userAgent.startsWith("yarn")) return "yarn";
-  if (userAgent.startsWith("bun")) return "bun";
-  return "npm";
-}
-function getInstallArgs(pm, deps) {
-  switch (pm) {
-    case "pnpm":
-      return ["pnpm", ["add", ...deps]];
-    case "yarn":
-      return ["yarn", ["add", ...deps]];
-    case "bun":
-      return ["bun", ["add", ...deps]];
-    default:
-      return ["npm", ["install", ...deps]];
-  }
-}
-async function installDependencies(deps, cwd) {
-  if (deps.length === 0) return;
-  const pkgPath = path4.join(cwd, "package.json");
-  let existing = /* @__PURE__ */ new Set();
-  if (fs3.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-      existing = new Set(Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }));
-    } catch {
-    }
-  }
-  const toInstall = deps.filter((dep) => !existing.has(dep));
-  if (toInstall.length === 0) return;
-  const pm = await detectPackageManager(cwd);
-  const [cmd, args] = getInstallArgs(pm, toInstall);
-  const spinner = createSpinner(`Installing with ${pm}`);
-  try {
-    await execa(cmd, args, { cwd });
-    spinner.succeed(`Installed with ${pm}`);
-  } catch (error) {
-    spinner.fail(`Install failed`);
-    if (error instanceof Error && "stdout" in error && typeof error.stdout === "string" && error.stdout.includes("ERR_PNPM_ADDING_TO_ROOT")) {
-      throw new Error(
-        `Cannot install dependencies at a pnpm workspace root.
-Run stera-ui init from within a specific workspace package instead,
-or use "pnpm add -w <package>" manually to install at the root.`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/utils/transform.ts
-function applyTransforms(content, ctx, transforms2) {
-  return transforms2.reduce((acc, fn) => fn(acc, ctx), content);
-}
-
-// src/utils/transform-imports.ts
-var DEFAULT_ALIASES = {
-  utils: "@/lib/utils",
-  ui: "@/components/ui",
-  components: "@/components",
-  lib: "@/lib",
-  hooks: "@/hooks"
-};
-var transformImports = (content, ctx) => {
-  if (!ctx.filename.endsWith(".ts") && !ctx.filename.endsWith(".tsx")) {
-    return content;
-  }
-  const { aliases } = ctx.config;
-  const rules = [];
-  if (aliases.utils !== DEFAULT_ALIASES.utils) {
-    rules.push({ type: "exact", from: DEFAULT_ALIASES.utils, to: aliases.utils });
-  }
-  if (aliases.ui !== DEFAULT_ALIASES.ui) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.ui, to: aliases.ui });
-  }
-  if (aliases.components !== DEFAULT_ALIASES.components) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.components, to: aliases.components });
-  }
-  if (aliases.lib !== DEFAULT_ALIASES.lib) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.lib, to: aliases.lib });
-  }
-  if (aliases.hooks !== DEFAULT_ALIASES.hooks) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.hooks, to: aliases.hooks });
-  }
-  if (rules.length === 0) {
-    return content;
-  }
-  return content.replace(
-    /from\s+(["'])([^"']+)\1/g,
-    (match, quote, importPath) => {
-      for (const rule of rules) {
-        if (rule.type === "exact" && importPath === rule.from) {
-          return `from ${quote}${rule.to}${quote}`;
-        }
-        if (rule.type === "prefix" && importPath.startsWith(rule.from + "/")) {
-          const rest = importPath.slice(rule.from.length);
-          return `from ${quote}${rule.to}${rest}${quote}`;
-        }
-        if (rule.type === "prefix" && importPath === rule.from) {
-          return `from ${quote}${rule.to}${quote}`;
-        }
-      }
-      return match;
-    }
-  );
-};
-
-// src/utils/write-stera-css.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-function stripImportLines(content) {
-  const lines = content.split("\n");
-  const imports = [];
-  const kept = [];
-  for (const line of lines) {
-    if (line.trim().match(/^@import\s+["'].+["']/)) {
-      if (!line.trim().match(/^@import\s+["']tailwindcss["']/)) {
-        imports.push(line.trim());
-      }
-    } else {
-      kept.push(line);
-    }
-  }
-  return { content: kept.join("\n"), imports };
-}
-async function writeSteraUiCss(config, cwd) {
-  const item = await fetchRegistryItem("globals");
-  const rawContent = item.files?.[0]?.content ?? "";
-  const { content, imports } = stripImportLines(rawContent);
-  const cssDir = path5.dirname(path5.resolve(cwd, config.css));
-  const steraUiPath = path5.join(cssDir, "stera-ui.css");
-  await fs4.mkdir(cssDir, { recursive: true });
-  await fs4.writeFile(steraUiPath, content, "utf-8");
-  return {
-    steraUiPath,
-    extraImports: imports,
-    dependencies: item.dependencies ?? []
-  };
-}
-
-// src/commands/add.ts
-var transforms = [transformImports];
-async function add(components, options) {
-  const cwd = options.cwd ? path6.resolve(options.cwd) : process.cwd();
-  const configPath = findConfigPath(cwd);
-  if (!configPath) {
-    console.error(`  ${CROSS}  ${CONFIG_FILE} not found. Run "stera-ui init" first.`);
-    process.exit(1);
-  }
-  const config = loadConfig(cwd);
-  if (!config) {
-    console.error(`  ${CROSS}  Failed to parse ${CONFIG_FILE}.`);
-    process.exit(1);
-  }
-  const projectRoot = path6.dirname(configPath);
-  if (components.includes("globals")) {
-    if (components.length > 1) {
-      console.error(
-        `  ${CROSS}  "stera-ui add globals" refreshes design tokens and cannot be combined with other components.`
-      );
-      console.error(
-        `     Run "stera-ui add globals" and "stera-ui add ${components.filter((c) => c !== "globals").join(" ")}" separately.`
-      );
-      process.exit(1);
-    }
-    const spinner2 = createSpinner("Refreshing base styles");
-    let result;
-    try {
-      result = await writeSteraUiCss(config, projectRoot);
-    } catch (err) {
-      spinner2.fail("Failed to refresh base styles");
-      throw err;
-    }
-    spinner2.succeed(
-      `Refreshed ${path6.relative(projectRoot, result.steraUiPath)}`
-    );
-    console.log("");
-    return;
-  }
-  const spinner = createSpinner("Fetching registry");
-  try {
-    for (const name of components) {
-      const item = await getComponent(name);
-      if (!item) {
-        spinner.fail(`Component "${name}" not found in registry.`);
-        console.error(`  Run "stera-ui list" to see available components.`);
-        process.exit(1);
-      }
-    }
-  } catch (err) {
-    spinner.fail("Failed to fetch registry");
-    throw err;
-  }
-  let resolved;
-  try {
-    resolved = await resolveDependencies(components);
-  } catch (err) {
-    spinner.fail("Failed to fetch registry");
-    throw err;
-  }
-  spinner.succeed("Registry resolved");
-  for (const item of resolved) {
-    for (const file of item.files ?? []) {
-      if (file.content) {
-        file.content = applyTransforms(
-          file.content,
-          { config, filename: file.path },
-          transforms
-        );
-      }
-    }
-  }
-  const requested = new Set(components);
-  console.log("\n  Installing components\n");
-  for (const item of resolved) {
-    const tag = requested.has(item.name) ? "" : dim("  (dependency)");
-    console.log(`  \u2192 ${item.name}${tag}`);
-  }
-  const allNpmDeps = [];
-  for (const item of resolved) {
-    if (item.dependencies) {
-      allNpmDeps.push(...item.dependencies);
-    }
-  }
-  const uniqueNpmDeps = [...new Set(allNpmDeps)].sort();
-  if (uniqueNpmDeps.length > 0) {
-    console.log("\n  npm packages\n");
-    for (const dep of uniqueNpmDeps) {
-      console.log(`  \u2192 ${dep}`);
-    }
-  }
-  console.log("");
-  const { written, skipped } = await writeComponentFiles(
-    resolved,
-    config,
-    projectRoot,
-    { overwrite: options.overwrite }
-  );
-  for (const file of written) {
-    console.log(`  ${CHECK}  ${file}`);
-  }
-  for (const file of skipped) {
-    console.log(`  ${dim(`\xB7  ${file}  (unchanged)`)}`);
-  }
-  if (uniqueNpmDeps.length > 0) {
-    console.log("");
-    await installDependencies(uniqueNpmDeps, projectRoot);
-  }
-  console.log("");
-}
-
-// src/commands/init.ts
-import fs10 from "fs";
-import fsp from "fs/promises";
-import path10 from "path";
-import { confirm, select } from "@inquirer/prompts";
-
-// src/utils/detect-project.ts
-import fs5 from "fs";
-import path7 from "path";
-import { loadConfig as loadConfig3 } from "tsconfig-paths";
-function hasFile(cwd, filenames) {
-  return filenames.some((f) => fs5.existsSync(path7.join(cwd, f)));
-}
-function findTailwindCssFile(cwd) {
-  const candidates = [
-    "src/app/globals.css",
-    "src/styles/globals.css",
-    "src/index.css",
-    "app/globals.css",
-    "styles/globals.css",
-    "index.css"
-  ];
-  for (const candidate of candidates) {
-    const fullPath = path7.join(cwd, candidate);
-    if (!fs5.existsSync(fullPath)) continue;
-    const content = fs5.readFileSync(fullPath, "utf-8");
-    if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'") || content.includes("@tailwind base")) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function detectProject(cwd) {
-  const hasSrc = fs5.existsSync(path7.join(cwd, "src"));
-  let framework = "other";
-  if (hasFile(cwd, ["next.config.ts", "next.config.js", "next.config.mjs"])) {
-    framework = "next";
-  } else if (hasFile(cwd, ["vite.config.ts", "vite.config.js", "vite.config.mjs"])) {
-    framework = "vite";
-  }
-  let rsc = false;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    rsc = fs5.existsSync(path7.join(cwd, appDir));
-  }
-  const existingCssFile = findTailwindCssFile(cwd);
-  let layoutFile = null;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    for (const ext of ["tsx", "jsx", "ts", "js"]) {
-      const candidate = `${appDir}/layout.${ext}`;
-      if (fs5.existsSync(path7.join(cwd, candidate))) {
-        layoutFile = candidate;
-        break;
-      }
-    }
-  } else if (framework === "vite") {
-    if (fs5.existsSync(path7.join(cwd, "index.html"))) {
-      layoutFile = "index.html";
-    }
-  }
-  return { hasSrc, framework, rsc, existingCssFile, layoutFile };
-}
-function detectAliasPrefix(cwd) {
-  let tsConfig;
-  try {
-    tsConfig = loadConfig3(cwd);
-  } catch {
-    return null;
-  }
-  if (tsConfig.resultType !== "success" || Object.keys(tsConfig.paths).length === 0) {
-    return null;
-  }
-  for (const [alias, targets] of Object.entries(tsConfig.paths)) {
-    if (targets.includes("./*") || targets.includes("./src/*") || targets.includes("./app/*")) {
-      return alias.replace(/\/\*$/, "");
-    }
-  }
-  const first = Object.keys(tsConfig.paths)[0];
-  return first ? first.replace(/\/\*$/, "") : null;
-}
-
-// src/utils/detect-fonts.ts
-import fs6 from "fs";
-import path8 from "path";
-function readIfExists(filePath) {
-  try {
-    return fs6.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function detectNextFont(layoutContent) {
-  const hasNextFont = /import.*from\s+['"]next\/font/.test(layoutContent) || /import.*from\s+['"]@next\/font/.test(layoutContent) || /import.*from\s+['"]geist\/font/.test(layoutContent);
-  let nextFontVariable = null;
-  const varMatch = layoutContent.match(/variable:\s*['"](--.+?)['"]/);
-  if (varMatch) {
-    nextFontVariable = varMatch[1];
-  }
-  return { hasNextFont, nextFontVariable };
-}
-function detectFontFace(cssContent) {
-  const hasFontFace = /@font-face\s*\{/.test(cssContent);
-  const fontFamilies = [];
-  const regex = /font-family:\s*['"]?([^'";}\n]+?)['"]?\s*;/g;
-  let match;
-  while ((match = regex.exec(cssContent)) !== null) {
-    const family = match[1].trim();
-    if (family && !fontFamilies.includes(family)) {
-      fontFamilies.push(family);
-    }
-  }
-  return { hasFontFace, fontFamilies };
-}
-function detectGoogleFonts(content) {
-  return content.includes("fonts.googleapis.com") || content.includes("fonts.gstatic.com");
-}
-function detectFonts(cwd, project) {
-  const result = {
-    hasNextFont: false,
-    hasFontFace: false,
-    hasGoogleFontsLink: false,
-    fontFamilies: [],
-    nextFontVariable: null
-  };
-  if (project.layoutFile) {
-    const layoutContent = readIfExists(path8.join(cwd, project.layoutFile));
-    if (layoutContent) {
-      const nextFontResult = detectNextFont(layoutContent);
-      result.hasNextFont = nextFontResult.hasNextFont;
-      result.nextFontVariable = nextFontResult.nextFontVariable;
-      if (detectGoogleFonts(layoutContent)) {
-        result.hasGoogleFontsLink = true;
-      }
-    }
-  }
-  if (project.existingCssFile) {
-    const cssContent = readIfExists(path8.join(cwd, project.existingCssFile));
-    if (cssContent) {
-      const fontFaceResult = detectFontFace(cssContent);
-      result.hasFontFace = fontFaceResult.hasFontFace;
-      result.fontFamilies.push(...fontFaceResult.fontFamilies);
-      if (detectGoogleFonts(cssContent)) {
-        result.hasGoogleFontsLink = true;
-      }
-      const importRegex = /@import\s+['"](.+?)['"]/g;
-      let importMatch;
-      while ((importMatch = importRegex.exec(cssContent)) !== null) {
-        const importPath = importMatch[1];
-        const resolvedPath = path8.join(
-          cwd,
-          path8.dirname(project.existingCssFile),
-          importPath
-        );
-        const importedContent = readIfExists(resolvedPath);
-        if (importedContent) {
-          const imported = detectFontFace(importedContent);
-          if (imported.hasFontFace) result.hasFontFace = true;
-          for (const family of imported.fontFamilies) {
-            if (!result.fontFamilies.includes(family)) {
-              result.fontFamilies.push(family);
-            }
-          }
-        }
-      }
-    }
-  }
-  for (const htmlFile of ["index.html", "src/index.html"]) {
-    const htmlContent = readIfExists(path8.join(cwd, htmlFile));
-    if (htmlContent && detectGoogleFonts(htmlContent)) {
-      result.hasGoogleFontsLink = true;
-    }
-  }
-  return result;
-}
-
-// src/utils/patch-css-vars.ts
-import fs7 from "fs";
-function patchCssVariables(filePath, patches) {
-  const content = fs7.readFileSync(filePath, "utf-8");
-  const lines = content.split("\n");
-  const patched = [];
-  for (let i = 0; i < lines.length; i++) {
-    for (const [prop, newValue] of Object.entries(patches)) {
-      const regex = new RegExp(`(\\s*${escapeRegex(prop)}:\\s*).+?(;)`);
-      if (regex.test(lines[i])) {
-        lines[i] = lines[i].replace(regex, `$1${newValue}$2`);
-        if (!patched.includes(prop)) patched.push(prop);
-      }
-    }
-  }
-  if (patched.length > 0) {
-    fs7.writeFileSync(filePath, lines.join("\n"), "utf-8");
-  }
-  return patched;
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/utils/update-fonts.ts
-import { existsSync, promises as fs8 } from "fs";
-import path9 from "path";
 import {
-  Project,
-  ScriptKind,
-  SyntaxKind,
-  VariableDeclarationKind
-} from "ts-morph";
-var ROOT_FONT_VARIABLES = /* @__PURE__ */ new Set([
-  "--font-sans",
-  "--font-serif",
-  "--font-mono"
-]);
-function massageTreeForFonts(fonts, project) {
-  const result = {
-    cssVars: {},
-    dependencies: [],
-    cssImports: []
-  };
-  if (fonts.length === 0) return result;
-  const isNext = project.framework === "next";
-  for (const font of fonts) {
-    if (isNext) {
-      result.cssVars[font.font.variable] = `var(${font.font.variable})`;
-    } else {
-      const fontName = font.name.replace(/^font-/, "");
-      const fontSourceDep = font.font.dependency ?? `@fontsource-variable/${fontName}`;
-      result.dependencies.push(fontSourceDep);
-      result.cssImports.push(`@import "${fontSourceDep}";`);
-      result.cssVars[font.font.variable] = font.font.family;
-    }
-  }
-  return result;
-}
-async function updateFonts(fonts, project, cwd, options = {}) {
-  if (fonts.length === 0) return;
-  if (project.framework !== "next") return;
-  const layoutPath = findLayoutFile(project, cwd);
-  if (!layoutPath) return;
-  if (options.silent) {
-    try {
-      const layoutContent = await fs8.readFile(layoutPath, "utf-8");
-      const updatedContent = transformLayoutFonts(layoutContent, fonts);
-      if (updatedContent !== layoutContent) {
-        await fs8.writeFile(layoutPath, updatedContent, "utf-8");
-      }
-    } catch {
-    }
-    return;
-  }
-  const spinner = createSpinner("Updating fonts");
-  try {
-    const layoutContent = await fs8.readFile(layoutPath, "utf-8");
-    const updatedContent = transformLayoutFonts(layoutContent, fonts);
-    if (updatedContent !== layoutContent) {
-      await fs8.writeFile(layoutPath, updatedContent, "utf-8");
-    }
-    spinner.succeed("Updated layout with font imports");
-  } catch {
-    spinner.fail("Failed to update fonts");
-  }
-}
-function findLayoutFile(project, cwd) {
-  if (!project.layoutFile) return null;
-  const fullPath = path9.join(cwd, project.layoutFile);
-  return existsSync(fullPath) ? fullPath : null;
-}
-function transformLayoutFonts(input, fonts) {
-  const project = new Project({ compilerOptions: {} });
-  const sourceFile = project.createSourceFile("layout.tsx", input, {
-    scriptKind: ScriptKind.TSX
-  });
-  const googleFonts = fonts.filter((f) => f.font.provider === "google");
-  const fontVariableNames = [];
-  const fontUtilityClasses = [];
-  for (const font of googleFonts) {
-    const importName = font.font.import;
-    if (!importName) continue;
-    const existingImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue() === "next/font/google"
-    );
-    let hasExistingImport = false;
-    if (existingImport) {
-      const namedImports = existingImport.getNamedImports();
-      hasExistingImport = namedImports.some(
-        (imp) => imp.getName() === importName
-      );
-      if (!hasExistingImport) {
-        existingImport.addNamedImport(importName);
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "next/font/google",
-        namedImports: [importName]
-      });
-    }
-    const varName = getFontVariableName(importName, font.font.variable);
-    const fontOptions = buildFontOptions(font);
-    const existingVarDecl = findFontVariableDeclaration(
-      sourceFile,
-      font.font.variable
-    );
-    if (hasExistingImport && !existingVarDecl && isRootFontVariable(font.font.variable)) {
-      continue;
-    }
-    if (existingVarDecl) {
-      existingVarDecl.setInitializer(`${importName}(${fontOptions})`);
-      if (existingVarDecl.getName() !== varName) {
-        existingVarDecl.rename(varName);
-      }
-    } else {
-      const insertPosition = findInsertPosition(sourceFile);
-      const statement = sourceFile.insertVariableStatement(insertPosition, {
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-          {
-            name: varName,
-            initializer: `${importName}(${fontOptions})`
-          }
-        ]
-      });
-      statement.appendWhitespace("\n");
-    }
-    fontVariableNames.push(varName);
-    if (shouldApplyFontUtilityToHtml(font)) {
-      fontUtilityClasses.push(font.font.variable.replace("--", ""));
-    }
-  }
-  const fontFamilyClasses = /* @__PURE__ */ new Set(["font-sans", "font-serif", "font-mono"]);
-  const lastFontFamilyClass = [...fontUtilityClasses].reverse().find((cls) => fontFamilyClasses.has(cls));
-  const filteredUtilityClasses = fontUtilityClasses.filter(
-    (cls) => !fontFamilyClasses.has(cls)
-  );
-  if (lastFontFamilyClass) {
-    filteredUtilityClasses.unshift(lastFontFamilyClass);
-  }
-  if (fontVariableNames.length > 0) {
-    updateHtmlClassName(sourceFile, fontVariableNames, filteredUtilityClasses);
-  }
-  return sourceFile.getFullText();
-}
-function buildFontOptions(font) {
-  const options = {};
-  if (font.font.subsets?.length) options.subsets = font.font.subsets;
-  if (font.font.weight?.length) options.weight = font.font.weight;
-  options.variable = font.font.variable;
-  return JSON.stringify(options).replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
-}
-function isRootFontVariable(variable) {
-  return ROOT_FONT_VARIABLES.has(variable);
-}
-function shouldApplyFontUtilityToHtml(font) {
-  return !font.font.selector && isRootFontVariable(font.font.variable);
-}
-function getFontVariableName(importName, variable) {
-  const baseName = toCamelCase(importName);
-  if (isRootFontVariable(variable)) return baseName;
-  return `${baseName}${toPascalCase(variable.replace(/^--font-/, ""))}`;
-}
-function toCamelCase(str) {
-  return str.split("_").map(
-    (part, index) => index === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
-  ).join("");
-}
-function toPascalCase(str) {
-  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function findFontVariableDeclaration(sourceFile, variable) {
-  for (const statement of sourceFile.getVariableStatements()) {
-    for (const declaration of statement.getDeclarations()) {
-      const initializer = declaration.getInitializer();
-      if (!initializer || initializer.getKind() !== SyntaxKind.CallExpression)
-        continue;
-      const args = initializer.getArguments();
-      if (args.length === 0) continue;
-      const argText = args[0].getText();
-      if (argText.includes("variable:") && argText.includes(variable)) {
-        return declaration;
-      }
-    }
-  }
-  return null;
-}
-function findInsertPosition(sourceFile) {
-  const imports = sourceFile.getImportDeclarations();
-  if (imports.length > 0) {
-    return imports[imports.length - 1].getChildIndex() + 1;
-  }
-  return 0;
-}
-function updateHtmlClassName(sourceFile, fontVariableNames, fontUtilityClasses) {
-  const jsxElements = sourceFile.getDescendantsOfKind(
-    SyntaxKind.JsxOpeningElement
-  );
-  for (const element of jsxElements) {
-    if (element.getTagNameNode().getText() !== "html") continue;
-    const newUtilityClasses = fontUtilityClasses.map((cls) => `"${cls}"`);
-    const newVarExpressions = fontVariableNames.map(
-      (name) => `${name}.variable`
-    );
-    const allNewArgs = [...newUtilityClasses, ...newVarExpressions];
-    const classNameAttr = element.getAttribute("className");
-    if (!classNameAttr) {
-      element.addAttribute({
-        name: "className",
-        initializer: `{cn(${allNewArgs.join(", ")})}`
-      });
-      ensureCnImport(sourceFile);
-      return;
-    }
-    if (classNameAttr.getKind() !== SyntaxKind.JsxAttribute) return;
-    const jsxAttr = classNameAttr.asKindOrThrow(SyntaxKind.JsxAttribute);
-    const initializer = jsxAttr.getInitializer();
-    if (!initializer) return;
-    if (initializer.getKind() === SyntaxKind.StringLiteral) {
-      const currentValue = initializer.getText().slice(1, -1);
-      ensureCnImport(sourceFile);
-      jsxAttr.setInitializer(
-        `{cn("${currentValue}", ${allNewArgs.join(", ")})}`
-      );
-    } else if (initializer.getKind() === SyntaxKind.JsxExpression) {
-      const jsxExpr = initializer.asKindOrThrow(SyntaxKind.JsxExpression);
-      const expr = jsxExpr.getExpression();
-      if (!expr) return;
-      const exprText = expr.getText();
-      if (exprText.startsWith("cn(")) {
-        const hasAllFontVars = newVarExpressions.every(
-          (v) => exprText.includes(v)
-        );
-        const hasAllUtilityClasses = fontUtilityClasses.every(
-          (cls) => exprText.includes(`"${cls}"`)
-        );
-        if (hasAllFontVars && hasAllUtilityClasses) continue;
-        let cleanedExpr = exprText;
-        for (const varExpr of newVarExpressions) {
-          cleanedExpr = cleanedExpr.replace(
-            new RegExp(`,?\\s*${varExpr.replace(".", "\\.")}`, "g"),
-            ""
-          );
-        }
-        cleanedExpr = cleanedExpr.replace(/cn\(\s*,/, "cn(");
-        const newExpr = cleanedExpr.replace(
-          /\)$/,
-          `, ${allNewArgs.join(", ")})`
-        );
-        jsxExpr.replaceWithText(`{${newExpr}}`);
-      } else if (/^\w+\.variable$/.test(exprText)) {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${allNewArgs.join(", ")})}`);
-      } else if (exprText.startsWith("`") && exprText.endsWith("`")) {
-        const cnArgs = parseTemplateLiteralToCnArgs(exprText);
-        ensureCnImport(sourceFile);
-        const allNewArgsSet = new Set(allNewArgs);
-        const fontFamilyLiterals = new Set(
-          ["font-sans", "font-serif", "font-mono"].map((c) => `"${c}"`)
-        );
-        const cleanedCnArgs = cnArgs.filter(
-          (arg) => !allNewArgsSet.has(arg) && !fontFamilyLiterals.has(arg)
-        );
-        jsxExpr.replaceWithText(
-          `{cn(${[...cleanedCnArgs, ...allNewArgs].join(", ")})}`
-        );
-      } else {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${exprText}, ${allNewArgs.join(", ")})}`);
-      }
-    }
-  }
-}
-function ensureCnImport(sourceFile) {
-  const existingImport = sourceFile.getImportDeclaration(
-    (decl) => decl.getNamedImports().some((imp) => imp.getName() === "cn")
-  );
-  if (!existingImport) {
-    const utilsImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue().includes("/lib/utils")
-    );
-    if (utilsImport) {
-      const namedImports = utilsImport.getNamedImports();
-      if (!namedImports.some((imp) => imp.getName() === "cn")) {
-        utilsImport.addNamedImport("cn");
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "@/lib/utils",
-        namedImports: ["cn"]
-      });
-    }
-  }
-}
-function parseTemplateLiteralToCnArgs(templateLiteral) {
-  const staticArgs = [];
-  const variableArgs = [];
-  const content = templateLiteral.slice(1, -1);
-  const parts = content.split(/(\$\{[^}]+\})/);
-  for (const part of parts) {
-    if (!part) continue;
-    if (part.startsWith("${") && part.endsWith("}")) {
-      const expr = part.slice(2, -1).trim();
-      if (expr) variableArgs.push(expr);
-    } else {
-      const staticParts = part.trim().split(/\s+/).filter(Boolean);
-      for (const staticPart of staticParts) {
-        staticArgs.push(`"${staticPart}"`);
-      }
-    }
-  }
-  return [...staticArgs, ...variableArgs];
-}
-
-// src/utils/css-imports.ts
-import fs9 from "fs/promises";
-async function insertImportLine(filePath, importStatement) {
-  const content = await fs9.readFile(filePath, "utf-8");
-  const importPath = importStatement.match(/["']([^"']+)["']/)?.[1];
-  if (importPath) {
-    const escaped = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (new RegExp(`@import\\s+["']${escaped}["']`).test(content)) return;
-  }
-  const lines = content.split("\n");
-  let lastImportIndex = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim().startsWith("@import")) {
-      lastImportIndex = i;
-    }
-  }
-  if (lastImportIndex >= 0) {
-    lines.splice(lastImportIndex + 1, 0, importStatement);
-  } else {
-    lines.unshift(importStatement);
-  }
-  await fs9.writeFile(filePath, lines.join("\n"), "utf-8");
-}
-
-// src/commands/init.ts
-var DEFAULT_FONT_NAMES = ["font-geist", "font-geist-mono"];
-function buildConfig(project, strategy, aliasPrefix) {
-  let cssPath;
-  if (project.existingCssFile) {
-    cssPath = project.existingCssFile;
-  } else if (project.hasSrc) {
-    cssPath = "src/styles/globals.css";
-  } else {
-    cssPath = "styles/globals.css";
-  }
-  return {
-    $schema: "https://ui.stera.sh/schema.json",
-    version: 1,
-    css: cssPath,
-    aliases: {
-      components: `${aliasPrefix}/components`,
-      utils: `${aliasPrefix}/lib/utils`,
-      ui: `${aliasPrefix}/components/ui`,
-      lib: `${aliasPrefix}/lib`,
-      hooks: `${aliasPrefix}/hooks`
-    },
-    fonts: {
-      strategy
-    }
-  };
-}
-async function promptFontStrategy(detected, skipPrompts) {
-  const hasExistingFonts = detected.hasNextFont || detected.hasFontFace || detected.hasGoogleFontsLink;
-  const defaultStrategy = hasExistingFonts ? "keep-existing" : "stera-default";
-  if (skipPrompts) return defaultStrategy;
-  if (hasExistingFonts) {
-    const sources = [];
-    if (detected.fontFamilies.length > 0) {
-      sources.push(detected.fontFamilies.join(", "));
-    }
-    if (detected.hasNextFont) sources.push("next/font");
-    if (detected.hasGoogleFontsLink) sources.push("Google Fonts");
-    console.log(`  Detected existing fonts: ${sources.join(" via ")}
-`);
-  }
-  const choices = [];
-  if (hasExistingFonts) {
-    choices.push({
-      value: "keep-existing",
-      name: "Keep my current fonts",
-      description: "Update CSS variables to use your existing fonts"
-    });
-  }
-  choices.push({
-    value: "stera-default",
-    name: "Use Stera UI default fonts (Geist Sans + Geist Mono)",
-    description: "Optimized variable fonts via next/font or fontsource"
-  });
-  choices.push({
-    value: "skip",
-    name: "Skip font setup",
-    description: "Configure fonts manually later"
-  });
-  const strategy = await select({
-    message: "How would you like to set up fonts?",
-    choices,
-    default: defaultStrategy
-  });
-  console.log("");
-  return strategy;
-}
-async function fetchDefaultFonts() {
-  const spinner = createSpinner("Fetching fonts");
-  const fonts = [];
-  try {
-    for (const name of DEFAULT_FONT_NAMES) {
-      try {
-        const item = await fetchRegistryItem(name);
-        if (item.type === "registry:font") {
-          fonts.push(item);
-        }
-      } catch {
-      }
-    }
-  } catch (err) {
-    spinner.fail("Failed to fetch fonts");
-    throw err;
-  }
-  spinner.succeed("Fonts resolved");
-  return fonts;
-}
-async function executeFontStrategy(strategy, project, detected, config, cwd) {
-  if (strategy === "skip") return;
-  const cssDir = path10.dirname(path10.resolve(cwd, config.css));
-  const steraUiPath = path10.join(cssDir, "stera-ui.css");
-  if (strategy === "keep-existing") {
-    const fontFamily = detected.fontFamilies.length > 0 ? detected.fontFamilies[0] : null;
-    const fontValue = detected.nextFontVariable ? `var(${detected.nextFontVariable})` : fontFamily ?? "Geist";
-    const patched = patchCssVariables(steraUiPath, {
-      "--font-heading": fontValue,
-      "--font-sans": fontValue
-    });
-    if (patched.length > 0) {
-      console.log(`  ${CHECK}  Updated font variables to use ${fontValue}`);
-    }
-    return;
-  }
-  const fonts = await fetchDefaultFonts();
-  if (fonts.length === 0) return;
-  const fontTree = massageTreeForFonts(fonts, project);
-  if (fontTree.dependencies.length > 0) {
-    await installDependencies(fontTree.dependencies, cwd);
-  }
-  if (fontTree.cssImports.length > 0) {
-    for (const importLine of fontTree.cssImports) {
-      await insertImportLine(steraUiPath, importLine);
-    }
-    console.log(`  ${CHECK}  Added font imports to ${path10.relative(cwd, steraUiPath)}`);
-  }
-  if (Object.keys(fontTree.cssVars).length > 0) {
-    const patched = patchCssVariables(steraUiPath, fontTree.cssVars);
-    if (patched.length > 0) {
-      console.log(`  ${CHECK}  Updated font variables in ${path10.relative(cwd, steraUiPath)}`);
-    }
-  }
-  await updateFonts(fonts, project, cwd);
-}
-async function init(options) {
-  const cwd = options.cwd ? path10.resolve(options.cwd) : process.cwd();
-  console.log(`
-  ${LOGO}  Stera UI
-`);
-  const existing = findConfigPath(cwd);
-  if (existing) {
-    const existingName = path10.basename(existing);
-    if (existingName === LEGACY_CONFIG_FILE) {
-      console.log(
-        `  Found legacy ${LEGACY_CONFIG_FILE} at ${existing}`
-      );
-      const shouldRename = options.yes ? true : await confirm({
-        message: `Rename it to ${CONFIG_FILE}?`,
-        default: true
-      });
-      if (shouldRename) {
-        const renamed = path10.join(path10.dirname(existing), CONFIG_FILE);
-        fs10.renameSync(existing, renamed);
-        console.log(`  ${CHECK}  Renamed to ${CONFIG_FILE}`);
-        console.log('  Run "stera-ui add <component>" to add components.\n');
-      } else {
-        console.log(
-          `  Keeping ${LEGACY_CONFIG_FILE} for now. Legacy filename support will be removed in a future release.
-`
-        );
-      }
-      return;
-    }
-    console.log(`  ${CONFIG_FILE} already exists at ${existing}`);
-    console.log('  Run "stera-ui add <component>" to add components.\n');
-    return;
-  }
-  const pkgPath = path10.join(cwd, "package.json");
-  if (!fs10.existsSync(pkgPath)) {
-    console.error(
-      "  Error: No package.json found. Please run this in a project directory."
-    );
-    process.exit(1);
-  }
-  const project = detectProject(cwd);
-  const aliasPrefix = detectAliasPrefix(cwd);
-  if (!aliasPrefix) {
-    console.error("");
-    console.error("  Error: No import alias found in your tsconfig.json file.");
-    console.error(
-      '  Stera UI requires a path alias (e.g. "@/*": ["./src/*"]) in compilerOptions.paths.'
-    );
-    console.error(
-      "  See https://ui.stera.sh/docs/installation for setup instructions per framework."
-    );
-    console.error("");
-    process.exit(1);
-  }
-  const frameworkName = project.framework === "next" ? "Next.js" : project.framework === "vite" ? "Vite" : null;
-  const parts = [];
-  if (frameworkName) parts.push(frameworkName);
-  if (project.hasSrc) parts.push("src/ directory");
-  if (parts.length > 0) {
-    console.log(`  Detected ${parts.join(" project with ")} project
-`);
-  }
-  const detectedFonts = detectFonts(cwd, project);
-  const strategy = await promptFontStrategy(
-    detectedFonts,
-    options.yes ?? false
-  );
-  const config = buildConfig(project, strategy, aliasPrefix);
-  const configPath = path10.join(cwd, CONFIG_FILE);
-  fs10.writeFileSync(
-    configPath,
-    JSON.stringify(config, null, 2) + "\n",
-    "utf-8"
-  );
-  console.log(`  ${CHECK}  Created ${CONFIG_FILE}`);
-  const fetchSpinner = createSpinner("Fetching base styles");
-  let steraCssResult;
-  try {
-    steraCssResult = await writeSteraUiCss(config, cwd);
-  } catch (err) {
-    fetchSpinner.fail("Failed to fetch base styles");
-    throw err;
-  }
-  fetchSpinner.succeed("Base styles resolved");
-  console.log(
-    `  ${CHECK}  Created ${path10.relative(cwd, steraCssResult.steraUiPath)}`
-  );
-  const globalsPath = project.existingCssFile ? path10.resolve(cwd, project.existingCssFile) : path10.resolve(cwd, config.css);
-  if (fs10.existsSync(globalsPath)) {
-    for (const imp of steraCssResult.extraImports) {
-      await insertImportLine(globalsPath, imp);
-    }
-    await insertImportLine(globalsPath, '@import "./stera-ui.css";');
-    console.log(
-      `  ${CHECK}  Added @import to ${path10.relative(cwd, globalsPath)}`
-    );
-  } else {
-    await fsp.mkdir(path10.dirname(globalsPath), { recursive: true });
-    const scaffold = [
-      '@import "tailwindcss";',
-      ...steraCssResult.extraImports,
-      '@import "./stera-ui.css";'
-    ].join("\n") + "\n";
-    await fsp.writeFile(globalsPath, scaffold, "utf-8");
-    console.log(`  ${CHECK}  Created ${path10.relative(cwd, globalsPath)}`);
-  }
-  await executeFontStrategy(
-    strategy,
-    project,
-    detectedFonts,
-    config,
-    cwd
-  );
-  if (steraCssResult.dependencies.length > 0) {
-    const deps = [...new Set(steraCssResult.dependencies)].sort();
-    console.log("");
-    await installDependencies(deps, cwd);
-  }
-  console.log("");
-  console.log("  Next steps:");
-  console.log("    stera-ui add <component>");
-  if (strategy === "skip") {
-    console.log("");
-    console.log(`  ${dim("Font setup was skipped. See https://ui.stera.sh for font configuration docs.")}`);
-  }
-  console.log("");
-}
-
-// src/commands/list.ts
-async function list() {
-  const spinner = createSpinner("Fetching registry");
-  let items;
-  try {
-    items = await getAllComponents();
-  } catch (err) {
-    spinner.fail("Failed to fetch registry");
-    throw err;
-  }
-  spinner.succeed("Registry resolved");
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const type = item.type.replace("registry:", "");
-    if (!groups.has(type)) groups.set(type, []);
-    groups.get(type).push(item);
-  }
-  console.log(`
-  ${LOGO}  Available components
-`);
-  for (const [type, groupItems] of groups) {
-    console.log(`  ${type}`);
-    for (const item of groupItems) {
-      const deps = item.registryDependencies?.length ? dim(`  (depends on: ${item.registryDependencies.join(", ")})`) : "";
-      console.log(`    ${item.name}${deps}`);
-    }
-    console.log("");
-  }
-  console.log(`  ${dim(`${items.length} components available`)}
-`);
-}
+  CROSS
+} from "./chunk-KGMF6UW4.js";
 
 // src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+var pkg = createRequire(import.meta.url)("../package.json");
 var program = new Command();
-program.name("stera-ui").description("Add Stera UI components to your project.").version("0.1.0");
+program.name("stera-ui").description("Add Stera UI components to your project.").version(pkg.version);
 program.command("init").description("Initialize Stera UI in your project.").option("-c, --cwd <path>", "Working directory", process.cwd()).option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
+  const { init } = await import("./init-E7O5WAUI.js");
   await init(options);
 });
 program.command("add").description("Add components to your project.").argument("<components...>", "Components to add").option("-c, --cwd <path>", "Working directory", process.cwd()).option("-y, --yes", "Skip confirmation prompts").option("-o, --overwrite", "Overwrite existing files without prompting").action(async (components, options) => {
+  const { add } = await import("./add-JUBSRCDJ.js");
   await add(components, options);
 });
 program.command("list").description("List all available components.").action(async () => {
+  const { list } = await import("./list-M73QTIWR.js");
   await list();
 });
-program.parse();
+program.parseAsync().catch((error) => {
+  if (error instanceof Error && error.name === "ExitPromptError") {
+    process.exit(130);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`
+  ${CROSS}  ${message}
+`);
+  process.exit(1);
+});