@glass-ui-kit/cli 0.2.4 → 0.2.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Tellez
+
+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/README.md

@@ -1,44 +1,44 @@
-# @glass-ui-kit/cli
-
-The official CLI for Glass UI. Add premium glassmorphism components to your React projects in seconds.
-
-## init
-
-Use the `init` command to initialize the project configuration.
-
-The `init` command:
-
-1. Creates a `glass.config.json` file.
-2. Generates the `cn` utility at `src/lib/utils.ts`.
-3. Installs necessary dependencies (`clsx`, `tailwind-merge`).
-4. Injects Glass Physics variables into your global CSS.
-
-```bash
-npx @glass-ui-kit/cli init
-
-```
-
-## add
-
-Use the `add` command to add components to your project.
-The `add` command downloads the component source code and places it directly into your project.
-
-```bash
-npx @glass-ui-kit/cli add [component]
-
-```
-
-### Example
-
-```bash
-npx @glass-ui-kit/cli add card
-
-```
-
-## Documentation
-
-Visit [https://ui-glass.vercel.app](https://ui-glass.vercel.app) to view the registry and documentation.
-
-## License
-
-Licensed under the [MIT license](https://github.com/jntellez/glass-ui/blob/master/LICENSE).
+# @glass-ui-kit/cli
+
+The official CLI for Glass UI. Add premium glassmorphism components to your React projects in seconds.
+
+## init
+
+Use the `init` command to initialize the project configuration.
+
+The `init` command:
+
+1. Creates a `glass.config.json` file.
+2. Generates the `cn` utility at `src/lib/utils.ts`.
+3. Installs necessary dependencies (`clsx`, `tailwind-merge`).
+4. Injects Glass Physics variables into your global CSS.
+
+```bash
+npx @glass-ui-kit/cli init
+
+```
+
+## add
+
+Use the `add` command to add components to your project.
+The `add` command downloads the component source code and places it directly into your project.
+
+```bash
+npx @glass-ui-kit/cli add [component]
+
+```
+
+### Example
+
+```bash
+npx @glass-ui-kit/cli add card
+
+```
+
+## Documentation
+
+Visit [https://ui-glass.vercel.app](https://ui-glass.vercel.app) to view the registry and documentation.
+
+## License
+
+Licensed under the [MIT license](https://github.com/jntellez/glass-ui/blob/master/LICENSE).

package/dist/index.js

@@ -4,45 +4,135 @@
 import { Command as Command3 } from "commander";
 
 // src/commands/init.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import { Command } from "commander";
+
+// src/utils/init/options.ts
+import path from "path";
+var SUPPORTED_INIT_FRAMEWORKS = ["react", "vite", "next", "remix"];
+function resolveInitOptions(options = {}, currentWorkingDirectory = process.cwd()) {
+  validateFrameworkOverride(options.framework);
+  return {
+    projectRoot: path.resolve(currentWorkingDirectory, options.cwd ?? "."),
+    cssOverride: options.css,
+    componentsAliasOverride: options.components,
+    utilsAliasOverride: options.utils,
+    frameworkOverride: options.framework,
+    force: options.force === true,
+    install: options.install !== false
+  };
+}
+function validateFrameworkOverride(framework) {
+  if (framework === void 0) {
+    return;
+  }
+  if (SUPPORTED_INIT_FRAMEWORKS.includes(framework)) {
+    return;
+  }
+  throw new Error(
+    `Unsupported framework "${framework}". Supported values: ${SUPPORTED_INIT_FRAMEWORKS.join(", ")}.`
+  );
+}
+
+// src/utils/init/paths.ts
 import path2 from "path";
+function resolveInitPaths({
+  projectRoot,
+  hasSrc,
+  framework,
+  detectedCssPath,
+  cssOverride,
+  componentsAliasOverride,
+  utilsAliasOverride
+}) {
+  let baseDir = hasSrc ? "src" : "";
+  if (framework === "remix") {
+    baseDir = "app";
+  }
+  let cssPath = cssOverride ?? detectedCssPath;
+  if (!cssPath) {
+    if (framework === "next") {
+      cssPath = hasSrc ? "src/app/globals.css" : "app/globals.css";
+    } else if (framework === "remix") {
+      cssPath = "app/app.css";
+    } else {
+      cssPath = hasSrc ? "src/index.css" : "index.css";
+    }
+  }
+  const defaultComponentsAlias = `${framework === "remix" ? "~" : "@"}/components/ui`;
+  const defaultUtilsAlias = `${framework === "remix" ? "~" : "@"}/lib/utils`;
+  const componentsAlias = componentsAliasOverride ?? defaultComponentsAlias;
+  const utilsAlias = utilsAliasOverride ?? defaultUtilsAlias;
+  const utilsRelativePath = resolveUtilsRelativePath(utilsAlias, baseDir);
+  const utilsPath = path2.join(projectRoot, utilsRelativePath);
+  const aliasPrefix = framework === "remix" ? "~" : "@";
+  return {
+    framework,
+    cssPath,
+    utilsRelativePath,
+    utilsPath,
+    aliasPrefix,
+    config: {
+      framework,
+      style: "default",
+      css: cssPath,
+      aliases: {
+        components: componentsAlias,
+        utils: utilsAlias
+      }
+    }
+  };
+}
+function resolveUtilsRelativePath(utilsAlias, baseDir) {
+  const aliasBody = stripAliasPrefix(utilsAlias);
+  const relativePath = baseDir && !aliasBody.startsWith(`${baseDir}/`) ? path2.posix.join(baseDir, aliasBody) : aliasBody;
+  return path2.posix.extname(relativePath) ? relativePath : `${relativePath}.ts`;
+}
+function stripAliasPrefix(alias) {
+  return alias.replace(/^[@~]\//, "");
+}
+
+// src/utils/init/run-init.ts
+import chalk from "chalk";
 
 // src/utils/filesystem.ts
 import fs from "fs";
-import path from "path";
-async function writeFile(filePath, content) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
-  const dir = path.dirname(absolutePath);
+import path3 from "path";
+function resolveFromBaseDir(filePath, baseDir = process.cwd()) {
+  return path3.resolve(baseDir, filePath);
+}
+async function writeFile(filePath, content, baseDir = process.cwd()) {
+  const absolutePath = resolveFromBaseDir(filePath, baseDir);
+  const dir = path3.dirname(absolutePath);
   if (!fs.existsSync(dir)) {
     await fs.promises.mkdir(dir, { recursive: true });
   }
   await fs.promises.writeFile(absolutePath, content, "utf-8");
   return absolutePath;
 }
-async function readFile(filePath) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
+async function readFile(filePath, baseDir = process.cwd()) {
+  const absolutePath = resolveFromBaseDir(filePath, baseDir);
   if (!fs.existsSync(absolutePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   return await fs.promises.readFile(absolutePath, "utf-8");
 }
-function exists(filePath) {
-  return fs.existsSync(path.resolve(process.cwd(), filePath));
+function exists(filePath, baseDir = process.cwd()) {
+  return fs.existsSync(resolveFromBaseDir(filePath, baseDir));
 }
 
 // src/utils/get-project-info.ts
 import { spawn } from "child_process";
-async function getPackageManager() {
-  if (exists("bun.lockb")) return "bun";
-  if (exists("pnpm-lock.yaml")) return "pnpm";
-  if (exists("yarn.lock")) return "yarn";
+async function getPackageManager(projectRoot = process.cwd()) {
+  if (exists("bun.lockb", projectRoot)) return "bun";
+  if (exists("pnpm-lock.yaml", projectRoot)) return "pnpm";
+  if (exists("yarn.lock", projectRoot)) return "yarn";
   return "npm";
 }
-async function getFramework() {
-  if (!exists("package.json")) return "unknown";
+async function getFramework(projectRoot = process.cwd()) {
+  if (!exists("package.json", projectRoot)) return "unknown";
   try {
-    const content = await readFile("package.json");
+    const content = await readFile("package.json", projectRoot);
     const pkg = JSON.parse(content);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (deps["@remix-run/react"] || deps["@remix-run/dev"] || deps["@react-router/dev"] || deps["@react-router/node"]) {
@@ -56,29 +146,26 @@ async function getFramework() {
   }
   return "unknown";
 }
-function getCssPath(framework) {
+function getCssPath(framework, projectRoot = process.cwd()) {
   const paths = {
+    react: ["src/index.css", "src/main.css", "src/style.css", "index.css"],
     next: ["app/globals.css", "src/app/globals.css", "styles/globals.css"],
     vite: ["src/index.css", "src/main.css", "src/style.css"],
     astro: ["src/styles/global.css", "src/global.css"],
-    remix: [
-      "app/app.css",
-      "app/tailwind.css",
-      "app/globals.css",
-      "app/styles/tailwind.css"
-    ],
+    remix: ["app/app.css", "app/tailwind.css", "app/globals.css", "app/styles/tailwind.css"],
     unknown: ["src/index.css", "styles.css"]
   };
   for (const p of paths[framework] || []) {
-    if (exists(p)) return p;
+    if (exists(p, projectRoot)) return p;
   }
   return paths[framework]?.[0] || null;
 }
-async function installDependencies(deps, pm) {
+async function installDependencies(deps, pm, projectRoot = process.cwd()) {
   const installCmd = pm === "npm" ? "install" : "add";
   console.log(`Running ${pm} ${installCmd}...`);
   return new Promise((resolve, reject) => {
     const child = spawn(pm, [installCmd, ...deps], {
+      cwd: projectRoot,
       stdio: "inherit",
       shell: true
     });
@@ -287,113 +374,152 @@ export function cn(...inputs: ClassValue[]) {
 }
 `;
 
-// src/commands/init.ts
-var init = new Command().name("init").description("Initialize configuration and dependencies").option("-y, --yes", "Skip confirmation prompt", false).action(async (opts) => {
-  try {
-    console.log(chalk.bold("\nInitializing Glass UI..."));
-    const framework = await getFramework();
-    const pm = await getPackageManager();
-    const cwd = process.cwd();
-    const configPath = "glass.config.json";
-    const hasSrc = exists("src");
-    let baseDir = hasSrc ? "src" : "";
-    if (framework === "remix") {
-      baseDir = "app";
-    }
-    let cssPath = getCssPath(framework);
-    if (!cssPath || framework === "next") {
-      if (framework === "next") {
-        cssPath = hasSrc ? "src/app/globals.css" : "app/globals.css";
-      } else if (framework === "remix") {
-        cssPath = "app/app.css";
-      } else {
-        cssPath = hasSrc ? "src/index.css" : "index.css";
-      }
-    }
-    const utilsRelativePath = baseDir ? `${baseDir}/lib/utils.ts` : "lib/utils.ts";
-    const utilsPath = path2.join(cwd, utilsRelativePath);
-    const aliasPrefix = framework === "remix" ? "~" : "@";
-    if (!exists(configPath)) {
-      await writeFile(
-        configPath,
-        JSON.stringify(
-          {
-            framework,
-            style: "default",
-            css: cssPath,
-            aliases: {
-              components: `${aliasPrefix}/components/ui`,
-              utils: `${aliasPrefix}/lib/utils`
-            }
-          },
-          null,
-          2
-        )
-      );
-      console.log(chalk.green("  Created glass.config.json"));
-    } else {
-      console.log(chalk.gray("  glass.config.json already exists."));
-    }
-    if (!exists(utilsPath)) {
-      await writeFile(utilsPath, UTILS_CN);
-      console.log(chalk.green(`  Created ${utilsRelativePath}`));
-    } else {
-      console.log(chalk.gray(`  ${utilsRelativePath} already exists.`));
+// src/utils/init/run-init.ts
+var defaultRuntime = {
+  cwd: () => process.cwd(),
+  exists,
+  readFile,
+  writeFile,
+  getFramework,
+  getPackageManager,
+  getCssPath,
+  installDependencies,
+  log: console.log
+};
+async function runInitCommand(options = {}, runtime = defaultRuntime) {
+  const resolvedOptions = resolveInitOptions(options, runtime.cwd());
+  runtime.log(chalk.bold("\nInitializing Glass UI..."));
+  const framework = resolvedOptions.frameworkOverride ?? await runtime.getFramework(resolvedOptions.projectRoot);
+  const pm = await runtime.getPackageManager(resolvedOptions.projectRoot);
+  const configPath = "glass.config.json";
+  const hasSrc = runtime.exists("src", resolvedOptions.projectRoot);
+  const plan = resolveInitPaths({
+    projectRoot: resolvedOptions.projectRoot,
+    hasSrc,
+    framework,
+    detectedCssPath: runtime.getCssPath(framework, resolvedOptions.projectRoot),
+    cssOverride: resolvedOptions.cssOverride,
+    componentsAliasOverride: resolvedOptions.componentsAliasOverride,
+    utilsAliasOverride: resolvedOptions.utilsAliasOverride
+  });
+  const writes = [
+    {
+      filePath: configPath,
+      content: JSON.stringify(plan.config, null, 2),
+      label: "glass.config.json"
+    },
+    {
+      filePath: plan.utilsRelativePath,
+      content: UTILS_CN,
+      label: plan.utilsRelativePath
+    },
+    {
+      filePath: plan.cssPath,
+      content: `@import "tailwindcss";
+
+${GLASS_BASE_STYLES}`,
+      label: plan.cssPath
     }
-    let cssContent = "";
-    try {
-      if (exists(cssPath)) {
-        cssContent = await readFile(cssPath);
-      } else {
-        console.log(chalk.yellow(`  Creating new CSS file at ${cssPath}`));
-      }
-    } catch (e) {
+  ];
+  for (const write of writes.slice(0, 2)) {
+    const alreadyExists = runtime.exists(write.filePath, resolvedOptions.projectRoot);
+    if (alreadyExists && !resolvedOptions.force) {
+      runtime.log(chalk.yellow(`  Skipped ${write.label} (already exists)`));
+      continue;
     }
-    if (!cssContent.includes("--glass-bg")) {
-      const newCssContent = `@import "tailwindcss";
-
-${GLASS_BASE_STYLES}`;
-      await writeFile(cssPath, newCssContent);
-      console.log(
-        chalk.green(
-          `  Overwrote ${cssPath} with Tailwind import and glass tokens`
-        )
-      );
+    await runtime.writeFile(write.filePath, write.content, resolvedOptions.projectRoot);
+    runtime.log(
+      alreadyExists ? chalk.green(`  Replaced ${write.label}`) : chalk.green(`  Created ${write.label}`)
+    );
+  }
+  const cssWrite = writes[2];
+  const cssAlreadyExists = runtime.exists(cssWrite.filePath, resolvedOptions.projectRoot);
+  if (!cssAlreadyExists) {
+    await runtime.writeFile(cssWrite.filePath, cssWrite.content, resolvedOptions.projectRoot);
+    runtime.log(chalk.green(`  Created ${cssWrite.label}`));
+  } else if (resolvedOptions.force) {
+    await runtime.writeFile(cssWrite.filePath, cssWrite.content, resolvedOptions.projectRoot);
+    runtime.log(chalk.green(`  Replaced ${cssWrite.label}`));
+  } else {
+    const existingCss = await runtime.readFile(cssWrite.filePath, resolvedOptions.projectRoot) ?? "";
+    if (existingCss.includes("--glass-bg")) {
+      runtime.log(chalk.yellow(`  Skipped ${cssWrite.label} (already exists)`));
     } else {
-      console.log(chalk.gray(`  Tokens already present in ${cssPath}`));
+      const updatedCss = `${existingCss.trimEnd()}
+
+${GLASS_BASE_STYLES}
+`;
+      await runtime.writeFile(cssWrite.filePath, updatedCss, resolvedOptions.projectRoot);
+      runtime.log(chalk.green(`  Updated ${cssWrite.label} with Glass tokens`));
     }
-    console.log(
-      chalk.cyan(
-        `  Installing dependencies (clsx, tailwind-merge, lucide-react)...`
-      )
-    );
-    await installDependencies(["clsx", "tailwind-merge", "lucide-react"], pm);
-    const runCommand = pm === "bun" ? "bunx" : pm === "pnpm" ? "pnpm dlx" : "npx";
-    console.log(chalk.bold.green("\nSetup complete."));
-    console.log(`Try adding a component:
-`);
-    console.log(
-      chalk.cyan(`  ${runCommand} @glass-ui-kit/cli@latest add card`)
+  }
+  if (resolvedOptions.install) {
+    runtime.log(chalk.cyan(`  Installing dependencies (clsx, tailwind-merge, lucide-react)...`));
+    await runtime.installDependencies(
+      ["clsx", "tailwind-merge", "lucide-react"],
+      pm,
+      resolvedOptions.projectRoot
     );
-    console.log("");
+  } else {
+    runtime.log(chalk.gray("  Skipped dependency installation (--no-install)."));
+  }
+  const runCommand = pm === "bun" ? "bunx" : pm === "pnpm" ? "pnpm dlx" : "npx";
+  runtime.log(chalk.bold.green("\nSetup complete."));
+  runtime.log(chalk.gray(`  Project root: ${resolvedOptions.projectRoot}`));
+  runtime.log(chalk.gray(`  Framework: ${plan.framework}`));
+  runtime.log("Try adding a component:\n");
+  runtime.log(chalk.cyan(`  ${runCommand} @glass-ui-kit/cli@latest add card`));
+  runtime.log("");
+}
+
+// src/commands/init.ts
+var InitCommandError = class extends Error {
+};
+async function runInitCommand2(options = {}, runtime = defaultRuntime) {
+  try {
+    await runInitCommand(options, runtime);
   } catch (error) {
-    console.error(chalk.red("\nInitialization failed:"));
     if (error instanceof Error) {
-      console.error(chalk.gray(error.message));
-    } else {
-      console.error(chalk.gray(String(error)));
+      throw new InitCommandError(error.message);
     }
-    process.exit(1);
+    throw new InitCommandError(String(error));
   }
-});
+}
+function createInitAction(deps = {
+  runInitCommand: runInitCommand2,
+  error: console.error,
+  exit: process.exit
+}) {
+  return async (options = {}) => {
+    try {
+      await deps.runInitCommand({
+        cwd: options.cwd,
+        css: options.css,
+        components: options.components,
+        utils: options.utils,
+        framework: options.framework,
+        force: options.force === true,
+        install: options.install
+      });
+    } catch (error) {
+      deps.error(chalk2.red("\nInitialization failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk2.gray(error.message));
+      } else {
+        deps.error(chalk2.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var init = new Command().name("init").description("Initialize configuration and dependencies").option("-y, --yes", "Skip confirmation prompt", false).option("--cwd <path>", "Run the command against another project directory").option("--css <path>", "Use a custom CSS file instead of autodetecting one").option("--components <alias>", "Set the components alias saved in glass.config.json").option("--utils <alias>", "Set the utils alias saved in glass.config.json").option("--framework <name>", "Force the framework instead of autodetecting it").option("--force", "Overwrite generated files if they already exist").option("--no-install", "Skip dependency installation").action(createInitAction());
 
 // src/commands/add.ts
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 import { Command as Command2 } from "commander";
-import path4 from "path";
 
 // src/utils/registry.ts
-import path3 from "path";
+import path4 from "path";
 import os from "os";
 import fs2 from "fs/promises";
 
@@ -427,8 +553,8 @@ var registryIndexSchema = z.array(registryItemSchema);
 
 // src/utils/registry.ts
 var DEFAULT_REGISTRY_URL = "https://ui-glass.vercel.app/registry.json";
-var CACHE_DIR = path3.join(os.homedir(), ".glass-ui");
-var CACHE_FILE = path3.join(CACHE_DIR, "registry.json");
+var CACHE_DIR = path4.join(os.homedir(), ".glass-ui");
+var CACHE_FILE = path4.join(CACHE_DIR, "registry.json");
 var CACHE_TTL = 1e3 * 60 * 60 * 24;
 function getRegistryUrl() {
   return process.env.GLASS_UI_REGISTRY_URL || DEFAULT_REGISTRY_URL;
@@ -469,14 +595,10 @@ async function fetchRegistry() {
   try {
     response = await fetch(url);
   } catch (error) {
-    throw new Error(
-      "Network error: Unable to connect to registry. Check your internet connection."
-    );
+    throw new Error("Network error: Unable to connect to registry. Check your internet connection.");
   }
   if (!response.ok) {
-    throw new Error(
-      `Registry unavailable. URL: ${url} (Status: ${response.status})`
-    );
+    throw new Error(`Registry unavailable. URL: ${url} (Status: ${response.status})`);
   }
   let data;
   try {
@@ -497,6 +619,85 @@ async function fetchRegistry() {
 function getItem(registry, name) {
   return registry.find((item) => item.name === name);
 }
+function getItems(registry, names) {
+  const items = [];
+  const missing = [];
+  for (const name of names) {
+    const item = getItem(registry, name);
+    if (item) {
+      items.push(item);
+      continue;
+    }
+    missing.push(name);
+  }
+  return { items, missing };
+}
+
+// src/utils/add/selection.ts
+function dedupeNames(names) {
+  const uniqueNames = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    uniqueNames.push(name);
+  }
+  return uniqueNames;
+}
+function resolveAddSelection(registry, requestedNames, selectAll) {
+  if (selectAll && requestedNames.length > 0) {
+    return { ok: false, reason: "invalid-combination" };
+  }
+  if (selectAll) {
+    return { ok: true, items: registry };
+  }
+  const uniqueRequestedNames = dedupeNames(requestedNames);
+  if (uniqueRequestedNames.length === 0) {
+    return { ok: false, reason: "empty-selection" };
+  }
+  const { items, missing } = getItems(registry, uniqueRequestedNames);
+  if (missing.length > 0) {
+    return { ok: false, reason: "missing-components", names: missing };
+  }
+  return { ok: true, items };
+}
+
+// src/utils/add/dependencies.ts
+function collectDependencies(items) {
+  const dependencies = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    for (const dependency of item.dependencies || []) {
+      if (seen.has(dependency)) {
+        continue;
+      }
+      seen.add(dependency);
+      dependencies.push(dependency);
+    }
+  }
+  return dependencies;
+}
+
+// src/utils/add/paths.ts
+function resolveTargetDir(config, hasSrc, explicitPath) {
+  if (explicitPath) {
+    return explicitPath;
+  }
+  const targetDirAlias = config.aliases.components || "@/components/ui";
+  const relativeAliasPath = targetDirAlias.replace(/^[@~]\//, "");
+  if (config.framework === "remix") {
+    return `./app/${relativeAliasPath}`;
+  }
+  if (hasSrc) {
+    return `./src/${relativeAliasPath}`;
+  }
+  return `./${relativeAliasPath}`;
+}
+
+// src/utils/add/planner.ts
+import path5 from "path";
 
 // src/utils/transformers.ts
 function transformImports(content, config) {
@@ -519,63 +720,167 @@ function transformImports(content, config) {
   return transformed;
 }
 
-// src/commands/add.ts
-var add = new Command2().name("add").description("Add a component to your project").argument("<component>", "The component to add").action(async (componentName) => {
-  try {
-    if (!exists("glass.config.json")) {
-      console.error(chalk2.red("Configuration file not found."));
-      console.log(chalk2.gray("Please run the init command first:"));
-      console.log(chalk2.cyan("  npx @glass-ui-kit/cli@latest init"));
-      process.exit(1);
-    }
-    const config = JSON.parse(await readFile("glass.config.json"));
-    const pm = await getPackageManager();
-    console.log(chalk2.bold(`Fetching component: ${componentName}...`));
-    const registry = await fetchRegistry();
-    const item = getItem(registry, componentName);
-    if (!item) {
-      console.error(chalk2.red(`Component '${componentName}' not found.`));
-      process.exit(1);
+// src/utils/add/planner.ts
+function buildWritePlan(items, config, hasSrc, options) {
+  const targetDir = resolveTargetDir(config, hasSrc, options.path);
+  return items.flatMap(
+    (item) => item.files.filter((file) => Boolean(file.content)).map((file) => {
+      const fileName = path5.basename(file.path);
+      const filePath = path5.join(targetDir, fileName);
+      return {
+        filePath,
+        content: transformImports(file.content || "", config),
+        action: !options.overwrite && options.exists(filePath) ? "skip-existing" : "write"
+      };
+    })
+  );
+}
+
+// src/utils/add/run-add.ts
+import path6 from "path";
+import chalk3 from "chalk";
+var defaultRuntime2 = {
+  cwd: () => process.cwd(),
+  exists,
+  readFile,
+  writeFile,
+  fetchRegistry,
+  getPackageManager,
+  installDependencies,
+  log: console.log
+};
+function buildMissingComponentsMessage(names) {
+  return `Components not found: ${names.join(", ")}.`;
+}
+function resolveProjectRoot(cwdOption, cwd) {
+  return cwdOption ? path6.resolve(cwd, cwdOption) : cwd;
+}
+async function runAddCommand(componentNames = [], options = {}, runtime = defaultRuntime2) {
+  const projectRoot = resolveProjectRoot(options.cwd, runtime.cwd?.() ?? process.cwd());
+  if (options.depsOnly && options.install === false) {
+    throw new Error("invalid-install-combination");
+  }
+  if (!runtime.exists("glass.config.json", projectRoot)) {
+    throw new Error("config-not-found");
+  }
+  const config = JSON.parse(await runtime.readFile("glass.config.json", projectRoot));
+  runtime.log(chalk3.bold("Fetching components..."));
+  const registry = await runtime.fetchRegistry();
+  const selection = resolveAddSelection(registry, componentNames, Boolean(options.all));
+  if (!selection.ok) {
+    if (selection.reason === "invalid-combination") {
+      throw new Error("invalid-combination");
     }
-    const hasSrc = exists("src");
-    const targetDirAlias = config.aliases.components || "@/components/ui";
-    const relativeAliasPath = targetDirAlias.replace(/^[@~]\//, "");
-    let targetDir = "";
-    if (config.framework === "remix") {
-      targetDir = `./app/${relativeAliasPath}`;
-    } else if (hasSrc) {
-      targetDir = `./src/${relativeAliasPath}`;
-    } else {
-      targetDir = `./${relativeAliasPath}`;
+    if (selection.reason === "missing-components") {
+      throw new Error(buildMissingComponentsMessage(selection.names || []));
     }
-    for (const file of item.files) {
-      const fileName = path4.basename(file.path);
-      const filePath = path4.join(targetDir, fileName);
-      if (!file.content) {
+    throw new Error("empty-selection");
+  }
+  const shouldWrite = options.depsOnly !== true;
+  const shouldInstall = options.install !== false;
+  if (shouldWrite) {
+    const plannedWrites = buildWritePlan(
+      selection.items,
+      config,
+      runtime.exists("src", projectRoot),
+      {
+        exists: (filePath) => runtime.exists(filePath, projectRoot),
+        overwrite: options.overwrite,
+        path: options.path
+      }
+    );
+    for (const file of plannedWrites) {
+      if (file.action === "skip-existing") {
+        runtime.log(chalk3.yellow(`  Skipped ${file.filePath} (already exists)`));
         continue;
       }
-      const transformedContent = transformImports(file.content, config);
-      await writeFile(filePath, transformedContent);
-      console.log(chalk2.green(`  Created ${filePath}`));
+      await runtime.writeFile(file.filePath, file.content, projectRoot);
+      runtime.log(chalk3.green(`  Created ${file.filePath}`));
     }
-    if (item.dependencies?.length) {
-      console.log(chalk2.cyan(`  Installing dependencies...`));
-      await installDependencies(item.dependencies, pm);
-    }
-    console.log(chalk2.bold.green(`
-Done.`));
+  }
+  const dependencies = collectDependencies(selection.items);
+  if (shouldInstall && dependencies.length > 0) {
+    const pm = await runtime.getPackageManager(projectRoot);
+    runtime.log(chalk3.cyan("  Installing dependencies..."));
+    await runtime.installDependencies(dependencies, pm, projectRoot);
+  }
+  runtime.log(chalk3.bold.green("\nDone."));
+}
+
+// src/commands/add.ts
+var AddCommandError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function runAddCommand2(componentNames = [], options = {}, runtime = defaultRuntime2) {
+  try {
+    await runAddCommand(componentNames, options, runtime);
   } catch (error) {
-    console.error(chalk2.red("\nOperation failed:"));
     if (error instanceof Error) {
-      console.error(chalk2.gray(`  ${error.message}`));
+      if (error.message === "config-not-found") {
+        throw new AddCommandError("config-not-found", "Configuration file not found.");
+      }
+      if (error.message === "invalid-combination") {
+        throw new AddCommandError(
+          "invalid-combination",
+          "Cannot combine --all with specific component names."
+        );
+      }
+      if (error.message === "invalid-install-combination") {
+        throw new AddCommandError(
+          "invalid-combination",
+          "Cannot combine --deps-only with --no-install."
+        );
+      }
+      if (error.message === "empty-selection") {
+        throw new AddCommandError(
+          "empty-selection",
+          "Please specify at least one component or use --all."
+        );
+      }
+      if (error.message.startsWith("Components not found:")) {
+        throw new AddCommandError("missing-components", error.message);
+      }
     }
-    process.exit(1);
+    throw error;
   }
-});
+}
+function createAddAction(deps = {
+  runAddCommand: runAddCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (componentNames = [], options = {}) => {
+    try {
+      await deps.runAddCommand(componentNames, options);
+    } catch (error) {
+      if (error instanceof AddCommandError) {
+        if (error.code === "config-not-found") {
+          deps.error(chalk4.red(error.message));
+          deps.log(chalk4.gray("Please run the init command first:"));
+          deps.log(chalk4.cyan("  npx @glass-ui-kit/cli@latest init"));
+          deps.exit(1);
+        }
+        deps.error(chalk4.red(error.message));
+        deps.exit(1);
+      }
+      deps.error(chalk4.red("\nOperation failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk4.gray(`  ${error.message}`));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var add = new Command2().name("add").description("Add one or more components to your project").argument("[components...]", "The components to add").option("--all", "Add all available components").option("--overwrite", "Replace existing component files").option("--path <dir>", "Use a custom output directory").option("--no-install", "Skip dependency installation").option("--deps-only", "Install dependencies without writing component files").option("--cwd <path>", "Run the command against another project directory").action(createAddAction());
 
 // src/index.ts
 var program = new Command3();
-program.name("glass-ui").description("The Glass UI CLI - Add glassmorphism components to your app").version("0.0.1");
+program.name("glass-ui").description("The Glass UI CLI - Add glassmorphism components to your app").version("0.2.5");
 program.addCommand(init);
 program.addCommand(add);
 program.parse(process.argv);

package/package.json

@@ -1,59 +1,60 @@
-{
-  "name": "@glass-ui-kit/cli",
-  "version": "0.2.4",
-  "description": "The official CLI for Glass UI. Add glassmorphism components to your React projects in seconds.",
-  "keywords": [
-    "glassmorphism",
-    "design-system",
-    "react",
-    "cli",
-    "ui",
-    "tailwind"
-  ],
-  "homepage": "https://github.com/jntellez/glass-ui#readme",
-  "bugs": {
-    "url": "https://github.com/jntellez/glass-ui/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jntellez/glass-ui.git",
-    "directory": "packages/cli"
-  },
-  "license": "MIT",
-  "author": "Glass UI Team",
-  "type": "module",
-  "bin": {
-    "glass-ui": "./dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "sync": "node scripts/sync-styles.mjs",
-    "build": "pnpm run sync && tsup src/index.ts --format esm --clean",
-    "dev": "pnpm run sync && bun run ./src/index.ts",
-    "lint": "eslint src",
-    "prepublishOnly": "pnpm run build"
-  },
-  "dependencies": {
-    "chalk": "^5.3.0",
-    "commander": "^11.1.0",
-    "node-fetch": "^3.3.2",
-    "zod": "^3.22.4"
-  },
-  "devDependencies": {
-    "@glass-ui-kit/tsconfig": "workspace:*",
-    "@glass-ui-kit/schema": "workspace:*",
-    "@types/node": "^20.11.0",
-    "bun-types": "latest",
-    "tsup": "^8.0.1",
-    "typescript": "^5.3.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@glass-ui-kit/cli",
+  "version": "0.2.5",
+  "description": "The official CLI for Glass UI. Add glassmorphism components to your React projects in seconds.",
+  "keywords": [
+    "glassmorphism",
+    "design-system",
+    "react",
+    "cli",
+    "ui",
+    "tailwind"
+  ],
+  "homepage": "https://github.com/jntellez/glass-ui#readme",
+  "bugs": {
+    "url": "https://github.com/jntellez/glass-ui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jntellez/glass-ui.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Glass UI Team",
+  "type": "module",
+  "bin": {
+    "glass-ui": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "node-fetch": "^3.3.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "bun-types": "latest",
+    "vitest": "^3.2.4",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "@glass-ui-kit/schema": "0.0.1",
+    "@glass-ui-kit/tsconfig": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "sync": "node scripts/sync-styles.mjs",
+    "build": "pnpm run sync && tsup src/index.ts --format esm --clean",
+    "dev": "pnpm run sync && bun run ./src/index.ts",
+    "lint": "eslint src",
+    "test": "vitest run"
+  }
+}