stera-ui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaz Giese
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,665 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.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 = "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;
+}
+function findConfigPath(cwd) {
+  let dir = path.resolve(cwd);
+  while (true) {
+    const configPath = path.join(dir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) return configPath;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadConfig(cwd) {
+  const configPath = findConfigPath(cwd);
+  if (!configPath) return null;
+  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.site/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") {
+    const match = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths);
+    const resolved = match(alias, void 0, () => true, [".ts", ".tsx"]);
+    if (resolved) {
+      return path2.relative(projectRoot, resolved);
+    }
+  }
+  return alias.replace(/^@\//, "");
+}
+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 { spawn } from "child_process";
+
+// 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";
+var WARN = "!";
+
+// 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
+function detectPackageManager(cwd) {
+  if (fs3.existsSync(path4.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs3.existsSync(path4.join(cwd, "bun.lockb"))) return "bun";
+  if (fs3.existsSync(path4.join(cwd, "yarn.lock"))) return "yarn";
+  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 = detectPackageManager(cwd);
+  const [cmd, args] = getInstallArgs(pm, toInstall);
+  const spinner = createSpinner(`Installing with ${pm}`);
+  await new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { cwd, stdio: "pipe" });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed(`Installed with ${pm}`);
+        resolve();
+      } else {
+        spinner.fail(`Install failed (exit ${code})`);
+        reject(new Error(`${pm} exited with code ${code}`));
+      }
+    });
+    proc.on("error", (err) => {
+      spinner.fail(`Install failed`);
+      reject(err);
+    });
+  });
+}
+
+// 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/detect-globals.ts
+import fs4 from "fs";
+import path5 from "path";
+function hasGlobalsCss(config, projectRoot) {
+  const cssPath = path5.resolve(projectRoot, config.css);
+  if (!fs4.existsSync(cssPath)) {
+    return false;
+  }
+  const steraPath = path5.join(path5.dirname(cssPath), "stera-ui.css");
+  return fs4.existsSync(steraPath);
+}
+
+// src/commands/add.ts
+var transforms = [transformImports];
+async function add(components, options) {
+  const cwd = options.cwd ? path6.resolve(options.cwd) : process.cwd();
+  for (const name of components) {
+    const item = await getComponent(name);
+    if (!item) {
+      console.error(`  Error: Component "${name}" not found in registry.`);
+      console.error(`  Run "stera-ui list" to see available components.`);
+      process.exit(1);
+    }
+  }
+  const configPath = findConfigPath(cwd);
+  if (!configPath) {
+    console.error(
+      `  Error: ${CONFIG_FILE} not found. Run "stera-ui init" first.`
+    );
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  if (!config) {
+    console.error(`  Error: Failed to parse ${CONFIG_FILE}.`);
+    process.exit(1);
+  }
+  const projectRoot = path6.dirname(configPath);
+  const isAddingGlobals = components.includes("globals");
+  if (!isAddingGlobals && !hasGlobalsCss(config, projectRoot)) {
+    console.warn(`
+  ${WARN}  Stera design tokens not found in ${config.css}`);
+    console.warn(`     Components may not render correctly.`);
+    console.warn(`     Run "stera-ui add globals" to install base styles.
+`);
+  }
+  const resolved = await resolveDependencies(components);
+  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 fs6 from "fs";
+import path8 from "path";
+
+// src/utils/detect-project.ts
+import fs5 from "fs";
+import path7 from "path";
+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);
+  return { hasSrc, framework, rsc, existingCssFile };
+}
+
+// src/commands/init.ts
+function buildConfig(project) {
+  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.site/schema.json",
+    version: 1,
+    css: cssPath,
+    aliases: {
+      components: "@/components",
+      utils: "@/lib/utils",
+      ui: "@/components/ui",
+      lib: "@/lib",
+      hooks: "@/hooks"
+    }
+  };
+}
+function stripTailwindCoreImport(content) {
+  return content.split("\n").filter((line) => !line.trim().match(/^@import\s+["']tailwindcss["']/)).join("\n");
+}
+function insertImportLine(filePath, importStatement) {
+  const content = fs6.readFileSync(filePath, "utf-8");
+  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);
+  }
+  fs6.writeFileSync(filePath, lines.join("\n"), "utf-8");
+}
+async function init(options) {
+  const cwd = options.cwd ? path8.resolve(options.cwd) : process.cwd();
+  console.log(`
+  ${LOGO}  Stera UI
+`);
+  const existing = findConfigPath(cwd);
+  if (existing) {
+    console.log(`  components.json already exists at ${existing}`);
+    console.log('  Run "stera-ui add <component>" to add components.\n');
+    return;
+  }
+  const pkgPath = path8.join(cwd, "package.json");
+  if (!fs6.existsSync(pkgPath)) {
+    console.error(
+      "  Error: No package.json found. Please run this in a project directory."
+    );
+    process.exit(1);
+  }
+  const project = detectProject(cwd);
+  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 config = buildConfig(project);
+  const configPath = path8.join(cwd, CONFIG_FILE);
+  fs6.writeFileSync(
+    configPath,
+    JSON.stringify(config, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log(`  ${CHECK}  Created components.json`);
+  const cssDir = path8.dirname(path8.resolve(cwd, config.css));
+  if (project.existingCssFile) {
+    if (hasGlobalsCss(config, cwd)) {
+      console.log(
+        `  ${CHECK}  Stera already initialised ${dim(`(${path8.join(path8.dirname(project.existingCssFile), "stera-ui.css")} exists)`)}`
+      );
+    } else {
+      try {
+        const globalsItem = await fetchRegistryItem("globals");
+        const globalsContent = globalsItem.files[0].content ?? "";
+        const steraUiContent = stripTailwindCoreImport(globalsContent);
+        const steraUiPath = path8.join(cssDir, "stera-ui.css");
+        fs6.mkdirSync(cssDir, { recursive: true });
+        fs6.writeFileSync(steraUiPath, steraUiContent, "utf-8");
+        console.log(`  ${CHECK}  Created ${path8.relative(cwd, steraUiPath)}`);
+        const existingCssPath = path8.resolve(cwd, project.existingCssFile);
+        insertImportLine(existingCssPath, "@import './stera-ui.css';");
+        console.log(`  ${CHECK}  Added @import to ${project.existingCssFile}`);
+      } catch {
+      }
+    }
+    try {
+      const fontsItem = await fetchRegistryItem("fonts");
+      const fontsPath = path8.join(cssDir, "fonts.css");
+      fs6.mkdirSync(path8.dirname(fontsPath), { recursive: true });
+      if (!fs6.existsSync(fontsPath)) {
+        fs6.writeFileSync(fontsPath, fontsItem.files[0].content ?? "", "utf-8");
+        console.log(`  ${CHECK}  Created ${path8.relative(cwd, fontsPath)}`);
+      } else {
+        console.log(`  ${dim(path8.relative(cwd, fontsPath) + " (already exists, skipped)")}`);
+      }
+    } catch {
+    }
+  } else {
+    const resolved = await resolveDependencies(["globals"]);
+    const { written } = await writeComponentFiles(resolved, config, cwd);
+    for (const file of written) {
+      console.log(`  ${CHECK}  Created ${file}`);
+    }
+  }
+  try {
+    const globalsItem = await fetchRegistryItem("globals");
+    if (globalsItem.dependencies) {
+      const deps = [...new Set(globalsItem.dependencies)].sort();
+      console.log("");
+      await installDependencies(deps, cwd);
+    }
+  } catch {
+  }
+  console.log("");
+  console.log("  Next steps:");
+  console.log("    stera-ui add <component>");
+  console.log("");
+  console.log(`  ${dim("See the README for font setup instructions.")}`);
+  console.log("");
+}
+
+// src/commands/list.ts
+async function list() {
+  const items = await getAllComponents();
+  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`)}
+`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("stera-ui").description("Add Stera UI components to your project.").version("0.1.0");
+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) => {
+  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) => {
+  await add(components, options);
+});
+program.command("list").description("List all available components.").action(async () => {
+  await list();
+});
+program.parse();