@glass-ui-kit/cli 0.2.4 → 1.0.0

package/dist/index.js

@@ -1,48 +1,150 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command3 } from "commander";
+import { Command as Command6 } 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 path4 from "path";
 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";
+function resolveProjectRoot(cwdOption, cwd = process.cwd()) {
+  return cwdOption ? path4.resolve(cwd, cwdOption) : cwd;
+}
+function getLockfilePath(projectRoot = process.cwd(), existsAtPath = exists) {
+  if (existsAtPath("bun.lock", projectRoot)) return "bun.lock";
+  if (existsAtPath("bun.lockb", projectRoot)) return "bun.lockb";
+  if (existsAtPath("pnpm-lock.yaml", projectRoot)) return "pnpm-lock.yaml";
+  if (existsAtPath("yarn.lock", projectRoot)) return "yarn.lock";
+  return null;
+}
+async function getPackageManager(projectRoot = process.cwd()) {
+  if (exists("bun.lock", projectRoot)) return "bun";
+  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 +158,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 +386,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."));
+// 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
     }
-    if (!exists(utilsPath)) {
-      await writeFile(utilsPath, UTILS_CN);
-      console.log(chalk.green(`  Created ${utilsRelativePath}`));
-    } else {
-      console.log(chalk.gray(`  ${utilsRelativePath} already exists.`));
+  ];
+  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;
     }
-    let cssContent = "";
-    try {
-      if (exists(cssPath)) {
-        cssContent = await readFile(cssPath);
-      } else {
-        console.log(chalk.yellow(`  Creating new CSS file at ${cssPath}`));
-      }
-    } catch (e) {
-    }
-    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 path5 from "path";
 import os from "os";
 import fs2 from "fs/promises";
 
@@ -427,8 +565,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 = path5.join(os.homedir(), ".glass-ui");
+var CACHE_FILE = path5.join(CACHE_DIR, "registry.json");
 var CACHE_TTL = 1e3 * 60 * 60 * 24;
 function getRegistryUrl() {
   return process.env.GLASS_UI_REGISTRY_URL || DEFAULT_REGISTRY_URL;
@@ -459,6 +597,12 @@ async function writeCache(data) {
   } catch {
   }
 }
+function getErrorMessage(error, fallback) {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return fallback;
+}
 async function fetchRegistry() {
   const cachedRegistry = await readCache();
   if (cachedRegistry) {
@@ -469,27 +613,22 @@ 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(getErrorMessage(error, "Network error: Unable to connect to registry."));
   }
   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 {
     data = await response.json();
-  } catch {
-    throw new Error("Invalid response: Registry returned non-JSON data.");
+  } catch (error) {
+    throw new Error(getErrorMessage(error, "Invalid response: Registry returned non-JSON data."));
   }
   const parsed = registryIndexSchema.safeParse(data);
   if (!parsed.success) {
-    console.error("Debug: Schema validation errors:", parsed.error.flatten());
-    throw new Error(
-      "Incompatible registry version. Your CLI might be outdated. Please try updating @glass-ui-kit/cli."
-    );
+    const issue = parsed.error.issues[0];
+    const location = issue?.path.length ? issue.path.join(".") : "registry";
+    throw new Error(`${issue?.message ?? "Schema validation failed"}: ${location}`);
   }
   await writeCache(parsed.data);
   return parsed.data;
@@ -497,6 +636,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 path6 from "path";
 
 // src/utils/transformers.ts
 function transformImports(content, config) {
@@ -519,63 +737,541 @@ 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 = path6.basename(file.path);
+      const filePath = path6.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 path7 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 resolveProjectRoot2(cwdOption, cwd) {
+  return cwdOption ? path7.resolve(cwd, cwdOption) : cwd;
+}
+async function runAddCommand(componentNames = [], options = {}, runtime = defaultRuntime2) {
+  const projectRoot = resolveProjectRoot2(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/commands/list.ts
+import chalk5 from "chalk";
+import { Command as Command3 } from "commander";
+
+// src/utils/list/run-list.ts
+var defaultRuntime3 = {
+  fetchRegistry
+};
+async function runListCommand(options = {}, runtime = defaultRuntime3) {
+  const registry = await runtime.fetchRegistry();
+  if (options.json) {
+    return JSON.stringify(registry, null, 2);
+  }
+  return registry.map((item) => item.name).join("\n");
+}
+
+// src/commands/list.ts
+async function runListCommand2(options = {}, runtime = defaultRuntime3) {
+  return runListCommand(options, runtime);
+}
+function createListAction(deps = {
+  runListCommand: runListCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (options = {}) => {
+    try {
+      const output = await deps.runListCommand({ json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk5.red("\nList failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk5.gray(error.message));
+      } else {
+        deps.error(chalk5.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var list = new Command3().name("list").description("List available components from the registry").option("--json", "Output the validated registry payload as JSON", false).action(createListAction());
+
+// src/commands/info.ts
+import chalk6 from "chalk";
+import { Command as Command4 } from "commander";
+
+// src/utils/info/format-info.ts
+function formatDependencySection(label, values) {
+  return `${label}: ${values && values.length > 0 ? values.join(", ") : "None"}`;
+}
+function formatInfo(item) {
+  const lines = [
+    `Name: ${item.name}`,
+    `Type: ${item.type}`,
+    "Files:",
+    ...item.files.map((file) => `- ${file.path} (${file.type})`),
+    formatDependencySection("Dependencies", item.dependencies),
+    formatDependencySection("Dev Dependencies", item.devDependencies),
+    formatDependencySection("Registry Dependencies", item.registryDependencies)
+  ];
+  if (item.meta?.requiresBlur !== void 0) {
+    lines.push(`Requires Blur: ${item.meta.requiresBlur}`);
+  }
+  return lines.join("\n");
+}
+
+// src/utils/info/run-info.ts
+var defaultRuntime4 = {
+  fetchRegistry,
+  getItem
+};
+async function runInfoCommand(componentName, options = {}, runtime = defaultRuntime4) {
+  const registry = await runtime.fetchRegistry();
+  const item = runtime.getItem(registry, componentName);
+  if (!item) {
+    throw new Error(`Component not found: "${componentName}"`);
+  }
+  if (options.json) {
+    return JSON.stringify(item, null, 2);
+  }
+  return formatInfo(item);
+}
+
+// src/commands/info.ts
+async function runInfoCommand2(componentName, options = {}, runtime = defaultRuntime4) {
+  return runInfoCommand(componentName, options, runtime);
+}
+function createInfoAction(deps = {
+  runInfoCommand: runInfoCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (componentName, options = {}) => {
+    try {
+      const output = await deps.runInfoCommand(componentName, { json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk6.red("\nInfo failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk6.gray(error.message));
+      } else {
+        deps.error(chalk6.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var info = new Command4().name("info").description("Show details for a single registry component").argument("<component>", "The exact component name to inspect").option("--json", "Output the validated registry item as JSON", false).action(createInfoAction());
+
+// src/commands/doctor.ts
+import chalk7 from "chalk";
+import { Command as Command5 } from "commander";
+
+// src/utils/doctor/format-doctor.ts
+function formatCheck(check) {
+  const icon = check.status === "ok" ? "\u2713" : check.status === "warn" ? "!" : "\u2716";
+  const lines = [`${icon} ${check.id} \u2014 ${check.summary}`];
+  if (check.detail) {
+    lines.push(`  Next step: ${check.detail}`);
+  }
+  return lines.join("\n");
+}
+function formatDoctorReport(report) {
+  const aliasLine = report.config.aliases ? `- Aliases: components=${report.config.aliases.components}, utils=${report.config.aliases.utils}` : "- Aliases: missing";
+  return [
+    "Glass UI Doctor",
+    `Project root: ${report.projectRoot}`,
+    `Init readiness: ${report.readiness.init ? "ready" : "not ready"}`,
+    `Add readiness: ${report.readiness.add ? "ready" : "not ready"}`,
+    "",
+    "Detected state:",
+    `- Framework: ${report.framework.value} (${report.framework.source})`,
+    `- Package manager: ${report.packageManager.value} (${report.packageManager.source})`,
+    `- Config: ${report.config.path} (${report.config.source})`,
+    `- CSS: ${report.css.path ?? "unresolved"} (${report.css.source}, ${report.css.exists ? "exists" : "missing"})`,
+    aliasLine,
+    "",
+    "Checks:",
+    ...report.checks.map(formatCheck)
+  ].join("\n");
+}
+
+// src/utils/doctor/inspect-project.ts
+import { z as z2 } from "zod";
+var configSchema = z2.object({
+  framework: z2.enum(["react", "next", "vite", "astro", "remix", "unknown"]),
+  style: z2.string(),
+  css: z2.string().min(1),
+  aliases: z2.object({
+    components: z2.string().min(1),
+    utils: z2.string().min(1)
+  })
 });
+function buildChecks(report) {
+  const checks = [];
+  if (report.config.source === "detected") {
+    checks.push({ id: "config", status: "ok", summary: "Found valid glass.config.json." });
+  } else if (report.config.source === "missing") {
+    checks.push({
+      id: "config",
+      status: "error",
+      summary: "glass.config.json was not found.",
+      detail: "Run `glass-ui init` in this project before running `glass-ui add`."
+    });
+  } else {
+    checks.push({
+      id: "config",
+      status: "error",
+      summary: "glass.config.json is invalid.",
+      detail: report.config.error ?? "Fix the config JSON and try doctor again."
+    });
+  }
+  if (report.framework.source === "detected") {
+    checks.push({
+      id: "framework",
+      status: "ok",
+      summary: `Detected framework: ${report.framework.value}.`
+    });
+  } else {
+    checks.push({
+      id: "framework",
+      status: "warn",
+      summary: `Could not confidently detect the framework; using ${report.framework.value}.`,
+      detail: "Check package.json dependencies or pass an explicit framework during `glass-ui init`."
+    });
+  }
+  if (report.packageManager.source === "detected") {
+    checks.push({
+      id: "package-manager",
+      status: "ok",
+      summary: `Detected package manager: ${report.packageManager.value}.`
+    });
+  } else {
+    checks.push({
+      id: "package-manager",
+      status: "warn",
+      summary: `No lockfile found; defaulting to ${report.packageManager.value}.`,
+      detail: "Create or commit the lockfile used by this project to confirm the package manager."
+    });
+  }
+  if (report.css.path && report.css.exists && report.css.source === "detected") {
+    checks.push({
+      id: "css",
+      status: "ok",
+      summary: `CSS file is available at ${report.css.path}.`
+    });
+  } else if (report.css.path && report.css.exists) {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: `CSS path was inferred as ${report.css.path}.`,
+      detail: "Save the CSS path in glass.config.json to confirm it explicitly."
+    });
+  } else if (report.css.path) {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: `CSS file is missing at ${report.css.path}.`,
+      detail: "Create the CSS file or update glass.config.json to point at the correct path."
+    });
+  } else {
+    checks.push({
+      id: "css",
+      status: "warn",
+      summary: "Could not resolve a CSS file path.",
+      detail: "Set the css field in glass.config.json or rerun `glass-ui init`."
+    });
+  }
+  if (report.config.aliases) {
+    checks.push({
+      id: "aliases",
+      status: "ok",
+      summary: "Detected components and utils aliases."
+    });
+  } else {
+    checks.push({
+      id: "aliases",
+      status: "error",
+      summary: "Components and utils aliases are missing.",
+      detail: "Save both aliases in glass.config.json so generated imports resolve correctly."
+    });
+  }
+  if (report.readiness.add) {
+    checks.push({ id: "add-readiness", status: "ok", summary: "Project is ready for add." });
+  } else {
+    checks.push({
+      id: "add-readiness",
+      status: "error",
+      summary: "Project is not ready for add.",
+      detail: "Create a valid glass.config.json with aliases before adding components."
+    });
+  }
+  return checks;
+}
+async function inspectProject(options = {}, runtime) {
+  const projectRoot = resolveProjectRoot(options.cwd, runtime.cwd());
+  if (!runtime.exists(".", projectRoot)) {
+    throw new Error(
+      `Could not inspect directory "${projectRoot}": path does not exist or is not accessible.`
+    );
+  }
+  const hasPackageJson = runtime.exists("package.json", projectRoot);
+  const frameworkValue = await runtime.getFramework(projectRoot);
+  const frameworkSource = hasPackageJson && frameworkValue !== "unknown" ? "detected" : "inferred";
+  const packageManagerValue = await runtime.getPackageManager(projectRoot);
+  const packageManagerSource = getLockfilePath(projectRoot, runtime.exists) ? "detected" : "inferred";
+  let config = {
+    path: "glass.config.json",
+    source: "missing"
+  };
+  if (runtime.exists("glass.config.json", projectRoot)) {
+    try {
+      const parsed = configSchema.parse(
+        JSON.parse(await runtime.readFile("glass.config.json", projectRoot))
+      );
+      config = {
+        path: "glass.config.json",
+        source: "detected",
+        css: parsed.css,
+        aliases: parsed.aliases
+      };
+    } catch (error) {
+      config = {
+        path: "glass.config.json",
+        source: "invalid",
+        error: error instanceof Error ? `Invalid config: ${error.message}` : "Invalid config."
+      };
+    }
+  }
+  const cssPath = config.css ?? runtime.getCssPath(frameworkValue, projectRoot);
+  const cssSource = config.css ? "detected" : cssPath ? "inferred" : "missing";
+  const cssExists = cssPath ? runtime.exists(cssPath, projectRoot) : false;
+  const readiness = {
+    init: true,
+    add: config.source === "detected" && Boolean(config.aliases?.components) && Boolean(config.aliases?.utils)
+  };
+  const reportWithoutChecks = {
+    projectRoot,
+    framework: { value: frameworkValue, source: frameworkSource },
+    packageManager: { value: packageManagerValue, source: packageManagerSource },
+    config,
+    css: {
+      path: cssPath,
+      exists: cssExists,
+      source: cssSource
+    },
+    readiness
+  };
+  return {
+    ...reportWithoutChecks,
+    checks: buildChecks(reportWithoutChecks)
+  };
+}
+
+// src/utils/doctor/run-doctor.ts
+var defaultRuntime5 = {
+  cwd: () => process.cwd(),
+  exists,
+  readFile,
+  writeFile,
+  getFramework,
+  getPackageManager,
+  getCssPath,
+  installDependencies,
+  inspectProject,
+  formatDoctorReport
+};
+async function runDoctorCommand(options = {}, runtime = defaultRuntime5) {
+  const resolvedRuntime = { ...defaultRuntime5, ...runtime };
+  const report = await resolvedRuntime.inspectProject(options, resolvedRuntime);
+  if (options.json) {
+    return JSON.stringify(report, null, 2);
+  }
+  return resolvedRuntime.formatDoctorReport(report);
+}
+
+// src/commands/doctor.ts
+async function runDoctorCommand2(options = {}, runtime = defaultRuntime5) {
+  return runDoctorCommand(options, runtime);
+}
+function createDoctorAction(deps = {
+  runDoctorCommand: runDoctorCommand2,
+  error: console.error,
+  log: console.log,
+  exit: process.exit
+}) {
+  return async (options = {}) => {
+    try {
+      const output = await deps.runDoctorCommand({ cwd: options.cwd, json: options.json === true });
+      if (output.length > 0) {
+        deps.log(output);
+      }
+    } catch (error) {
+      deps.error(chalk7.red("\nDoctor failed:"));
+      if (error instanceof Error) {
+        deps.error(chalk7.gray(error.message));
+      } else {
+        deps.error(chalk7.gray(String(error)));
+      }
+      deps.exit(1);
+    }
+  };
+}
+var doctor = new Command5().name("doctor").description("Diagnose whether a project is ready to use the CLI").option("--cwd <path>", "Run the command against another project directory").option("--json", "Output the diagnostic report as JSON", false).action(createDoctorAction());
 
 // 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");
+var program = new Command6();
+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.addCommand(list);
+program.addCommand(info);
+program.addCommand(doctor);
 program.parse(process.argv);