ui8kit 1.1.0 → 1.3.5

package/dist/index.js

@@ -2,15 +2,14 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk7 from "chalk";
+import chalk12 from "chalk";
 
 // src/commands/add.ts
-import chalk3 from "chalk";
-import ora from "ora";
-import path3 from "path";
-import fs4 from "fs-extra";
-import { execa } from "execa";
+import ora4 from "ora";
+import path8 from "path";
+import fs7 from "fs-extra";
 import fetch3 from "node-fetch";
+import prompts3 from "prompts";
 
 // src/registry/api.ts
 import fetch from "node-fetch";
@@ -87,6 +86,7 @@ var SCHEMA_CONFIG = {
     schema: "JSON Schema URL",
     framework: "Target framework",
     typescript: "Whether the project uses TypeScript",
+    globalCss: "Path to global styles entry file",
     aliases: "Path aliases for imports in UI8Kit structure",
     registry: "Default component registry",
     componentsDir: "Directory where utility components will be installed",
@@ -153,285 +153,294 @@ var configSchema = z.object({
   $schema: z.string().optional(),
   framework: z.literal(SCHEMA_CONFIG.supportedFrameworks[0]),
   typescript: z.boolean().default(true),
+  globalCss: z.string().default("src/index.css"),
   aliases: z.record(z.string(), z.string()).default(SCHEMA_CONFIG.defaultAliases),
   registry: z.string().default(SCHEMA_CONFIG.defaultRegistry),
   componentsDir: z.string().default(SCHEMA_CONFIG.defaultDirectories.components),
   libDir: z.string().default(SCHEMA_CONFIG.defaultDirectories.lib)
 });
 
-// src/registry/api.ts
-var registryCache = /* @__PURE__ */ new Map();
-function isUrl(path7) {
-  try {
-    new URL(path7);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRegistryCache(registryType) {
-  if (!registryCache.has(registryType)) {
-    registryCache.set(registryType, {
-      workingCDN: null,
-      registryIndex: null
-    });
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var verboseEnabled = false;
+function output(level, message, ...args) {
+  const prefix = (() => {
+    switch (level) {
+      case "info":
+        return chalk.blue("\u2139");
+      case "success":
+        return chalk.green("\u2705");
+      case "warn":
+        return chalk.yellow("\u26A0\uFE0F");
+      case "error":
+        return chalk.red("\u274C");
+      case "debug":
+        return chalk.gray("\u{1F41E}");
+      default:
+        return "";
+    }
+  })();
+  if (level === "debug" && !verboseEnabled) {
+    return;
   }
-  return registryCache.get(registryType);
+  console.log(`${prefix} ${message}`, ...args);
 }
-async function findWorkingCDN(registryType) {
-  const cache = getRegistryCache(registryType);
-  if (cache.workingCDN) {
-    return cache.workingCDN;
+var logger = {
+  setVerbose(enabled) {
+    verboseEnabled = enabled;
+  },
+  info(message, ...args) {
+    output("info", message, ...args);
+  },
+  success(message, ...args) {
+    output("success", message, ...args);
+  },
+  warn(message, ...args) {
+    output("warn", message, ...args);
+  },
+  error(message, ...args) {
+    output("error", message, ...args);
+  },
+  debug(message, ...args) {
+    output("debug", message, ...args);
+  },
+  spinner(text) {
+    return ora(text).start();
   }
-  const cdnUrls = getCdnUrls(registryType);
-  for (const baseUrl of cdnUrls) {
-    try {
-      console.log(`\u{1F50D} Testing ${registryType} CDN: ${baseUrl}`);
-      const response = await fetch(`${baseUrl}/index.json`);
-      if (response.ok) {
-        cache.workingCDN = baseUrl;
-        console.log(`\u2705 Using ${registryType} CDN: ${baseUrl}`);
-        return baseUrl;
-      }
-    } catch (error) {
-      console.log(`\u274C ${registryType} CDN failed: ${baseUrl}`);
-    }
+};
+
+// src/utils/cache.ts
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+var DEFAULT_TTL_MS = 36e5;
+function normalizeKey(key) {
+  return key.trim().replace(/^\/+/, "").replace(/\\/g, "/");
+}
+function cacheFilePath(key) {
+  const cacheDir = getCacheDir();
+  const normalized = normalizeKey(key);
+  const normalizedWithJson = normalized.endsWith(".json") ? normalized : `${normalized}.json`;
+  const dataPath = path.join(cacheDir, normalizedWithJson);
+  return { dataPath, metaPath: `${dataPath}.meta.json` };
+}
+function getCacheDir() {
+  return path.join(os.homedir(), ".ui8kit", "cache");
+}
+function parseTimestamp(timestamp) {
+  if (typeof timestamp !== "number") {
+    return null;
   }
-  throw new Error(`No working ${registryType} CDN found`);
+  return Number.isFinite(timestamp) ? timestamp : null;
 }
-async function fetchFromWorkingCDN(path7, registryType) {
-  const baseUrl = await findWorkingCDN(registryType);
-  const url = `${baseUrl}/${path7}`;
-  console.log(`\u{1F3AF} Fetching from ${registryType}: ${url}`);
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+async function getCachedJson(key, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  if (options.noCache) {
+    return null;
   }
-  return await response.json();
-}
-async function getRegistryIndex(registryType) {
-  const cache = getRegistryCache(registryType);
-  if (cache.registryIndex) {
-    return cache.registryIndex;
+  const { dataPath, metaPath } = cacheFilePath(key);
+  if (!await fs.pathExists(dataPath) || !await fs.pathExists(metaPath)) {
+    return null;
   }
-  console.log(`\u{1F310} Fetching ${registryType} registry index`);
-  cache.registryIndex = await fetchFromWorkingCDN("index.json", registryType);
-  return cache.registryIndex;
-}
-async function getComponentByType(name, registryType) {
   try {
-    const index = await getRegistryIndex(registryType);
-    const componentInfo = index.components?.find((c) => c.name === name);
-    if (!componentInfo) {
-      console.log(`\u274C Component ${name} not found in ${registryType} registry`);
+    const meta = await fs.readJson(metaPath);
+    const lastFetched = parseTimestamp(meta?.lastFetched);
+    const metaTtl = parseTimestamp(meta?.ttl) ?? ttlMs;
+    if (!lastFetched) {
       return null;
     }
-    const folder = componentInfo.type === "registry:variants" ? "components/variants" : TYPE_TO_FOLDER[componentInfo.type];
-    if (!folder) {
-      console.log(`\u274C Unknown component type: ${componentInfo.type}`);
+    const now = Date.now();
+    if (now - lastFetched > metaTtl) {
       return null;
     }
-    console.log(`\u{1F3AF} Loading ${name} from /${folder}/ (type: ${componentInfo.type})`);
-    const data = await fetchFromWorkingCDN(`${folder}/${name}.json`, registryType);
-    return componentSchema.parse(data);
-  } catch (error) {
-    console.log(`\u274C Failed to get component by type: ${error.message}`);
-    return null;
-  }
-}
-async function getComponent(name, registryType = SCHEMA_CONFIG.defaultRegistryType) {
-  try {
-    if (isUrl(name)) {
-      return await fetchFromUrl(name);
-    }
-    return await getComponentByType(name, registryType);
-  } catch (error) {
-    console.error(`\u274C Failed to fetch ${name} from ${registryType}:`, error.message);
+    return await fs.readJson(dataPath);
+  } catch {
     return null;
   }
 }
-async function fetchFromUrl(url) {
-  console.log(`\u{1F310} Fetching component from: ${url}`);
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return componentSchema.parse(data);
+async function setCachedJson(key, data, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  const { dataPath, metaPath } = cacheFilePath(key);
+  await fs.ensureDir(path.dirname(dataPath));
+  await fs.writeJson(dataPath, data, { spaces: 2 });
+  await fs.writeJson(metaPath, {
+    lastFetched: Date.now(),
+    ttl: ttlMs
+  });
 }
-async function getAllComponents(registryType = SCHEMA_CONFIG.defaultRegistryType) {
-  try {
-    console.log(`\u{1F310} Fetching all ${registryType} components using optimized approach`);
-    const indexData = await getRegistryIndex(registryType);
-    const components = [];
-    if (indexData.components && Array.isArray(indexData.components)) {
-      for (const componentInfo of indexData.components) {
-        const component = await getComponent(componentInfo.name, registryType);
-        if (component) {
-          components.push(component);
-        }
-      }
-    }
-    return components;
-  } catch (error) {
-    console.error(`\u274C Failed to fetch all ${registryType} components:`, error.message);
-    return [];
+async function clearCache() {
+  const cacheDir = getCacheDir();
+  if (await fs.pathExists(cacheDir)) {
+    await fs.remove(cacheDir);
   }
 }
 
-// src/registry/retry-api.ts
-import fetch2 from "node-fetch";
-var MAX_RETRIES = 3;
-var RETRY_DELAY = 2e3;
-var registryCache2 = /* @__PURE__ */ new Map();
-function isUrl2(path7) {
+// src/registry/api.ts
+var REGISTRY_INDEX_CACHE_TTL_MS = 36e5;
+var registryCache = /* @__PURE__ */ new Map();
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RETRIES = 1;
+var RETRY_DELAY_MS = 1200;
+function isUrl(path13) {
   try {
-    new URL(path7);
+    new URL(path13);
     return true;
   } catch {
     return false;
   }
 }
-function getRegistryCache2(registryType) {
-  if (!registryCache2.has(registryType)) {
-    registryCache2.set(registryType, {
+function getRegistryCache(registryType) {
+  if (!registryCache.has(registryType)) {
+    registryCache.set(registryType, {
       workingCDN: null,
       registryIndex: null
     });
   }
-  return registryCache2.get(registryType);
+  return registryCache.get(registryType);
 }
-async function checkInternetConnection() {
+async function fetchJsonWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    console.log("\u{1F310} Checking internet connection...");
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch2("https://www.google.com", {
-      method: "HEAD",
-      signal: controller.signal
-    });
+    const response = await fetch(url, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+  } finally {
     clearTimeout(timeoutId);
-    return response.ok;
-  } catch (error) {
-    console.log("\u274C No internet connection detected");
-    return false;
   }
 }
-async function fetchWithRetry(url, retries = MAX_RETRIES) {
-  for (let attempt = 1; attempt <= retries; attempt++) {
+async function fetchJsonWithRetry(url, maxRetries, timeoutMs) {
+  let attempt = 0;
+  let lastError;
+  while (attempt < maxRetries) {
+    attempt += 1;
     try {
-      console.log(`\u{1F504} Attempt ${attempt}/${retries}: ${url}`);
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 1e4);
-      const response = await fetch2(url, {
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        return await response.json();
-      } else if (response.status === 404) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      } else {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
+      return await fetchJsonWithTimeout(url, timeoutMs);
     } catch (error) {
-      console.log(`\u274C Attempt ${attempt} failed: ${error.message}`);
-      if (attempt === retries) {
-        throw error;
+      lastError = error;
+      if (attempt >= maxRetries) {
+        break;
       }
-      console.log(`\u23F3 Waiting ${RETRY_DELAY / 1e3}s before retry...`);
-      await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+      await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
     }
   }
+  throw lastError instanceof Error ? lastError : new Error("Request failed");
 }
-async function findWorkingCDNWithRetry(registryType) {
-  const cache = getRegistryCache2(registryType);
-  if (cache.workingCDN) {
-    return cache.workingCDN;
-  }
-  if (!await checkInternetConnection()) {
-    throw new Error("No internet connection available");
-  }
+async function fetchFromRegistryPath(requestPath, registryType, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = Math.max(1, options.maxRetries ?? DEFAULT_MAX_RETRIES);
+  const cache = getRegistryCache(registryType);
   const cdnUrls = getCdnUrls(registryType);
-  for (const baseUrl of cdnUrls) {
+  const orderedUrls = cache.workingCDN ? [cache.workingCDN, ...cdnUrls.filter((url) => url !== cache.workingCDN)] : [...cdnUrls];
+  let lastError;
+  for (const baseUrl of orderedUrls) {
     try {
-      console.log(`\u{1F50D} Testing ${registryType} CDN with retry: ${baseUrl}`);
-      await fetchWithRetry(`${baseUrl}/index.json`, 2);
+      const data = await fetchJsonWithRetry(`${baseUrl}/${requestPath}`, maxRetries, timeoutMs);
+      if (cache.workingCDN !== baseUrl) {
+        cache.registryIndex = null;
+      }
       cache.workingCDN = baseUrl;
-      console.log(`\u2705 Using ${registryType} CDN: ${baseUrl}`);
-      return baseUrl;
+      return data;
     } catch (error) {
-      console.log(`\u274C ${registryType} CDN failed: ${baseUrl}`);
+      lastError = error;
+      if (cache.workingCDN === baseUrl) {
+        cache.workingCDN = null;
+      }
     }
   }
-  throw new Error(`No working ${registryType} CDN found`);
+  throw lastError instanceof Error ? lastError : new Error(`No working ${registryType} CDN found`);
 }
-async function fetchFromWorkingCDNWithRetry(path7, registryType) {
-  const baseUrl = await findWorkingCDNWithRetry(registryType);
-  const url = `${baseUrl}/${path7}`;
-  console.log(`\u{1F3AF} Fetching from ${registryType} with retry: ${url}`);
-  return await fetchWithRetry(url);
-}
-async function getRegistryIndexWithRetry(registryType) {
-  const cache = getRegistryCache2(registryType);
-  if (cache.registryIndex) {
-    return cache.registryIndex;
+async function getRegistryIndex(registryType, options = {}) {
+  if (cacheStateHasIndex(registryType, options)) {
+    return getCachedInMemory(registryType);
+  }
+  const cached = await getCachedJson(
+    `${registryType}/index.json`,
+    { noCache: options.noCache, ttlMs: REGISTRY_INDEX_CACHE_TTL_MS }
+  );
+  if (cached) {
+    setCachedInMemory(registryType, cached);
+    return cached;
   }
-  console.log(`\u{1F310} Fetching ${registryType} registry index with retry`);
-  cache.registryIndex = await fetchFromWorkingCDNWithRetry("index.json", registryType);
+  const cache = getRegistryCache(registryType);
+  cache.registryIndex = await fetchFromRegistryPath("index.json", registryType, options);
+  await setCachedJson(
+    `${registryType}/index.json`,
+    cache.registryIndex,
+    { ttlMs: REGISTRY_INDEX_CACHE_TTL_MS }
+  );
   return cache.registryIndex;
 }
-async function getComponentByTypeWithRetry(name, registryType) {
+async function getComponentByType(name, registryType, options = {}) {
+  const normalizedName = name.toLowerCase();
+  const cachedComponent = await getCachedJson(
+    `${registryType}/components/${normalizedName}.json`,
+    { noCache: options.noCache, ttlMs: REGISTRY_INDEX_CACHE_TTL_MS }
+  );
+  if (cachedComponent) {
+    try {
+      return componentSchema.parse(cachedComponent);
+    } catch (error) {
+      logger.debug(`Invalid cached component for ${name}, refetching`);
+    }
+  }
   try {
-    const index = await getRegistryIndexWithRetry(registryType);
-    const componentInfo = index.components?.find((c) => c.name === name);
+    const index = await getRegistryIndex(registryType, options);
+    const excludeTypes = options.excludeTypes ?? [];
+    const componentInfo = index.components?.find(
+      (c) => typeof c?.name === "string" && c.name.toLowerCase() === normalizedName && !excludeTypes.includes(c.type)
+    );
     if (!componentInfo) {
-      console.log(`\u274C Component ${name} not found in ${registryType} registry`);
+      logger.debug(`Component ${name} not found in ${registryType} registry`);
       return null;
     }
-    const folder = TYPE_TO_FOLDER[componentInfo.type];
+    const folder = componentInfo.type === "registry:variants" ? "components/variants" : TYPE_TO_FOLDER[componentInfo.type];
     if (!folder) {
-      console.log(`\u274C Unknown component type: ${componentInfo.type}`);
+      logger.debug(`Unknown component type: ${componentInfo.type}`);
       return null;
     }
-    console.log(`\u{1F3AF} Loading ${name} from /${registryType}/${folder}/ (type: ${componentInfo.type})`);
-    const data = await fetchFromWorkingCDNWithRetry(`${folder}/${name}.json`, registryType);
+    logger.debug(`Loading ${name} from /${folder}/ (type: ${componentInfo.type})`);
+    const data = await fetchFromRegistryPath(`${folder}/${name}.json`, registryType, options);
+    await setCachedJson(`${registryType}/components/${normalizedName}.json`, data, { ttlMs: REGISTRY_INDEX_CACHE_TTL_MS });
     return componentSchema.parse(data);
   } catch (error) {
-    console.log(`\u274C Failed to get component by type: ${error.message}`);
+    logger.debug(`Failed to get component by type: ${error.message}`);
     return null;
   }
 }
-async function getComponentWithRetry(name, registryType = SCHEMA_CONFIG.defaultRegistryType) {
+async function getComponent(name, registryType = SCHEMA_CONFIG.defaultRegistryType, options = {}) {
   try {
-    if (isUrl2(name)) {
-      return await fetchFromUrlWithRetry(name);
-    }
-    if (!await checkInternetConnection()) {
-      throw new Error("No internet connection available");
+    if (isUrl(name)) {
+      return await fetchFromUrl(name, options);
     }
-    return await getComponentByTypeWithRetry(name, registryType);
+    return await getComponentByType(name, registryType, options);
   } catch (error) {
-    console.error(`\u274C Failed to fetch ${name} from ${registryType}:`, error.message);
+    logger.debug(`Failed to fetch ${name} from ${registryType}: ${error.message}`);
     return null;
   }
 }
-async function fetchFromUrlWithRetry(url) {
-  console.log(`\u{1F310} Fetching component from URL with retry: ${url}`);
-  const data = await fetchWithRetry(url);
+async function fetchFromUrl(url, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = Math.max(1, options.maxRetries ?? DEFAULT_MAX_RETRIES);
+  logger.debug(`Fetching component from: ${url}`);
+  const data = await fetchJsonWithRetry(url, maxRetries, timeoutMs);
   return componentSchema.parse(data);
 }
-async function getAllComponentsWithRetry(registryType = SCHEMA_CONFIG.defaultRegistryType) {
+async function getAllComponents(registryType = SCHEMA_CONFIG.defaultRegistryType, options = {}) {
   try {
-    console.log(`\u{1F310} Fetching all ${registryType} components with retry logic`);
-    if (!await checkInternetConnection()) {
-      throw new Error("No internet connection available");
-    }
-    const indexData = await getRegistryIndexWithRetry(registryType);
+    logger.debug(`Fetching all ${registryType} components using optimized approach`);
+    const indexData = await getRegistryIndex(registryType, options);
     const components = [];
+    const excludeTypes = options.excludeTypes ?? [];
     if (indexData.components && Array.isArray(indexData.components)) {
       for (const componentInfo of indexData.components) {
-        const component = await getComponentWithRetry(componentInfo.name, registryType);
+        if (excludeTypes.includes(componentInfo.type)) {
+          continue;
+        }
+        const component = await getComponent(componentInfo.name, registryType, options);
         if (component) {
           components.push(component);
         }
@@ -439,14 +448,37 @@ async function getAllComponentsWithRetry(registryType = SCHEMA_CONFIG.defaultReg
     }
     return components;
   } catch (error) {
-    console.error(`\u274C Failed to fetch all ${registryType} components:`, error.message);
+    logger.debug(`Failed to fetch all ${registryType} components: ${error.message}`);
     return [];
   }
 }
+function cacheStateHasIndex(registryType, options) {
+  if (options.noCache) {
+    return false;
+  }
+  const cache = getRegistryCache(registryType);
+  return Boolean(cache.registryIndex);
+}
+function getCachedInMemory(registryType) {
+  return getRegistryCache(registryType).registryIndex;
+}
+function setCachedInMemory(registryType, index) {
+  const cache = getRegistryCache(registryType);
+  cache.registryIndex = index;
+}
+function resetCache(registryType) {
+  if (registryType) {
+    registryCache.delete(registryType);
+    logger.debug(`Cache reset for ${registryType} - will rediscover working CDN`);
+  } else {
+    registryCache.clear();
+    logger.debug(`All registry caches reset - will rediscover working CDNs`);
+  }
+}
 
 // src/utils/project.ts
-import fs from "fs-extra";
-import path from "path";
+import fs2 from "fs-extra";
+import path2 from "path";
 var MODERN_CONFIG_NAME = "ui8kit.config.json";
 async function isViteProject() {
   const viteConfigFiles = [
@@ -456,134 +488,71 @@ async function isViteProject() {
     "vite.config.mjs"
   ];
   for (const file of viteConfigFiles) {
-    if (await fs.pathExists(file)) {
+    if (await fs2.pathExists(file)) {
       return true;
     }
   }
   return false;
 }
 async function hasReact() {
-  const packageJsonPath = path.join(process.cwd(), "package.json");
-  if (!await fs.pathExists(packageJsonPath)) {
+  const packageJsonPath = path2.join(process.cwd(), "package.json");
+  if (!await fs2.pathExists(packageJsonPath)) {
     return false;
   }
-  const packageJson = await fs.readJson(packageJsonPath);
+  const packageJson = await fs2.readJson(packageJsonPath);
   const deps = {
     ...packageJson.dependencies,
     ...packageJson.devDependencies
   };
   return "react" in deps;
 }
-async function findConfig(_registryType) {
+async function findConfig(registryType) {
+  const rootConfig = await getConfig();
+  if (rootConfig)
+    return rootConfig;
   const srcConfig = await getConfig("./src");
   if (srcConfig)
     return srcConfig;
-  if (_registryType) {
-    const registryConfig = await getConfig(`./${_registryType}`);
+  if (registryType) {
+    const registryConfig = await getConfig(`./${registryType}`);
     if (registryConfig)
       return registryConfig;
   }
-  return await getConfig();
+  return null;
 }
 async function getConfig(registryPath) {
-  const baseDir = registryPath ? path.join(process.cwd(), registryPath) : process.cwd();
-  const configPath = path.join(baseDir, MODERN_CONFIG_NAME);
-  if (!await fs.pathExists(configPath)) {
+  const baseDir = registryPath ? path2.join(process.cwd(), registryPath) : process.cwd();
+  const configPath = path2.join(baseDir, MODERN_CONFIG_NAME);
+  if (!await fs2.pathExists(configPath)) {
     return null;
   }
   try {
-    const config = await fs.readJson(configPath);
+    const config = await fs2.readJson(configPath);
     return configSchema.parse(config);
   } catch (error) {
     console.error("\u274C Invalid ui8kit.config.json:", error.message);
     return null;
   }
 }
-async function saveConfig(config, registryPath) {
-  const configPath = registryPath ? path.join(process.cwd(), registryPath, MODERN_CONFIG_NAME) : path.join(process.cwd(), MODERN_CONFIG_NAME);
-  await fs.ensureDir(path.dirname(configPath));
-  await fs.writeJson(configPath, config, { spaces: 2 });
+async function saveConfig(config) {
+  const configPath = path2.join(process.cwd(), MODERN_CONFIG_NAME);
+  await fs2.ensureDir(path2.dirname(configPath));
+  await fs2.writeJson(configPath, config, { spaces: 2 });
 }
 async function ensureDir(dirPath) {
-  await fs.ensureDir(dirPath);
+  await fs2.ensureDir(dirPath);
 }
 
 // src/utils/registry-validator.ts
-import fs2 from "fs-extra";
-import chalk from "chalk";
-async function validateComponentInstallation(components, registryType) {
-  return { isValid: true };
-}
-function handleValidationError(result) {
-  console.error(chalk.red("\u274C Registry Validation Error:"));
-  console.error(chalk.red(result.message));
-  if (result.missingComponents && result.missingComponents.length > 0) {
-    console.log(chalk.yellow("\n\u{1F4A1} Suggestion:"));
-    console.log(`Install missing components first: ${chalk.cyan(`npx ui8kit add ${result.missingComponents.join(" ")}`)}
-`);
-  }
-  process.exit(1);
-}
+import fs6 from "fs-extra";
+import path6 from "path";
+import chalk6 from "chalk";
+import prompts2 from "prompts";
 
-// src/utils/dependency-checker.ts
-import fs3 from "fs-extra";
-import path2 from "path";
-import chalk2 from "chalk";
-async function checkProjectDependencies(requiredDeps) {
-  const packageJsonPath = path2.join(process.cwd(), "package.json");
-  if (!await fs3.pathExists(packageJsonPath)) {
-    return {
-      installed: [],
-      missing: requiredDeps,
-      workspace: []
-    };
-  }
-  try {
-    const packageJson = await fs3.readJson(packageJsonPath);
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    const installed = [];
-    const missing = [];
-    const workspace = [];
-    for (const dep of requiredDeps) {
-      const version = allDeps[dep];
-      if (!version) {
-        missing.push(dep);
-      } else if (version.startsWith("workspace:")) {
-        workspace.push(dep);
-      } else {
-        installed.push(dep);
-      }
-    }
-    return { installed, missing, workspace };
-  } catch (error) {
-    return {
-      installed: [],
-      missing: requiredDeps,
-      workspace: []
-    };
-  }
-}
-function showDependencyStatus(deps) {
-  if (deps.installed.length > 0) {
-    console.log(chalk2.green(`   \u2705 Already installed: ${deps.installed.join(", ")}`));
-  }
-  if (deps.workspace.length > 0) {
-    console.log(chalk2.blue(`   \u{1F517} Workspace dependencies: ${deps.workspace.join(", ")}`));
-  }
-  if (deps.missing.length > 0) {
-    console.log(chalk2.yellow(`   \u{1F4E6} Will install: ${deps.missing.join(", ")}`));
-  }
-}
-async function filterMissingDependencies(dependencies) {
-  const status = await checkProjectDependencies(dependencies);
-  return status.missing;
-}
-function isWorkspaceError(errorMessage) {
-  return errorMessage.includes("EUNSUPPORTEDPROTOCOL") || errorMessage.includes("workspace:") || errorMessage.includes('Unsupported URL Type "workspace:"');
-}
+// src/commands/init.ts
+import chalk5 from "chalk";
+import prompts from "prompts";
+import ora3 from "ora";
 
 // src/utils/cli-messages.ts
 var CLI_MESSAGES = {
@@ -599,14 +568,17 @@ var CLI_MESSAGES = {
     noCDNFound: (registryType) => `No working ${registryType} CDN found`,
     componentNotFound: (name, registryType) => `Component "${name}" not found in ${registryType} registry`,
     unknownComponentType: (type) => `Unknown component type: ${type}`,
-    fileNotFound: (path7) => `File not found: ${path7}`,
+    fileNotFound: (path13) => `File not found: ${path13}`,
     invalidConfig: "Invalid ui8kit.config.json:",
     failedToInstall: (name, registryType) => `Failed to install ${name} from ${registryType}`,
     failedToFetch: (registryType) => `Failed to fetch components from ${registryType}`,
     failedToFetchComponent: (name, registryType) => `Failed to fetch ${name} from ${registryType}:`,
-    failedToAnalyzeDeps: (path7) => `Warning: Could not analyze dependencies for ${path7}:`,
+    failedToAnalyzeDeps: (path13) => `Warning: Could not analyze dependencies for ${path13}:`,
     dependenciesFailed: "Failed to install dependencies",
-    couldNotInstallDeps: (name) => `Warning: Could not install some dependencies for ${name}`
+    couldNotInstallDeps: (name) => `Warning: Could not install some dependencies for ${name}`,
+    noLocalInstall: "No installed local components were found in this project.",
+    invalidRegistryForDiff: "Could not load registry data for diff check.",
+    cacheClearFailed: "Could not clear cache."
   },
   // Success messages
   success: {
@@ -619,14 +591,16 @@ var CLI_MESSAGES = {
     registryBuilt: "Registry built successfully!",
     schemasGenerated: "Schema files generated successfully!",
     registryGenerated: (registryName) => `${registryName} registry generated successfully!`,
-    depsAvailable: "All dependencies already available"
+    depsAvailable: "All dependencies already available",
+    cacheCleared: "UI8Kit cache cleared successfully."
   },
   // Info messages
   info: {
+    tryListComponents: (registryType) => `Run "npx ui8kit@latest add --all --registry ${registryType}" to list available components`,
     initializing: (registryName) => `Initializing UI8Kit in your project (${registryName} registry)...`,
     installing: (registryName) => `Installing from ${registryName} registry...`,
     installingAll: (registryName) => `Installing all available components from ${registryName} registry...`,
-    retryEnabled: "Retry mode enabled - using enhanced connection logic",
+    retryEnabled: "Aggressive retry mode enabled (3 attempts per request)",
     fetchingComponentList: (registryType) => `Fetching component list from ${registryType}...`,
     fetchingRegistry: (registryType) => `Fetching ${registryType} registry index`,
     scanningComponents: (registryName) => `Scanning ${registryName} components...`,
@@ -641,12 +615,16 @@ var CLI_MESSAGES = {
     using: (registryType, baseUrl) => `Using ${registryType} CDN: ${baseUrl}`,
     loading: (name, registryType, folder, type) => `Loading ${name} from /${registryType}/${folder}/ (type: ${type})`,
     fetching: (registryType, url) => `Fetching from ${registryType}: ${url}`,
+    listingComponents: "Listing available components",
     fetchingUrl: "Fetching component from:",
-    fetchingUrlWithRetry: "Fetching component from URL with retry:"
+    fetchingUrlWithRetry: "Fetching component from URL with retry:",
+    checkingForUpdates: "Checking for component updates...",
+    localDiffSummary: "Local components compared with registry."
   },
   // Prompts
   prompts: {
-    typescript: "Are you using TypeScript?",
+    globalCss: "Where is your global CSS file?",
+    aliasComponents: "Configure import aliases?",
     overwrite: (registryName) => `UI8Kit is already initialized for ${registryName} registry. Overwrite configuration?`
   },
   // Examples and help text
@@ -694,235 +672,82 @@ var CLI_MESSAGES = {
   }
 };
 
-// src/commands/add.ts
-async function addCommand(components, options) {
-  const registryType = resolveRegistryType(options.registry);
-  if (options.all || components.includes("all")) {
-    return await addAllComponents(options, registryType);
-  }
-  if (components.length === 0) {
-    console.error(chalk3.red(`\u274C ${CLI_MESSAGES.errors.noComponentsSpecified}`));
-    CLI_MESSAGES.examples.add.forEach((example) => console.log(example));
-    process.exit(1);
-  }
-  const validation = await validateComponentInstallation(components, registryType);
-  if (!validation.isValid) {
-    handleValidationError(validation);
-  }
-  const config = await findConfig(registryType);
-  if (!config) {
-    console.error(chalk3.red(`\u274C ${CLI_MESSAGES.errors.notInitialized}`));
-    console.log(`Run 'npx ui8kit@latest init' first.`);
-    console.log(`For ${registryType} registry, run: npx ui8kit@latest init --registry ${registryType}`);
-    process.exit(1);
-  }
-  const getComponentFn = options.retry ? getComponentWithRetry : getComponent;
-  if (options.retry) {
-    console.log(chalk3.blue(`\u{1F504} ${CLI_MESSAGES.info.retryEnabled}`));
-  }
-  console.log(chalk3.blue(`\u{1F4E6} ${CLI_MESSAGES.info.installing(registryType)}`));
-  const results = await processComponents(components, registryType, config, getComponentFn, options);
-  displayInstallationSummary(registryType, results);
-}
-async function addAllComponents(options, registryType) {
-  console.log(chalk3.blue(`\u{1F680} ${CLI_MESSAGES.info.installingAll(registryType)}`));
-  const config = await findConfig(registryType);
-  if (!config) {
-    console.error(chalk3.red(`\u274C ${CLI_MESSAGES.errors.notInitialized}`));
-    console.log(`Run 'npx ui8kit@latest init' first.`);
-    console.log(`For ${registryType} registry, run: npx ui8kit@latest init --registry ${registryType}`);
-    process.exit(1);
-  }
-  const getAllComponentsFn = options.retry ? getAllComponentsWithRetry : getAllComponents;
-  if (options.retry) {
-    console.log(chalk3.blue(`\u{1F504} ${CLI_MESSAGES.info.retryEnabled}`));
+// src/utils/package-manager.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import path4 from "path";
+import fs4 from "fs-extra";
+import { execa } from "execa";
+
+// src/utils/dependency-checker.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import chalk2 from "chalk";
+async function checkProjectDependencies(requiredDeps) {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (!await fs3.pathExists(packageJsonPath)) {
+    return {
+      installed: [],
+      missing: requiredDeps,
+      workspace: []
+    };
   }
-  const spinner = ora(CLI_MESSAGES.info.fetchingComponentList(registryType)).start();
   try {
-    const allComponents = await getAllComponentsFn(registryType);
-    if (allComponents.length === 0) {
-      spinner.fail(`No components found in ${registryType} registry`);
-      console.log(chalk3.yellow(`
-\u26A0\uFE0F  ${registryType} ${CLI_MESSAGES.errors.registryTempUnavailable}`));
-      console.log("Try these alternatives:");
-      CLI_MESSAGES.examples.troubleshooting.forEach((alt) => console.log(`  \u2022 ${alt}`));
-      return;
-    }
-    spinner.succeed(CLI_MESSAGES.status.foundComponents(allComponents.length, registryType));
-    if (options.dryRun) {
-      console.log(chalk3.blue(`
-\u{1F4CB} ${CLI_MESSAGES.status.wouldInstallFrom(registryType)}`));
-      allComponents.forEach((comp) => {
-        console.log(`   - ${comp.name} (${comp.type})`);
-      });
-      return;
-    }
-    const results = await processComponents(
-      allComponents.map((c) => c.name),
-      registryType,
-      config,
-      options.retry ? getComponentWithRetry : getComponent,
-      options,
-      allComponents
-    );
-    await installComponentsIndex(registryType, config);
-    displayInstallationSummary(registryType, results);
-  } catch (error) {
-    spinner.fail(CLI_MESSAGES.errors.failedToFetch(registryType));
-    console.error(chalk3.red("\u274C Error:"), error.message);
-    console.log(chalk3.yellow(`
-\u26A0\uFE0F  ${registryType} ${CLI_MESSAGES.errors.registryTempUnavailable}`));
-    console.log("Try these alternatives:");
-    CLI_MESSAGES.examples.troubleshooting.forEach((alt) => console.log(`  \u2022 ${alt}`));
-    process.exit(1);
-  }
-}
-async function processComponents(componentNames, registryType, config, getComponentFn, options, preloadedComponents) {
-  const results = [];
-  const componentMap = new Map(preloadedComponents?.map((c) => [c.name, c]));
-  for (const componentName of componentNames) {
-    const spinner = ora(CLI_MESSAGES.status.installing(componentName, registryType)).start();
-    try {
-      let component = componentMap?.get(componentName);
-      if (!component) {
-        component = await getComponentFn(componentName, registryType);
-      }
-      if (!component) {
-        throw new Error(CLI_MESSAGES.errors.componentNotFound(componentName, registryType));
-      }
-      if (options.dryRun) {
-        spinner.succeed(CLI_MESSAGES.status.wouldInstall(component.name, registryType));
-        console.log(`   Type: ${component.type}`);
-        console.log(`   Files: ${component.files.length}`);
-        console.log(`   Dependencies: ${component.dependencies.join(", ") || "none"}`);
-        if (component.dependencies.length > 0) {
-          const depStatus = await checkProjectDependencies(component.dependencies);
-          showDependencyStatus(depStatus);
-        }
-        continue;
-      }
-      await installComponentFiles(component, config, options.force);
-      if (component.dependencies.length > 0) {
-        try {
-          await installDependencies(component.dependencies);
-        } catch (error) {
-          console.log(chalk3.yellow(`   \u26A0\uFE0F  ${CLI_MESSAGES.errors.couldNotInstallDeps(component.name)}`));
-          console.log(chalk3.yellow(`   Dependencies: ${component.dependencies.join(", ")}`));
-          console.log(chalk3.yellow(`   Please install them manually if needed`));
-        }
+    const packageJson = await fs3.readJson(packageJsonPath);
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    const installed = [];
+    const missing = [];
+    const workspace = [];
+    for (const dep of requiredDeps) {
+      const version = allDeps[dep];
+      if (!version) {
+        missing.push(dep);
+      } else if (version.startsWith("workspace:")) {
+        workspace.push(dep);
+      } else {
+        installed.push(dep);
       }
-      spinner.succeed(CLI_MESSAGES.status.installing(component.name, registryType));
-      results.push({ name: component.name, status: "success" });
-    } catch (error) {
-      spinner.fail(CLI_MESSAGES.errors.failedToInstall(componentName, registryType));
-      console.error(chalk3.red(`   Error: ${error.message}`));
-      results.push({
-        name: componentName,
-        status: "error",
-        error: error.message
-      });
     }
-  }
-  return results;
-}
-function displayInstallationSummary(registryType, results) {
-  const successful = results.filter((r) => r.status === "success");
-  const failed = results.filter((r) => r.status === "error");
-  console.log(chalk3.blue("\n\u{1F4CA} Installation Summary:"));
-  console.log(`   Registry: ${registryType}`);
-  console.log(`   \u2705 Successful: ${successful.length}`);
-  console.log(`   \u274C Failed: ${failed.length}`);
-  if (successful.length > 0) {
-    console.log(chalk3.green(`
-\u{1F389} ${CLI_MESSAGES.success.componentsInstalled}`));
-    console.log("You can now import and use them in your project.");
-  }
-  if (failed.length > 0) {
-    process.exit(1);
-  }
-}
-async function installComponentFiles(component, config, force = false) {
-  for (const file of component.files) {
-    const fileName = path3.basename(file.path);
-    const target = file.target || inferTargetFromType(component.type);
-    const installDir = resolveInstallDir(target, config);
-    const targetPath = path3.join(process.cwd(), installDir, fileName);
-    if (!force && await fs4.pathExists(targetPath)) {
-      console.log(`   \u26A0\uFE0F  ${CLI_MESSAGES.status.skipped(fileName)}`);
-      continue;
-    }
-    await fs4.ensureDir(path3.dirname(targetPath));
-    await fs4.writeFile(targetPath, file.content, "utf-8");
-  }
-}
-function inferTargetFromType(componentType) {
-  switch (componentType) {
-    case "registry:ui":
-      return "ui";
-    case "registry:composite":
-      return "components";
-    case "registry:block":
-      return "blocks";
-    case "registry:component":
-      return "components";
-    case "registry:layout":
-      return "layouts";
-    case "registry:lib":
-      return "lib";
-    case "registry:variants":
-      return "variants";
-    default:
-      return "components";
+    return { installed, missing, workspace };
+  } catch (error) {
+    return {
+      installed: [],
+      missing: requiredDeps,
+      workspace: []
+    };
   }
 }
-function resolveInstallDir(target, config) {
-  const normalizedTarget = target.replace(/\\/g, "/").replace(/^\/?src\//i, "");
-  if (normalizedTarget === "lib") {
-    return normalizeDir(config.libDir || SCHEMA_CONFIG.defaultDirectories.lib);
-  }
-  if (normalizedTarget === "variants") {
-    return normalizeDir(SCHEMA_CONFIG.defaultDirectories.variants);
+function showDependencyStatus(deps) {
+  if (deps.installed.length > 0) {
+    console.log(chalk2.green(`   \u2705 Already installed: ${deps.installed.join(", ")}`));
   }
-  const baseComponentsDir = normalizeDir(config.componentsDir || SCHEMA_CONFIG.defaultDirectories.components);
-  if (normalizedTarget.includes("/")) {
-    const parentRoot = baseComponentsDir.replace(/[/\\]components$/i, "") || "src";
-    return path3.join(parentRoot, normalizedTarget).replace(/\\/g, "/");
+  if (deps.workspace.length > 0) {
+    console.log(chalk2.blue(`   \u{1F517} Workspace dependencies: ${deps.workspace.join(", ")}`));
   }
-  if (normalizedTarget === "ui")
-    return path3.join(baseComponentsDir, "ui").replace(/\\/g, "/");
-  if (normalizedTarget === "components")
-    return baseComponentsDir;
-  switch (normalizedTarget) {
-    case "blocks":
-      return normalizeDir(SCHEMA_CONFIG.defaultDirectories.blocks);
-    case "layouts":
-      return normalizeDir(SCHEMA_CONFIG.defaultDirectories.layouts);
-    default:
-      return baseComponentsDir;
+  if (deps.missing.length > 0) {
+    console.log(chalk2.yellow(`   \u{1F4E6} Will install: ${deps.missing.join(", ")}`));
   }
 }
-function normalizeDir(dir) {
-  return dir.replace(/^\.\//, "").replace(/\\/g, "/");
+async function filterMissingDependencies(dependencies) {
+  const status = await checkProjectDependencies(dependencies);
+  return status.missing;
 }
-function resolveRegistryType(registryInput) {
-  if (!registryInput) {
-    return SCHEMA_CONFIG.defaultRegistryType;
-  }
-  if (SCHEMA_CONFIG.registryTypes.includes(registryInput)) {
-    return registryInput;
-  }
-  console.warn(chalk3.yellow(`\u26A0\uFE0F  Unknown registry type: ${registryInput}`));
-  console.log(`Available registries: ${SCHEMA_CONFIG.registryTypes.join(", ")}`);
-  console.log(`Using default: ${SCHEMA_CONFIG.defaultRegistryType}`);
-  return SCHEMA_CONFIG.defaultRegistryType;
+function isWorkspaceError(errorMessage) {
+  return errorMessage.includes("EUNSUPPORTEDPROTOCOL") || errorMessage.includes("workspace:") || errorMessage.includes('Unsupported URL Type "workspace:"');
 }
-async function installDependencies(dependencies) {
-  const spinner = ora(CLI_MESSAGES.status.installing("dependencies", "")).start();
+
+// src/utils/package-manager.ts
+async function installDependencies(dependencies, options = {}) {
+  const useSpinner = options.useSpinner ?? true;
+  const spinner = useSpinner ? ora2(options.spinnerText ?? CLI_MESSAGES.status.installing("dependencies", "")).start() : null;
   try {
     const depStatus = await checkProjectDependencies(dependencies);
     const missingDependencies = await filterMissingDependencies(dependencies);
     if (missingDependencies.length === 0) {
-      spinner.succeed(CLI_MESSAGES.success.depsAvailable);
+      spinner?.succeed(CLI_MESSAGES.success.depsAvailable);
       if (depStatus.workspace.length > 0) {
         console.log(chalk3.blue(`   \u{1F517} Using workspace dependencies: ${depStatus.workspace.join(", ")}`));
       }
@@ -935,15 +760,15 @@ async function installDependencies(dependencies) {
       cwd: process.cwd(),
       stdio: "pipe"
     });
-    spinner.succeed(CLI_MESSAGES.success.depsInstalled);
+    spinner?.succeed(CLI_MESSAGES.success.depsInstalled);
   } catch (error) {
-    spinner.fail(CLI_MESSAGES.errors.dependenciesFailed);
+    spinner?.fail(CLI_MESSAGES.errors.dependenciesFailed);
     const errorMessage = error.stderr || error.message;
     if (isWorkspaceError(errorMessage)) {
       console.log(chalk3.yellow(`
 \u{1F4A1} ${CLI_MESSAGES.info.workspaceDepsDetected}`));
       const results = await installDependenciesIndividually(dependencies);
-      if (results.some((r) => r.success)) {
+      if (results.some((result) => result.success)) {
         console.log(chalk3.green("\u2705 Some dependencies installed successfully"));
         return;
       }
@@ -964,7 +789,7 @@ async function installDependenciesIndividually(dependencies) {
       });
       console.log(chalk3.green(`   \u2705 Installed ${dep}`));
       results.push({ dep, success: true });
-    } catch (error) {
+    } catch {
       console.log(chalk3.yellow(`   \u26A0\uFE0F  Skipped ${dep} (may already be available)`));
       results.push({ dep, success: false });
     }
@@ -974,14 +799,14 @@ async function installDependenciesIndividually(dependencies) {
 async function detectPackageManager() {
   let dir = process.cwd();
   while (true) {
-    if (await fs4.pathExists(path3.join(dir, "bun.lock")) || await fs4.pathExists(path3.join(dir, "bun.lockb"))) {
+    if (await fs4.pathExists(path4.join(dir, "bun.lock")) || await fs4.pathExists(path4.join(dir, "bun.lockb"))) {
       return "bun";
     }
-    if (await fs4.pathExists(path3.join(dir, "pnpm-lock.yaml")))
+    if (await fs4.pathExists(path4.join(dir, "pnpm-lock.yaml")))
       return "pnpm";
-    if (await fs4.pathExists(path3.join(dir, "yarn.lock")))
+    if (await fs4.pathExists(path4.join(dir, "yarn.lock")))
       return "yarn";
-    const packageJsonPath = path3.join(dir, "package.json");
+    const packageJsonPath = path4.join(dir, "package.json");
     if (await fs4.pathExists(packageJsonPath)) {
       try {
         const packageJson = await fs4.readJson(packageJsonPath);
@@ -997,66 +822,107 @@ async function detectPackageManager() {
       } catch {
       }
     }
-    const parent = path3.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
   return "npm";
 }
-async function installComponentsIndex(registryType, config) {
-  const spinner = ora("Installing components index...").start();
-  try {
-    const cdnUrls = SCHEMA_CONFIG.cdnBaseUrls;
-    for (const baseUrl of cdnUrls) {
-      try {
-        const url = `${baseUrl}/components/index.json`;
-        const response = await fetch3(url);
-        if (response.ok) {
-          const component = await response.json();
-          for (const file of component.files) {
-            const fileName = path3.basename(file.path);
-            const targetDir = config.componentsDir;
-            const targetPath = path3.join(process.cwd(), targetDir, fileName);
-            await fs4.ensureDir(path3.dirname(targetPath));
-            await fs4.writeFile(targetPath, file.content || "", "utf-8");
-          }
-          spinner.succeed("Installed components index");
-          return;
-        }
-      } catch {
-        continue;
-      }
+
+// src/commands/init.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import fetch2 from "node-fetch";
+
+// src/utils/errors.ts
+import chalk4 from "chalk";
+var Ui8kitError = class extends Error {
+  suggestion;
+  constructor(message, suggestion) {
+    super(message);
+    this.name = this.constructor.name;
+    this.suggestion = suggestion;
+  }
+};
+var ConfigNotFoundError = class extends Ui8kitError {
+  constructor(registry) {
+    super(
+      `ui8kit config not found for registry "${registry}".`,
+      `Run: npx ui8kit@latest init --registry ${registry}`
+    );
+  }
+};
+function handleError(error) {
+  if (error instanceof Ui8kitError) {
+    if (error.message) {
+      console.error(chalk4.red(error.message));
     }
-    spinner.info("Components index not found in registry (optional)");
-  } catch (error) {
-    spinner.fail("Could not install components index");
+    if (error.suggestion) {
+      console.log(chalk4.yellow(`\u{1F4A1} ${error.suggestion}`));
+    }
+    process.exit(1);
   }
+  if (isZodError(error)) {
+    console.error(chalk4.red("\u274C Configuration validation error:"));
+    error.errors.forEach((issue) => {
+      const path13 = issue.path.join(".") || "root";
+      console.log(chalk4.yellow(`  - ${path13}: ${issue.message}`));
+    });
+    process.exit(1);
+  }
+  console.error(chalk4.red("\u274C Unexpected error:"));
+  console.error(chalk4.red(error.message ?? String(error)));
+  process.exit(1);
+}
+function isZodError(error) {
+  return Boolean(error && typeof error === "object" && "issues" in error);
 }
 
 // src/commands/init.ts
-import chalk4 from "chalk";
-import prompts from "prompts";
-import ora2 from "ora";
-import path4 from "path";
-import fs5 from "fs-extra";
-import fetch4 from "node-fetch";
+function buildInitConfig(options) {
+  const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
+  const aliases = SCHEMA_CONFIG.defaultAliases;
+  const globalCss = options.globalCss || "src/index.css";
+  const aliasComponents = options.aliasComponents?.trim() || "@/components";
+  if (options.yes) {
+    return {
+      $schema: `${SCHEMA_CONFIG.baseUrl}.json`,
+      framework: "vite-react",
+      typescript: true,
+      globalCss,
+      aliases,
+      registry: SCHEMA_CONFIG.defaultRegistry,
+      componentsDir: SCHEMA_CONFIG.defaultDirectories.components,
+      libDir: SCHEMA_CONFIG.defaultDirectories.lib
+    };
+  }
+  return {
+    $schema: `${SCHEMA_CONFIG.baseUrl}.json`,
+    framework: "vite-react",
+    typescript: true,
+    globalCss,
+    aliases: { ...aliases, "@/components": aliasComponents },
+    registry: SCHEMA_CONFIG.defaultRegistry,
+    componentsDir: SCHEMA_CONFIG.defaultDirectories.components,
+    libDir: SCHEMA_CONFIG.defaultDirectories.lib
+  };
+}
 async function initCommand(options) {
   const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
-  const registryPath = `./${registryName}`;
-  console.log(chalk4.blue(`\u{1F680} ${CLI_MESSAGES.info.initializing(registryName)}`));
+  logger.info(CLI_MESSAGES.info.initializing(registryName));
   const viteDetected = await isViteProject();
   if (!viteDetected) {
-    console.error(chalk4.red(`\u274C ${CLI_MESSAGES.errors.notViteProject}`));
+    console.error(chalk5.red(`\u274C ${CLI_MESSAGES.errors.notViteProject}`));
     console.log("Please run this command in a Vite project directory.");
     process.exit(1);
   }
   if (!await hasReact()) {
-    console.error(chalk4.red(`\u274C ${CLI_MESSAGES.errors.reactNotInstalled}`));
+    console.error(chalk5.red(`\u274C ${CLI_MESSAGES.errors.reactNotInstalled}`));
     console.log("Please install React first: npm install react react-dom");
     process.exit(1);
   }
-  const existingConfig = await getConfig("./src");
+  const existingConfig = await findConfig(registryName);
   if (existingConfig && !options.yes) {
     const { overwrite } = await prompts({
       type: "confirm",
@@ -1065,68 +931,67 @@ async function initCommand(options) {
       initial: false
     });
     if (!overwrite) {
-      console.log(chalk4.yellow(`\u26A0\uFE0F  ${CLI_MESSAGES.info.installationCancelled}`));
+      logger.warn(CLI_MESSAGES.info.installationCancelled);
       return;
     }
   }
-  const aliases = SCHEMA_CONFIG.defaultAliases;
   let config;
   if (options.yes) {
-    config = {
-      $schema: `${SCHEMA_CONFIG.baseUrl}.json`,
-      framework: "vite-react",
-      typescript: true,
-      aliases,
-      registry: SCHEMA_CONFIG.defaultRegistry,
-      componentsDir: SCHEMA_CONFIG.defaultDirectories.components,
-      libDir: SCHEMA_CONFIG.defaultDirectories.lib
-    };
+    config = buildInitConfig({ yes: true, registry: registryName });
   } else {
     const responses = await prompts([
       {
-        type: "confirm",
-        name: "typescript",
-        message: CLI_MESSAGES.prompts.typescript,
-        initial: true
+        type: "text",
+        name: "globalCss",
+        message: CLI_MESSAGES.prompts.globalCss,
+        initial: "src/index.css"
+      },
+      {
+        type: "text",
+        name: "aliasComponents",
+        message: CLI_MESSAGES.prompts.aliasComponents,
+        initial: "@/components"
       }
     ]);
-    config = {
-      $schema: `${SCHEMA_CONFIG.baseUrl}.json`,
-      framework: "vite-react",
-      typescript: responses.typescript,
-      aliases,
-      registry: SCHEMA_CONFIG.defaultRegistry,
-      componentsDir: SCHEMA_CONFIG.defaultDirectories.components,
-      libDir: SCHEMA_CONFIG.defaultDirectories.lib
-    };
+    const aliasComponents = responses.aliasComponents?.trim() || "@/components";
+    const globalCss = responses.globalCss || "src/index.css";
+    config = buildInitConfig({
+      yes: false,
+      registry: registryName,
+      globalCss,
+      aliasComponents
+    });
   }
-  const spinner = ora2(CLI_MESSAGES.info.initializing(registryName)).start();
+  const spinner = ora3(CLI_MESSAGES.info.initializing(registryName)).start();
   try {
-    await saveConfig(config, "./src");
+    await saveConfig(config);
     await ensureDir(config.libDir);
     await ensureDir(config.componentsDir);
-    await ensureDir(path4.join(config.componentsDir, "ui"));
+    await ensureDir(path5.join(config.componentsDir, "ui"));
     await ensureDir(SCHEMA_CONFIG.defaultDirectories.blocks);
     await ensureDir(SCHEMA_CONFIG.defaultDirectories.layouts);
     await ensureDir(SCHEMA_CONFIG.defaultDirectories.variants);
     spinner.text = "Installing core utilities and variants...";
     await installCoreFiles(registryName, config, spinner);
+    spinner.text = "Installing core dependencies...";
+    await installDependencies(["clsx", "tailwind-merge"], {
+      useSpinner: false
+    });
     spinner.succeed(CLI_MESSAGES.success.initialized(registryName));
-    console.log(chalk4.green(`
-\u2705 ${CLI_MESSAGES.success.setupComplete(registryName)}`));
+    logger.success(`
+\u2705 ${CLI_MESSAGES.success.setupComplete(registryName)}`);
     console.log("\nDirectories created:");
-    console.log(`  ${chalk4.cyan("src/lib/")} - Utils, helpers, functions`);
-    console.log(`  ${chalk4.cyan("src/variants/")} - CVA variant configurations`);
-    console.log(`  ${chalk4.cyan("src/components/ui/")} - UI components`);
-    console.log(`  ${chalk4.cyan("src/components/")} - Complex components`);
-    console.log(`  ${chalk4.cyan("src/layouts/")} - Page layouts and structures`);
-    console.log(`  ${chalk4.cyan("src/blocks/")} - Component blocks`);
+    console.log(`  ${chalk5.cyan("src/lib/")} - Utils, helpers, functions`);
+    console.log(`  ${chalk5.cyan("src/variants/")} - CVA variant configurations`);
+    console.log(`  ${chalk5.cyan("src/components/ui/")} - UI components`);
+    console.log(`  ${chalk5.cyan("src/components/")} - Complex components`);
+    console.log(`  ${chalk5.cyan("src/layouts/")} - Page layouts and structures`);
+    console.log(`  ${chalk5.cyan("src/blocks/")} - Component blocks`);
     console.log("\nNext steps:");
-    CLI_MESSAGES.examples.init.forEach((example) => console.log(`  ${chalk4.cyan(example)}`));
+    CLI_MESSAGES.examples.init.forEach((example) => console.log(`  ${chalk5.cyan(example)}`));
   } catch (error) {
     spinner.fail(CLI_MESSAGES.errors.buildFailed);
-    console.error(chalk4.red("\u274C Error:"), error.message);
-    process.exit(1);
+    handleError(error);
   }
 }
 async function installCoreFiles(registryType, config, spinner) {
@@ -1135,7 +1000,7 @@ async function installCoreFiles(registryType, config, spinner) {
   for (const baseUrl of cdnUrls) {
     try {
       const indexUrl = `${baseUrl}/index.json`;
-      const response = await fetch4(indexUrl);
+      const response = await fetch2(indexUrl);
       if (response.ok) {
         registryIndex = await response.json();
         break;
@@ -1149,87 +1014,796 @@ async function installCoreFiles(registryType, config, spinner) {
     await createUtilsFile(config.libDir, config.typescript);
     return;
   }
-  const variantItems = registryIndex.components.filter((c) => c.type === "registry:variants");
-  const libItems = registryIndex.components.filter((c) => c.type === "registry:lib");
-  for (const item of libItems) {
-    spinner.text = `Installing ${item.name}...`;
-    await installComponentFromRegistry(item.name, "registry:lib", cdnUrls, config);
+  const variantItems = registryIndex.components.filter((c) => c.type === "registry:variants");
+  const libItems = registryIndex.components.filter((c) => c.type === "registry:lib");
+  for (const item of libItems) {
+    spinner.text = `Installing ${item.name}...`;
+    await installComponentFromRegistry(item.name, "registry:lib", cdnUrls, config);
+  }
+  for (const item of variantItems) {
+    spinner.text = `Installing variant: ${item.name}...`;
+    await installComponentFromRegistry(item.name, "registry:variants", cdnUrls, config);
+  }
+  spinner.text = "Syncing variants index...";
+  const variantsIndexStatus = await installVariantsIndex(cdnUrls);
+  if (variantsIndexStatus === "updated") {
+    spinner.text = "Updated variants/index.ts from CDN";
+  } else if (variantsIndexStatus === "created") {
+    spinner.text = "Created variants/index.ts from CDN";
+  } else if (variantsIndexStatus === "unchanged") {
+    spinner.text = "variants/index.ts is up to date";
+  } else {
+    spinner.text = "variants/index.ts not found in registry (skipped)";
+  }
+  spinner.text = `\u2705 Installed ${libItems.length} utilities and ${variantItems.length} variants`;
+}
+async function installComponentFromRegistry(name, type, cdnUrls, config) {
+  const folder = type === "registry:lib" ? "lib" : type === "registry:variants" ? "components/variants" : "components/ui";
+  for (const baseUrl of cdnUrls) {
+    try {
+      const url = `${baseUrl}/${folder}/${name}.json`;
+      const response = await fetch2(url);
+      if (response.ok) {
+        const component = await response.json();
+        for (const file of component.files) {
+          const fileName = path5.basename(file.path);
+          let targetDir;
+          if (type === "registry:lib") {
+            targetDir = config.libDir;
+          } else if (type === "registry:variants") {
+            targetDir = SCHEMA_CONFIG.defaultDirectories.variants;
+          } else {
+            targetDir = path5.join(config.componentsDir, "ui");
+          }
+          const targetPath = path5.join(process.cwd(), targetDir, fileName);
+          await fs5.ensureDir(path5.dirname(targetPath));
+          await fs5.writeFile(targetPath, file.content || "", "utf-8");
+        }
+        return;
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+async function installVariantsIndex(cdnUrls) {
+  for (const baseUrl of cdnUrls) {
+    try {
+      const url = `${baseUrl}/components/variants/index.json`;
+      const response = await fetch2(url);
+      if (response.ok) {
+        const component = await response.json();
+        for (const file of component.files) {
+          const fileName = path5.basename(file.path);
+          if (!fileName.startsWith("index.")) {
+            continue;
+          }
+          const targetDir = SCHEMA_CONFIG.defaultDirectories.variants;
+          const targetPath = path5.join(process.cwd(), targetDir, fileName);
+          const incomingContent = file.content || "";
+          const exists = await fs5.pathExists(targetPath);
+          if (exists) {
+            const currentContent = await fs5.readFile(targetPath, "utf-8");
+            if (currentContent === incomingContent) {
+              return "unchanged";
+            }
+          }
+          await fs5.ensureDir(path5.dirname(targetPath));
+          await fs5.writeFile(targetPath, incomingContent, "utf-8");
+          return exists ? "updated" : "created";
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "skipped";
+}
+async function createUtilsFile(libDir, typescript) {
+  const utilsContent = `import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}`;
+  const fileName = typescript ? "utils.ts" : "utils.js";
+  const filePath = path5.join(process.cwd(), libDir, fileName);
+  await fs5.writeFile(filePath, utilsContent, "utf-8");
+}
+
+// src/utils/registry-validator.ts
+async function validateComponentInstallation(components, registryType) {
+  const packageJsonPath = path6.join(process.cwd(), "package.json");
+  if (!await fs6.pathExists(packageJsonPath)) {
+    return {
+      isValid: false,
+      message: "No package.json found in the current directory. Run this command from your project root."
+    };
+  }
+  const nodeMajorVersion = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  if (Number.isNaN(nodeMajorVersion) || nodeMajorVersion < 18) {
+    return {
+      isValid: false,
+      message: `Node.js 18+ is required. Current version: ${process.versions.node}`
+    };
+  }
+  const existingConfig = await findConfig(registryType);
+  if (!existingConfig) {
+    const { runInit } = await prompts2({
+      type: "confirm",
+      name: "runInit",
+      message: "ui8kit.config.json not found. Run init now?",
+      initial: true
+    });
+    if (runInit) {
+      await initCommand({ registry: registryType });
+      const configAfterInit = await findConfig(registryType);
+      if (configAfterInit) {
+        return { isValid: true };
+      }
+    }
+    return {
+      isValid: false,
+      message: `ui8kit is not initialized. Run: npx ui8kit@latest init --registry ${registryType}`
+    };
+  }
+  return { isValid: true };
+}
+function handleValidationError(result) {
+  console.error(chalk6.red("\u274C Registry Validation Error:"));
+  console.error(chalk6.red(result.message));
+  if (result.missingComponents && result.missingComponents.length > 0) {
+    console.log(chalk6.yellow("\n\u{1F4A1} Suggestion:"));
+    console.log(`Install missing components first: ${chalk6.cyan(`npx ui8kit add ${result.missingComponents.join(" ")}`)}
+`);
+  }
+  process.exit(1);
+}
+
+// src/utils/dependency-resolver.ts
+async function resolveRegistryTree(componentNames, registryType, getComponent2) {
+  const componentsByName = /* @__PURE__ */ new Map();
+  const state = /* @__PURE__ */ new Map();
+  const visitStack = [];
+  const normalized = componentNames.map((name) => name.toLowerCase());
+  const ensureComponent = async (name) => {
+    const key = name.toLowerCase();
+    if (state.get(key) === "done") {
+      return componentsByName.get(key) ?? null;
+    }
+    if (state.get(key) === "visiting") {
+      const cycle = visitStack.includes(key) ? [...visitStack, key].join(" -> ") : key;
+      logger.warn(`Circular registry dependency detected: ${cycle}`);
+      return componentsByName.get(key) ?? null;
+    }
+    const component = await getComponent2(name, registryType);
+    if (!component) {
+      logger.warn(`Component ${name} not found in ${registryType} registry, skipping`);
+      state.set(key, "done");
+      return null;
+    }
+    componentsByName.set(key, component);
+    state.set(key, "visiting");
+    visitStack.push(key);
+    for (const dependency of component.registryDependencies ?? []) {
+      await ensureComponent(dependency);
+    }
+    visitStack.pop();
+    state.set(key, "done");
+    return component;
+  };
+  for (const name of normalized) {
+    await ensureComponent(name);
+  }
+  const graph = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const component of componentsByName.values()) {
+    const name = component.name.toLowerCase();
+    if (!graph.has(name)) {
+      graph.set(name, /* @__PURE__ */ new Set());
+      inDegree.set(name, 0);
+    }
+  }
+  for (const component of componentsByName.values()) {
+    const from = component.name.toLowerCase();
+    const deps = component.registryDependencies ?? [];
+    for (const dep of deps) {
+      const to = dep.toLowerCase();
+      if (!componentsByName.has(to)) {
+        continue;
+      }
+      const targets = graph.get(to);
+      if (targets) {
+        targets.add(from);
+      } else {
+        graph.set(to, /* @__PURE__ */ new Set([from]));
+      }
+      inDegree.set(from, (inDegree.get(from) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  inDegree.forEach((value, name) => {
+    if (value === 0) {
+      queue.push(name);
+    }
+  });
+  const orderedKeys = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current)
+      continue;
+    orderedKeys.push(current);
+    const targets = graph.get(current) || /* @__PURE__ */ new Set();
+    for (const next of targets) {
+      const degree = (inDegree.get(next) ?? 1) - 1;
+      inDegree.set(next, degree);
+      if (degree === 0) {
+        queue.push(next);
+      }
+    }
+  }
+  for (const key of componentsByName.keys()) {
+    if (!orderedKeys.includes(key)) {
+      logger.warn(`Unresolved dependency cycle detected for ${key}, appending in current order`);
+      orderedKeys.push(key);
+    }
+  }
+  return orderedKeys.map((key) => componentsByName.get(key)).filter((component) => Boolean(component));
+}
+
+// src/utils/diff-utils.ts
+import { createTwoFilesPatch } from "diff";
+function buildUnifiedDiff(oldFilePath, newFilePath, oldContent, newContent) {
+  return createTwoFilesPatch(
+    oldFilePath,
+    newFilePath,
+    oldContent,
+    newContent,
+    "local",
+    "registry",
+    { context: 3 }
+  );
+}
+function hasDiff(oldContent, newContent) {
+  return oldContent !== newContent;
+}
+function formatDiffPreview(diff, maxLines = 80) {
+  const lines = diff.split("\n");
+  if (lines.length <= maxLines) {
+    return diff;
+  }
+  return `${lines.slice(0, maxLines).join("\n")}
+...`;
+}
+
+// src/utils/transform.ts
+import path7 from "path";
+import ts from "typescript";
+var IMPORT_NODE_KIND = ts.SyntaxKind.ImportDeclaration;
+function normalizeAliasKey(alias) {
+  return alias.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizeAliasTarget(alias) {
+  return toPosix(alias).replace(/\/+$/, "");
+}
+function normalizeDefaultAliases() {
+  const map = /* @__PURE__ */ new Map();
+  for (const [alias, target] of Object.entries(SCHEMA_CONFIG.defaultAliases)) {
+    map.set(normalizeAliasKey(alias), normalizeAliasTarget(target));
+  }
+  return map;
+}
+function normalizeConfiguredAliases(aliasMap) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [alias, target] of Object.entries(aliasMap)) {
+    normalized.set(normalizeAliasKey(alias), normalizeAliasTarget(target));
+  }
+  return normalized;
+}
+function pickAliasForImport(importPath, configuredAliases) {
+  const pathValue = toPosix(importPath);
+  if (!pathValue.startsWith("@/")) {
+    return void 0;
+  }
+  const trimmed = pathValue.slice(2);
+  const [root] = trimmed.split("/");
+  const rootAlias = `@/${root}`;
+  const directAlias = Array.from(configuredAliases.keys()).filter((alias) => pathValue === alias || pathValue.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length)[0];
+  if (directAlias) {
+    const aliasValue = configuredAliases.get(directAlias);
+    if (!aliasValue || !aliasValue.startsWith("@/")) {
+      return void 0;
+    }
+    const remainder = pathValue.slice(directAlias.length).replace(/^\/+/, "");
+    if (!remainder) {
+      return aliasValue;
+    }
+    const remainderParts = remainder.split("/");
+    const targetParts = normalizeAliasKey(aliasValue).replace(/^@\//, "").split("/");
+    const aliasTail = targetParts[targetParts.length - 1];
+    const normalizedRemainder = remainderParts[0] === aliasTail ? remainderParts.slice(1).join("/") : remainder;
+    return normalizedRemainder ? `${aliasValue}/${normalizedRemainder}` : aliasValue;
+  }
+  const defaultAliasCandidates = Array.from(normalizeDefaultAliases().keys()).filter((alias) => pathValue === alias || pathValue.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length);
+  for (const defaultAlias of defaultAliasCandidates) {
+    const defaultParts = normalizeAliasKey(defaultAlias).replace(/^@\//, "").split("/");
+    const remainderFromDefault = trimmed.split("/").slice(defaultParts.length);
+    if (remainderFromDefault.length === 0) {
+      continue;
+    }
+    const candidateAliasTail = remainderFromDefault[0];
+    const candidateAlias = `@/${candidateAliasTail}`;
+    if (configuredAliases.has(candidateAlias)) {
+      const remainderPath = remainderFromDefault.slice(1).join("/");
+      return remainderPath ? `${candidateAlias}/${remainderPath}` : candidateAlias;
+    }
+  }
+  return void 0;
+}
+function rewriteModuleSpecifier(specifierText, configuredAliases) {
+  if (!specifierText.startsWith("@/")) {
+    return specifierText;
+  }
+  const aliasesMap = normalizeConfiguredAliases(configuredAliases);
+  const rewrittenRemainder = pickAliasForImport(specifierText, aliasesMap);
+  if (!rewrittenRemainder || rewrittenRemainder === normalizeAliasKey(specifierText)) {
+    return specifierText;
+  }
+  if (rewrittenRemainder) {
+    return rewrittenRemainder;
+  }
+  return specifierText;
+}
+function transformImports(content, aliases) {
+  const sourceFile = ts.createSourceFile("component.tsx", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const importSpans = [];
+  const configuredAliases = normalizeConfiguredAliases(aliases);
+  function visit(node) {
+    if (node.kind === IMPORT_NODE_KIND && ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpecifier)) {
+        const value = moduleSpecifier.text;
+        const rewritten = rewriteModuleSpecifier(value, Object.fromEntries(configuredAliases));
+        if (rewritten !== value) {
+          importSpans.push({
+            start: moduleSpecifier.getStart(sourceFile),
+            end: moduleSpecifier.getEnd(),
+            replacement: `"${rewritten}"`
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (importSpans.length === 0) {
+    return content;
+  }
+  importSpans.sort((a, b) => b.start - a.start);
+  let transformed = content;
+  for (const span of importSpans) {
+    transformed = `${transformed.slice(0, span.start)}${span.replacement}${transformed.slice(span.end)}`;
+  }
+  return transformed;
+}
+function transformCleanup(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function applyTransforms(content, aliases) {
+  const withImports = transformImports(content, aliases);
+  return transformCleanup(withImports);
+}
+function shouldTransformFile(fileName) {
+  return [".ts", ".tsx"].includes(path7.extname(fileName));
+}
+
+// src/commands/add.ts
+var ADD_EXCLUDED_COMPONENT_TYPES = ["registry:variants", "registry:lib"];
+async function addCommand(components, options) {
+  const registryType = resolveRegistryType(options.registry);
+  const requestOptions = {
+    excludeTypes: ADD_EXCLUDED_COMPONENT_TYPES,
+    maxRetries: options.retry ? 3 : 1,
+    noCache: options.cache === false
+  };
+  try {
+    if (options.all || components.includes("all")) {
+      await addAllComponents(options, registryType, requestOptions);
+      return;
+    }
+    const selectedComponents = components.length > 0 ? components : await pickComponentsFromPrompt(registryType, requestOptions);
+    if (selectedComponents.length === 0) {
+      logger.warn(CLI_MESSAGES.errors.noComponentsSpecified);
+      return;
+    }
+    const validation = await validateComponentInstallation(selectedComponents, registryType);
+    if (!validation.isValid) {
+      handleValidationError(validation);
+    }
+    const config = await findConfig(registryType);
+    if (!config) {
+      throw new ConfigNotFoundError(registryType);
+    }
+    if (options.retry) {
+      logger.info(CLI_MESSAGES.info.retryEnabled);
+    }
+    logger.info(CLI_MESSAGES.info.installing(registryType));
+    const getComponentFn = (name, type) => getComponent(name, type, requestOptions);
+    const results = await installRequestedComponents(
+      selectedComponents,
+      registryType,
+      config,
+      getComponentFn,
+      options
+    );
+    displayInstallationSummary(registryType, results);
+  } catch (error) {
+    handleError(error);
+  }
+}
+async function addAllComponents(options, registryType, requestOptions) {
+  logger.info(CLI_MESSAGES.info.installingAll(registryType));
+  const validation = await validateComponentInstallation([], registryType);
+  if (!validation.isValid) {
+    handleValidationError(validation);
+  }
+  const config = await findConfig(registryType);
+  if (!config) {
+    throw new ConfigNotFoundError(registryType);
+  }
+  const getAllComponentsFn = (type) => getAllComponents(type, requestOptions);
+  if (options.retry) {
+    logger.info(CLI_MESSAGES.info.retryEnabled);
+  }
+  const spinner = ora4(CLI_MESSAGES.info.fetchingComponentList(registryType)).start();
+  try {
+    const allComponents = await getAllComponentsFn(registryType);
+    if (allComponents.length === 0) {
+      spinner.fail(`No components found in ${registryType} registry`);
+      logger.warn(`
+\u26A0\uFE0F  ${registryType} ${CLI_MESSAGES.errors.registryTempUnavailable}`);
+      console.log("Try these alternatives:");
+      CLI_MESSAGES.examples.troubleshooting.forEach((alt) => console.log(`  \u2022 ${alt}`));
+      return;
+    }
+    spinner.succeed(CLI_MESSAGES.status.foundComponents(allComponents.length, registryType));
+    if (options.dryRun) {
+      await installRequestedComponents(
+        allComponents.map((c) => c.name),
+        registryType,
+        config,
+        (name, type) => getComponent(name, type, requestOptions),
+        options,
+        allComponents
+      );
+      return;
+    }
+    const results = await installRequestedComponents(
+      allComponents.map((c) => c.name),
+      registryType,
+      config,
+      (name, type) => getComponent(name, type, requestOptions),
+      options,
+      allComponents
+    );
+    await installComponentsIndex(registryType, config);
+    displayInstallationSummary(registryType, results);
+  } catch (error) {
+    spinner.fail(CLI_MESSAGES.errors.failedToFetch(registryType));
+    logger.error(`Error: ${error.message}`);
+    logger.warn(`
+\u26A0\uFE0F  ${registryType} ${CLI_MESSAGES.errors.registryTempUnavailable}`);
+    console.log("Try these alternatives:");
+    CLI_MESSAGES.examples.troubleshooting.forEach((alt) => console.log(`  \u2022 ${alt}`));
+    process.exit(1);
+  }
+}
+async function processComponents(componentNames, registryType, config, getComponentFn, options, preloadedComponents, totalCount) {
+  const results = [];
+  const componentMap = new Map(preloadedComponents?.map((c) => [c.name.toLowerCase(), c]));
+  const total = totalCount ?? componentNames.length;
+  if (total > 1) {
+    logger.info(`Installing ${total} components...`);
+  }
+  for (let i = 0; i < componentNames.length; i += 1) {
+    const componentName = componentNames[i];
+    const position = `${i + 1}/${total}`;
+    const spinner = ora4(`[${position}] ${CLI_MESSAGES.status.installing(componentName, registryType)}`).start();
+    try {
+      const lookupName = componentName.toLowerCase();
+      let component = componentMap?.get(lookupName) ?? null;
+      if (!component) {
+        component = await getComponentFn(componentName, registryType);
+      }
+      if (!component) {
+        throw new Error(CLI_MESSAGES.errors.componentNotFound(componentName, registryType));
+      }
+      if (options.dryRun) {
+        spinner.succeed(`[${position}] ${CLI_MESSAGES.status.wouldInstall(component.name, registryType)}`);
+        logger.info(`   Type: ${component.type}`);
+        if (component.registryDependencies && component.registryDependencies.length > 0) {
+          logger.info(`   Registry deps: ${component.registryDependencies.join(" -> ")}`);
+        }
+        logger.info(`   Files: ${component.files.length}`);
+        logger.info(`   Dependencies: ${component.dependencies.join(", ") || "none"}`);
+        for (const file of component.files) {
+          const fileName = path8.basename(file.path);
+          const target = file.target || inferTargetFromType(component.type);
+          const installDir = resolveInstallDir(target, config);
+          const targetPath = path8.join(process.cwd(), installDir, fileName);
+          const exists = await fs7.pathExists(targetPath);
+          const status = exists ? "overwrite" : "create";
+          logger.info(`   ${status}: ${targetPath}`);
+          if (exists) {
+            const currentContent = await fs7.readFile(targetPath, "utf-8");
+            const transformedIncoming = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases) : file.content;
+            const changed = hasDiff(currentContent, transformedIncoming);
+            if (changed) {
+              const patch = buildUnifiedDiff(targetPath, `${component.name}/${fileName}`, currentContent, transformedIncoming);
+              console.log(formatDiffPreview(patch, 40));
+            }
+          }
+        }
+        if (component.dependencies.length > 0) {
+          const depStatus = await checkProjectDependencies(component.dependencies);
+          showDependencyStatus(depStatus);
+        }
+        continue;
+      }
+      await installComponentFiles(component, config, options.force);
+      if (component.dependencies.length > 0) {
+        try {
+          await installDependencies(component.dependencies);
+        } catch (error) {
+          logger.warn(CLI_MESSAGES.errors.couldNotInstallDeps(component.name));
+          logger.warn(`   Dependencies: ${component.dependencies.join(", ")}`);
+          logger.warn("   Please install them manually if needed");
+        }
+      }
+      spinner.succeed(`[${position}] ${CLI_MESSAGES.status.installing(component.name, registryType)}`);
+      results.push({ name: component.name, status: "success" });
+    } catch (error) {
+      spinner.fail(`[${position}] ${CLI_MESSAGES.errors.failedToInstall(componentName, registryType)}`);
+      logger.error(`   Error: ${error.message}`);
+      results.push({
+        name: componentName,
+        status: "error",
+        error: error.message
+      });
+    }
+  }
+  return results;
+}
+async function pickComponentsFromPrompt(registryType, requestOptions) {
+  const allComponents = await getAllComponents(registryType, requestOptions);
+  if (allComponents.length === 0) {
+    logger.warn(`No components found in ${registryType} registry`);
+    return [];
+  }
+  const sorted = allComponents.filter((component) => !ADD_EXCLUDED_COMPONENT_TYPES.includes(component.type)).sort((a, b) => {
+    if (a.type === b.type) {
+      return a.name.localeCompare(b.name);
+    }
+    return a.type.localeCompare(b.type);
+  });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const component of sorted) {
+    const group = grouped.get(component.type) ?? [];
+    group.push(component);
+    if (!grouped.has(component.type)) {
+      grouped.set(component.type, group);
+    }
+  }
+  const choices = [];
+  for (const [type, components] of grouped) {
+    choices.push({
+      title: `
+${type}`,
+      value: "__separator__",
+      description: "",
+      disabled: true
+    });
+    for (const component of components) {
+      choices.push({
+        title: component.name,
+        value: component.name,
+        description: component.description || component.type
+      });
+    }
+  }
+  if (choices.length === 0) {
+    logger.warn(`No selectable components found in ${registryType} registry`);
+    return [];
+  }
+  const { selected } = await prompts3({
+    type: "multiselect",
+    name: "selected",
+    message: "Which components would you like to add?",
+    instructions: false,
+    choices,
+    hint: "Space to select, Enter to confirm"
+  });
+  return selected || [];
+}
+async function installRequestedComponents(componentNames, registryType, config, getComponentFn, options, preloadedComponents = []) {
+  const componentMap = /* @__PURE__ */ new Map();
+  for (const component of preloadedComponents) {
+    componentMap.set(component.name.toLowerCase(), component);
+  }
+  const resolverGetComponent = async (name, type) => {
+    const normalized = name.toLowerCase();
+    const cached = componentMap.get(normalized);
+    if (cached) {
+      return cached;
+    }
+    const component = await getComponentFn(name, type);
+    if (!component) {
+      return null;
+    }
+    componentMap.set(component.name.toLowerCase(), component);
+    return component;
+  };
+  const orderedComponents = await resolveRegistryTree(
+    componentNames,
+    registryType,
+    (name, type) => resolverGetComponent(name, type)
+  );
+  if (options.dryRun && orderedComponents.length > 0) {
+    logger.info("\n\u{1F4E6} Resolved registry dependency tree:");
+    orderedComponents.forEach((component, index) => {
+      console.log(`   ${index + 1}. ${component.name}`);
+    });
+  }
+  const orderedNames = new Set(orderedComponents.map((component) => component.name.toLowerCase()));
+  const normalizedRequested = Array.from(new Set(componentNames.map((name) => name.toLowerCase())));
+  const missingRequested = normalizedRequested.filter((name) => !orderedNames.has(name));
+  const missingResults = missingRequested.map((name) => ({
+    name,
+    status: "error",
+    error: `Component "${name}" was not found in ${registryType} registry`
+  }));
+  const processingResults = await processComponents(
+    orderedComponents.map((component) => component.name),
+    registryType,
+    config,
+    resolverGetComponent,
+    options,
+    orderedComponents,
+    orderedComponents.length
+  );
+  return [...missingResults, ...processingResults];
+}
+function displayInstallationSummary(registryType, results) {
+  const successful = results.filter((r) => r.status === "success");
+  const failed = results.filter((r) => r.status === "error");
+  logger.info("\n\u{1F4CA} Installation Summary:");
+  console.log(`   Registry: ${registryType}`);
+  console.log(`   \u2705 Successful: ${successful.length}`);
+  console.log(`   \u274C Failed: ${failed.length}`);
+  if (successful.length > 0) {
+    logger.success(`
+\u{1F389} ${CLI_MESSAGES.success.componentsInstalled}`);
+    console.log("You can now import and use them in your project.");
+  }
+  if (failed.length > 0) {
+    process.exit(1);
+  }
+}
+async function installComponentFiles(component, config, force = false) {
+  for (const file of component.files) {
+    const fileName = path8.basename(file.path);
+    const target = file.target || inferTargetFromType(component.type);
+    const installDir = resolveInstallDir(target, config);
+    const targetPath = path8.join(process.cwd(), installDir, fileName);
+    if (!force && await fs7.pathExists(targetPath)) {
+      console.log(`   \u26A0\uFE0F  ${CLI_MESSAGES.status.skipped(fileName)}`);
+      continue;
+    }
+    await fs7.ensureDir(path8.dirname(targetPath));
+    const preparedContent = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases) : file.content;
+    await fs7.writeFile(targetPath, preparedContent, "utf-8");
+  }
+}
+function inferTargetFromType(componentType) {
+  switch (componentType) {
+    case "registry:ui":
+      return "ui";
+    case "registry:composite":
+      return "components";
+    case "registry:block":
+      return "blocks";
+    case "registry:component":
+      return "components";
+    case "registry:layout":
+      return "layouts";
+    case "registry:lib":
+      return "lib";
+    case "registry:variants":
+      return "variants";
+    default:
+      return "components";
+  }
+}
+function resolveInstallDir(target, config) {
+  const normalizedTarget = target.replace(/\\/g, "/").replace(/^\/?src\//i, "");
+  if (normalizedTarget === "lib") {
+    return normalizeDir(config.libDir || SCHEMA_CONFIG.defaultDirectories.lib);
+  }
+  if (normalizedTarget === "variants") {
+    return normalizeDir(SCHEMA_CONFIG.defaultDirectories.variants);
+  }
+  const baseComponentsDir = normalizeDir(config.componentsDir || SCHEMA_CONFIG.defaultDirectories.components);
+  if (normalizedTarget.includes("/")) {
+    const parentRoot = baseComponentsDir.replace(/[/\\]components$/i, "") || "src";
+    return path8.join(parentRoot, normalizedTarget).replace(/\\/g, "/");
+  }
+  if (normalizedTarget === "ui")
+    return path8.join(baseComponentsDir, "ui").replace(/\\/g, "/");
+  if (normalizedTarget === "components")
+    return baseComponentsDir;
+  switch (normalizedTarget) {
+    case "blocks":
+      return normalizeDir(SCHEMA_CONFIG.defaultDirectories.blocks);
+    case "layouts":
+      return normalizeDir(SCHEMA_CONFIG.defaultDirectories.layouts);
+    default:
+      return baseComponentsDir;
+  }
+}
+function normalizeDir(dir) {
+  return dir.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function resolveRegistryType(registryInput) {
+  if (!registryInput) {
+    return SCHEMA_CONFIG.defaultRegistryType;
   }
-  for (const item of variantItems) {
-    spinner.text = `Installing variant: ${item.name}...`;
-    await installComponentFromRegistry(item.name, "registry:variants", cdnUrls, config);
+  if (SCHEMA_CONFIG.registryTypes.includes(registryInput)) {
+    return registryInput;
   }
-  spinner.text = `Installing variants index...`;
-  await installVariantsIndex(cdnUrls, config);
-  spinner.text = `\u2705 Installed ${libItems.length} utilities and ${variantItems.length} variants`;
+  logger.warn(`\u26A0\uFE0F  Unknown registry type: ${registryInput}`);
+  console.log(`Available registries: ${SCHEMA_CONFIG.registryTypes.join(", ")}`);
+  console.log(`Using default: ${SCHEMA_CONFIG.defaultRegistryType}`);
+  return SCHEMA_CONFIG.defaultRegistryType;
 }
-async function installComponentFromRegistry(name, type, cdnUrls, config) {
-  const folder = type === "registry:lib" ? "lib" : type === "registry:variants" ? "components/variants" : "components/ui";
-  for (const baseUrl of cdnUrls) {
-    try {
-      const url = `${baseUrl}/${folder}/${name}.json`;
-      const response = await fetch4(url);
-      if (response.ok) {
-        const component = await response.json();
-        for (const file of component.files) {
-          const fileName = path4.basename(file.path);
-          let targetDir;
-          if (type === "registry:lib") {
-            targetDir = config.libDir;
-          } else if (type === "registry:variants") {
-            targetDir = SCHEMA_CONFIG.defaultDirectories.variants;
-          } else {
-            targetDir = path4.join(config.componentsDir, "ui");
+async function installComponentsIndex(registryType, config) {
+  const spinner = ora4("Installing components index...").start();
+  try {
+    const cdnUrls = SCHEMA_CONFIG.cdnBaseUrls;
+    for (const baseUrl of cdnUrls) {
+      try {
+        const url = `${baseUrl}/components/index.json`;
+        const response = await fetch3(url);
+        if (response.ok) {
+          const component = await response.json();
+          for (const file of component.files) {
+            const fileName = path8.basename(file.path);
+            const targetDir = config.componentsDir;
+            const targetPath = path8.join(process.cwd(), targetDir, fileName);
+            await fs7.ensureDir(path8.dirname(targetPath));
+            await fs7.writeFile(targetPath, file.content || "", "utf-8");
           }
-          const targetPath = path4.join(process.cwd(), targetDir, fileName);
-          await fs5.ensureDir(path4.dirname(targetPath));
-          await fs5.writeFile(targetPath, file.content || "", "utf-8");
-        }
-        return;
-      }
-    } catch {
-      continue;
-    }
-  }
-}
-async function installVariantsIndex(cdnUrls, config) {
-  for (const baseUrl of cdnUrls) {
-    try {
-      const url = `${baseUrl}/components/variants/index.json`;
-      const response = await fetch4(url);
-      if (response.ok) {
-        const component = await response.json();
-        for (const file of component.files) {
-          const fileName = path4.basename(file.path);
-          const targetDir = SCHEMA_CONFIG.defaultDirectories.variants;
-          const targetPath = path4.join(process.cwd(), targetDir, fileName);
-          await fs5.ensureDir(path4.dirname(targetPath));
-          await fs5.writeFile(targetPath, file.content || "", "utf-8");
+          spinner.succeed("Installed components index");
+          return;
         }
-        return;
+      } catch {
+        continue;
       }
-    } catch {
-      continue;
     }
+    spinner.info("Components index not found in registry (optional)");
+  } catch (error) {
+    spinner.fail("Could not install components index");
   }
 }
-async function createUtilsFile(libDir, typescript) {
-  const utilsContent = `import { type ClassValue, clsx } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}`;
-  const fileName = typescript ? "utils.ts" : "utils.js";
-  const filePath = path4.join(process.cwd(), libDir, fileName);
-  await fs5.writeFile(filePath, utilsContent, "utf-8");
-}
 
 // src/commands/build.ts
-import fs6 from "fs-extra";
-import path5 from "path";
-import chalk5 from "chalk";
-import ora3 from "ora";
+import fs8 from "fs-extra";
+import path9 from "path";
+import chalk7 from "chalk";
+import ora5 from "ora";
+import * as ts2 from "typescript";
 
 // src/registry/build-schema.ts
 import { z as z2 } from "zod";
@@ -1323,6 +1897,11 @@ function generateConfigSchema() {
         "default": true,
         "description": SCHEMA_CONFIG.fieldDescriptions.typescript
       },
+      "globalCss": {
+        "type": "string",
+        "default": "src/index.css",
+        "description": SCHEMA_CONFIG.fieldDescriptions.globalCss
+      },
       "aliases": {
         "type": "object",
         "additionalProperties": {
@@ -1450,44 +2029,46 @@ function generateRegistryItemSchema() {
 // src/commands/build.ts
 async function buildCommand(registryPath = "./src/registry.json", options = {}) {
   const buildOptions = {
-    cwd: path5.resolve(options.cwd || process.cwd()),
-    registryFile: path5.resolve(registryPath),
-    outputDir: path5.resolve(options.output || "./packages/registry/r")
+    cwd: path9.resolve(options.cwd || process.cwd()),
+    registryFile: path9.resolve(registryPath),
+    outputDir: path9.resolve(options.output || "./packages/registry/r")
   };
-  console.log(chalk5.blue(CLI_MESSAGES.info.building));
+  console.log(chalk7.blue(CLI_MESSAGES.info.building));
   try {
-    const registryContent = await fs6.readFile(buildOptions.registryFile, "utf-8");
+    await clearCache();
+    resetCache();
+    const registryContent = await fs8.readFile(buildOptions.registryFile, "utf-8");
     const registryData = JSON.parse(registryContent);
     const registry = registrySchema.parse(registryData);
-    await fs6.ensureDir(buildOptions.outputDir);
+    await ensureVariantsIndexItem(registry, buildOptions.cwd);
+    await fs8.ensureDir(buildOptions.outputDir);
     await generateSchemaFiles(buildOptions.outputDir);
-    const spinner = ora3(CLI_MESSAGES.info.processingComponents).start();
+    const spinner = ora5(CLI_MESSAGES.info.processingComponents).start();
     for (const item of registry.items) {
       spinner.text = `Building ${item.name}...`;
       item.$schema = "https://ui.buildy.tw/schema/registry-item.json";
       for (const file of item.files) {
-        const filePath = path5.resolve(buildOptions.cwd, file.path);
-        if (await fs6.pathExists(filePath)) {
-          file.content = await fs6.readFile(filePath, "utf-8");
+        const filePath = path9.resolve(buildOptions.cwd, file.path);
+        if (await fs8.pathExists(filePath)) {
+          file.content = await fs8.readFile(filePath, "utf-8");
         } else {
           throw new Error(CLI_MESSAGES.errors.fileNotFound(file.path));
         }
       }
       const validatedItem = registryItemSchema.parse(item);
       const typeDir = getOutputDir(validatedItem.type);
-      const outputPath = path5.join(buildOptions.outputDir, typeDir);
-      await fs6.ensureDir(outputPath);
-      const outputFile = path5.join(outputPath, `${validatedItem.name}.json`);
-      await fs6.writeFile(outputFile, JSON.stringify(validatedItem, null, 2));
+      const outputPath = path9.join(buildOptions.outputDir, typeDir);
+      await fs8.ensureDir(outputPath);
+      const outputFile = path9.join(outputPath, `${validatedItem.name}.json`);
+      await fs8.writeFile(outputFile, JSON.stringify(validatedItem, null, 2));
     }
     spinner.succeed(CLI_MESSAGES.status.builtComponents(registry.items.length));
     await createIndexFile(registry, buildOptions.outputDir);
-    console.log(chalk5.green(`\u2705 ${CLI_MESSAGES.success.registryBuilt}`));
+    console.log(chalk7.green(`\u2705 ${CLI_MESSAGES.success.registryBuilt}`));
     console.log(`Output: ${buildOptions.outputDir}`);
-    console.log(chalk5.green(`\u2705 ${CLI_MESSAGES.success.schemasGenerated}`));
+    console.log(chalk7.green(`\u2705 ${CLI_MESSAGES.success.schemasGenerated}`));
   } catch (error) {
-    console.error(chalk5.red(`\u274C ${CLI_MESSAGES.errors.buildFailed}`), error.message);
-    process.exit(1);
+    handleError(error);
   }
 }
 var BUILD_OUTPUT_FOLDERS = {
@@ -1517,39 +2098,103 @@ async function createIndexFile(registry, outputDir) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
     registry: registry?.registry || SCHEMA_CONFIG.defaultRegistryType
   };
-  await fs6.writeFile(
-    path5.join(outputDir, "index.json"),
+  await fs8.writeFile(
+    path9.join(outputDir, "index.json"),
     JSON.stringify(index, null, 2)
   );
 }
 async function generateSchemaFiles(outputDir) {
-  const registryBaseDir = path5.dirname(outputDir);
-  const schemaDir = path5.join(registryBaseDir, "schema");
-  await fs6.ensureDir(schemaDir);
+  const registryBaseDir = path9.dirname(outputDir);
+  const schemaDir = path9.join(registryBaseDir, "schema");
+  await fs8.ensureDir(schemaDir);
   const configSchemaJson = generateConfigSchema();
   const registrySchemaJson = generateRegistrySchema();
   const registryItemSchemaJson = generateRegistryItemSchema();
-  await fs6.writeFile(
-    path5.join(registryBaseDir, "schema.json"),
+  await fs8.writeFile(
+    path9.join(registryBaseDir, "schema.json"),
     JSON.stringify(configSchemaJson, null, 2)
   );
-  await fs6.writeFile(
-    path5.join(schemaDir, "registry.json"),
+  await fs8.writeFile(
+    path9.join(schemaDir, "registry.json"),
     JSON.stringify(registrySchemaJson, null, 2)
   );
-  await fs6.writeFile(
-    path5.join(schemaDir, "registry-item.json"),
+  await fs8.writeFile(
+    path9.join(schemaDir, "registry-item.json"),
     JSON.stringify(registryItemSchemaJson, null, 2)
   );
 }
+async function ensureVariantsIndexItem(registry, cwd) {
+  const indexSourcePath = path9.join(cwd, "src/variants/index.ts");
+  if (!await fs8.pathExists(indexSourcePath)) {
+    return;
+  }
+  const sourceContent = await fs8.readFile(indexSourcePath, "utf-8");
+  const dependencies = extractFileDependencies(sourceContent);
+  const exportedModules = extractExportedModules(sourceContent);
+  const indexItem = {
+    type: "registry:variants",
+    name: "index",
+    description: exportedModules.length > 0 ? `Variant exports: ${exportedModules.join(", ")}` : "Variants export index",
+    dependencies,
+    devDependencies: [],
+    files: [
+      {
+        path: path9.relative(cwd, indexSourcePath).replace(/\\/g, "/")
+      }
+    ]
+  };
+  const items = Array.isArray(registry.items) ? registry.items : [];
+  const existingIndexIdx = items.findIndex(
+    (item) => item && item.type === indexItem.type && item.name === indexItem.name
+  );
+  if (existingIndexIdx >= 0) {
+    items[existingIndexIdx] = {
+      ...items[existingIndexIdx],
+      ...indexItem
+    };
+  } else {
+    items.push(indexItem);
+  }
+}
+function extractExportedModules(content) {
+  const exports = /* @__PURE__ */ new Set();
+  const starExportRegex = /export\s+\*\s+from\s+['"]\.\/([^'"]+)['"]/g;
+  const namedExportRegex = /export\s+\{[^}]+\}\s+from\s+['"]\.\/([^'"]+)['"]/g;
+  let match;
+  while ((match = starExportRegex.exec(content)) !== null) {
+    exports.add(match[1]);
+  }
+  while ((match = namedExportRegex.exec(content)) !== null) {
+    exports.add(match[1]);
+  }
+  return [...exports];
+}
+function extractFileDependencies(content) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const sourceFile = ts2.createSourceFile("index.ts", content, ts2.ScriptTarget.Latest, true);
+  function visit(node) {
+    if (ts2.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts2.isStringLiteral(moduleSpecifier)) {
+        const moduleName = moduleSpecifier.text;
+        if (isExternalDependency(moduleName)) {
+          dependencies.add(moduleName);
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return [...dependencies];
+}
 
 // src/commands/scan.ts
-import fs7 from "fs-extra";
-import path6 from "path";
-import chalk6 from "chalk";
-import ora4 from "ora";
+import fs9 from "fs-extra";
+import path10 from "path";
+import chalk8 from "chalk";
+import ora6 from "ora";
 import { glob } from "glob";
-import * as ts from "typescript";
+import * as ts3 from "typescript";
 var DEV_PATTERNS = [
   "@types/",
   "eslint",
@@ -1574,28 +2219,28 @@ async function scanCommand(options = {}) {
   const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
   const registryPath = `./${registryName}`;
   const scanOptions = {
-    cwd: path6.resolve(options.cwd || process.cwd()),
-    registry: path6.resolve(registryPath),
-    outputFile: path6.resolve(options.output || "./src/registry.json"),
-    sourceDir: path6.resolve(options.source || "./src")
+    cwd: path10.resolve(options.cwd || process.cwd()),
+    registry: path10.resolve(registryPath),
+    outputFile: path10.resolve(options.output || "./src/registry.json"),
+    sourceDir: path10.resolve(options.source || "./src")
   };
-  console.log(chalk6.blue(`\u{1F50D} ${CLI_MESSAGES.info.scanningComponents(registryName)}`));
+  console.log(chalk8.blue(`\u{1F50D} ${CLI_MESSAGES.info.scanningComponents(registryName)}`));
   try {
-    const spinner = ora4(CLI_MESSAGES.info.scanningDirectories).start();
-    const componentsDir = path6.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.components));
-    const uiDir = path6.join(componentsDir, "ui");
-    const blocksDir = path6.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.blocks));
-    const layoutsDir = path6.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.layouts));
-    const libDir = path6.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.lib));
-    const variantsDir = path6.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.variants));
+    const spinner = ora6(CLI_MESSAGES.info.scanningDirectories).start();
+    const componentsDir = path10.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.components));
+    const uiDir = path10.join(componentsDir, "ui");
+    const blocksDir = path10.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.blocks));
+    const layoutsDir = path10.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.layouts));
+    const libDir = path10.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.lib));
+    const variantsDir = path10.resolve(scanOptions.cwd, normalizeDir2(SCHEMA_CONFIG.defaultDirectories.variants));
     const uiComponents = await scanDirectory(uiDir, "registry:ui");
     const compositeComponents = await scanDirectoryFlat(componentsDir, "registry:composite", ["index.ts"]);
     const variantComponents = await scanDirectory(variantsDir, "registry:variants", ["index.ts"]);
     const blockComponents = await scanDirectory(blocksDir, "registry:block");
     const layoutComponents = await scanDirectory(layoutsDir, "registry:layout");
     const libComponents = await scanDirectory(libDir, "registry:lib");
-    const variantsIndexItem = await scanSingleFile(path6.join(variantsDir, "index.ts"), "registry:variants");
-    const componentsIndexItem = await scanSingleFile(path6.join(componentsDir, "index.ts"), "registry:composite");
+    const variantsIndexItem = await scanSingleFile(path10.join(variantsDir, "index.ts"), "registry:variants");
+    const componentsIndexItem = await scanSingleFile(path10.join(componentsDir, "index.ts"), "registry:composite");
     const allComponentsRaw = [
       ...uiComponents,
       ...compositeComponents,
@@ -1631,16 +2276,16 @@ async function scanCommand(options = {}) {
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
       registry: registryName
     };
-    await fs7.ensureDir(path6.dirname(scanOptions.outputFile));
-    await fs7.writeFile(scanOptions.outputFile, JSON.stringify(registry, null, 2));
+    await fs9.ensureDir(path10.dirname(scanOptions.outputFile));
+    await fs9.writeFile(scanOptions.outputFile, JSON.stringify(registry, null, 2));
     spinner.succeed(CLI_MESSAGES.status.scannedComponents(allComponents.length));
-    console.log(chalk6.green(`\u2705 ${CLI_MESSAGES.success.registryGenerated(registryName)}`));
+    console.log(chalk8.green(`\u2705 ${CLI_MESSAGES.success.registryGenerated(registryName)}`));
     console.log(`Output: ${scanOptions.outputFile}`);
     const summary = allComponents.reduce((acc, comp) => {
       acc[comp.type] = (acc[comp.type] || 0) + 1;
       return acc;
     }, {});
-    console.log(chalk6.blue("\n\u{1F4CA} Component Summary:"));
+    console.log(chalk8.blue("\n\u{1F4CA} Component Summary:"));
     Object.entries(summary).forEach(([type, count]) => {
       console.log(`   ${type}: ${count}`);
     });
@@ -1650,30 +2295,29 @@ async function scanCommand(options = {}) {
       comp.dependencies.forEach((dep) => allDeps.add(dep));
       comp.devDependencies.forEach((dep) => allDevDeps.add(dep));
     });
-    console.log(chalk6.blue("\n\u{1F4E6} Dependencies Summary:"));
+    console.log(chalk8.blue("\n\u{1F4E6} Dependencies Summary:"));
     console.log(`   Dependencies: ${allDeps.size} unique (${Array.from(allDeps).join(", ") || "none"})`);
     console.log(`   DevDependencies: ${allDevDeps.size} unique (${Array.from(allDevDeps).join(", ") || "none"})`);
   } catch (error) {
-    console.error(chalk6.red(`\u274C ${CLI_MESSAGES.errors.scanFailed}`), error.message);
-    process.exit(1);
+    handleError(error);
   }
 }
 async function scanDirectory(dirPath, type, ignorePatterns = []) {
-  if (!await fs7.pathExists(dirPath)) {
+  if (!await fs9.pathExists(dirPath)) {
     return [];
   }
   const components = [];
-  const pattern = path6.join(dirPath, "**/*.{ts,tsx,js,jsx}").replace(/\\/g, "/");
+  const pattern = path10.join(dirPath, "**/*.{ts,tsx,js,jsx}").replace(/\\/g, "/");
   const ignore = ignorePatterns.map((p) => p.replace(/\\/g, "/"));
   const files = await glob(pattern, { windowsPathsNoEscape: true, ignore });
   for (const filePath of files) {
-    const relativePath = path6.relative(process.cwd(), filePath).replace(/\\/g, "/");
-    const fileName = path6.basename(filePath, path6.extname(filePath));
+    const relativePath = path10.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const fileName = path10.basename(filePath, path10.extname(filePath));
     if (fileName === "index" || fileName.startsWith("_")) {
       continue;
     }
     try {
-      const content = await fs7.readFile(filePath, "utf-8");
+      const content = await fs9.readFile(filePath, "utf-8");
       const description = extractDescription(content);
       if (!hasValidExports(content)) {
         continue;
@@ -1696,20 +2340,20 @@ async function scanDirectory(dirPath, type, ignorePatterns = []) {
   return components;
 }
 async function scanDirectoryFlat(dirPath, type, ignoreFiles = []) {
-  if (!await fs7.pathExists(dirPath)) {
+  if (!await fs9.pathExists(dirPath)) {
     return [];
   }
   const components = [];
-  const pattern = path6.join(dirPath, "*.{ts,tsx,js,jsx}").replace(/\\/g, "/");
+  const pattern = path10.join(dirPath, "*.{ts,tsx,js,jsx}").replace(/\\/g, "/");
   const files = await glob(pattern, { windowsPathsNoEscape: true });
   for (const filePath of files) {
-    const relativePath = path6.relative(process.cwd(), filePath).replace(/\\/g, "/");
-    const fileName = path6.basename(filePath, path6.extname(filePath));
-    if (ignoreFiles.includes(fileName + path6.extname(filePath)) || fileName.startsWith("_")) {
+    const relativePath = path10.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const fileName = path10.basename(filePath, path10.extname(filePath));
+    if (ignoreFiles.includes(fileName + path10.extname(filePath)) || fileName.startsWith("_")) {
       continue;
     }
     try {
-      const content = await fs7.readFile(filePath, "utf-8");
+      const content = await fs9.readFile(filePath, "utf-8");
       const description = extractDescription(content);
       if (!hasValidExports(content)) {
         continue;
@@ -1732,17 +2376,17 @@ async function scanDirectoryFlat(dirPath, type, ignoreFiles = []) {
   return components;
 }
 async function scanSingleFile(filePath, type) {
-  if (!await fs7.pathExists(filePath)) {
+  if (!await fs9.pathExists(filePath)) {
     return null;
   }
   try {
-    const content = await fs7.readFile(filePath, "utf-8");
+    const content = await fs9.readFile(filePath, "utf-8");
     const description = extractDescription(content);
     if (!hasValidExports(content)) {
       return null;
     }
-    const relativePath = path6.relative(process.cwd(), filePath).replace(/\\/g, "/");
-    const fileName = path6.basename(filePath, path6.extname(filePath));
+    const relativePath = path10.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const fileName = path10.basename(filePath, path10.extname(filePath));
     return {
       name: fileName,
       type,
@@ -1771,7 +2415,17 @@ function extractDescription(content) {
   return "";
 }
 function hasValidExports(content) {
-  return /export\s+(default\s+)?(function|const|class|interface|type)/m.test(content) || /export\s*\{/.test(content);
+  const sourceFile = ts3.createSourceFile("index.ts", content, ts3.ScriptTarget.Latest, true);
+  let hasExports = false;
+  function visit(node) {
+    if (ts3.isExportDeclaration(node) || ts3.isExportAssignment(node) || hasExportModifier(node)) {
+      hasExports = true;
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return hasExports;
 }
 async function analyzeComponentDependencies(files, cwd) {
   const allDependencies = /* @__PURE__ */ new Set();
@@ -1779,12 +2433,12 @@ async function analyzeComponentDependencies(files, cwd) {
   let description;
   for (const file of files) {
     try {
-      const filePath = path6.resolve(cwd, file.path);
-      const content = await fs7.readFile(filePath, "utf-8");
-      const sourceFile = ts.createSourceFile(
+      const filePath = path10.resolve(cwd, file.path);
+      const content = await fs9.readFile(filePath, "utf-8");
+      const sourceFile = ts3.createSourceFile(
         file.path,
         content,
-        ts.ScriptTarget.Latest,
+        ts3.ScriptTarget.Latest,
         true
       );
       const analysis = analyzeAST(sourceFile);
@@ -1809,9 +2463,9 @@ function analyzeAST(sourceFile) {
   let description;
   let hasExports = false;
   function visit(node) {
-    if (ts.isImportDeclaration(node)) {
+    if (ts3.isImportDeclaration(node)) {
       const moduleSpecifier = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpecifier)) {
+      if (ts3.isStringLiteral(moduleSpecifier)) {
         const moduleName = moduleSpecifier.text;
         if (isExternalDependency(moduleName)) {
           if (isDevDependency(moduleName)) {
@@ -1822,9 +2476,9 @@ function analyzeAST(sourceFile) {
         }
       }
     }
-    if (ts.isExportDeclaration(node)) {
+    if (ts3.isExportDeclaration(node)) {
       hasExports = true;
-    } else if (ts.isExportAssignment(node)) {
+    } else if (ts3.isExportAssignment(node)) {
       hasExports = true;
     } else if (hasExportModifier(node)) {
       hasExports = true;
@@ -1833,7 +2487,7 @@ function analyzeAST(sourceFile) {
     if (jsDocComment && !description) {
       description = jsDocComment;
     }
-    ts.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   }
   visit(sourceFile);
   return {
@@ -1849,16 +2503,16 @@ function isDevDependency(moduleName) {
 function hasExportModifier(node) {
   if ("modifiers" in node && node.modifiers) {
     return node.modifiers.some(
-      (mod) => mod.kind === ts.SyntaxKind.ExportKeyword
+      (mod) => mod.kind === ts3.SyntaxKind.ExportKeyword
     );
   }
   return false;
 }
 function getJSDocComment(node) {
   try {
-    const jsDocTags = ts.getJSDocCommentsAndTags(node);
+    const jsDocTags = ts3.getJSDocCommentsAndTags(node);
     for (const tag of jsDocTags) {
-      if (ts.isJSDoc(tag) && tag.comment) {
+      if (ts3.isJSDoc(tag) && tag.comment) {
         if (typeof tag.comment === "string") {
           return tag.comment.trim();
         } else if (Array.isArray(tag.comment)) {
@@ -1878,19 +2532,427 @@ function normalizeDir2(dir) {
   return dir.replace(/^\.\//, "").replace(/\\/g, "/");
 }
 
+// src/commands/list.ts
+import chalk9 from "chalk";
+var LIST_EXCLUDED_COMPONENT_TYPES = ["registry:variants", "registry:lib"];
+async function listCommand(options = {}) {
+  const registryType = resolveRegistryType2(options.registry);
+  const requestOptions = {
+    excludeTypes: LIST_EXCLUDED_COMPONENT_TYPES,
+    noCache: options.cache === false
+  };
+  try {
+    const components = await getAllComponents(registryType, requestOptions);
+    if (options.json) {
+      console.log(JSON.stringify(components, null, 2));
+      return;
+    }
+    const byType = /* @__PURE__ */ new Map();
+    for (const component of components) {
+      const group = byType.get(component.type) ?? [];
+      group.push(component);
+      byType.set(component.type, group);
+    }
+    const sortedGroups = Array.from(byType.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    if (sortedGroups.length === 0) {
+      logger.warn(CLI_MESSAGES.errors.registryTempUnavailable);
+      return;
+    }
+    logger.info(CLI_MESSAGES.info.listingComponents);
+    for (const [type, group] of sortedGroups) {
+      const entries = group.sort((a, b) => a.name.localeCompare(b.name));
+      console.log(chalk9.cyan(`${type} (${entries.length} components)`));
+      for (const component of entries) {
+        const description = component.description ? chalk9.dim(component.description) : "";
+        console.log(chalk9.white(`  ${component.name.padEnd(14)}`) + description);
+      }
+      console.log("");
+    }
+  } catch (error) {
+    logger.error(error.message);
+  }
+}
+function resolveRegistryType2(registryInput) {
+  if (!registryInput) {
+    return SCHEMA_CONFIG.defaultRegistryType;
+  }
+  if (SCHEMA_CONFIG.registryTypes.includes(registryInput)) {
+    return registryInput;
+  }
+  logger.warn(`\u26A0\uFE0F  Unknown registry type: ${registryInput}`);
+  logger.warn(`Available registries: ${SCHEMA_CONFIG.registryTypes.join(", ")}`);
+  return SCHEMA_CONFIG.defaultRegistryType;
+}
+
+// src/commands/diff.ts
+import fs10 from "fs-extra";
+import path11 from "path";
+import { glob as glob2 } from "glob";
+import chalk10 from "chalk";
+async function diffCommand(componentName, options = {}) {
+  try {
+    const registryType = resolveRegistryType3(options.registry);
+    const config = await findConfig(registryType);
+    const defaultConfig = config ?? {
+      framework: SCHEMA_CONFIG.supportedFrameworks[0],
+      typescript: true,
+      globalCss: "src/index.css",
+      aliases: SCHEMA_CONFIG.defaultAliases,
+      registry: SCHEMA_CONFIG.defaultRegistry,
+      componentsDir: SCHEMA_CONFIG.defaultDirectories.components,
+      libDir: SCHEMA_CONFIG.defaultDirectories.lib
+    };
+    const installed = await scanLocalComponents(defaultConfig);
+    if (installed.length === 0) {
+      logger.warn(CLI_MESSAGES.errors.noLocalInstall);
+      return;
+    }
+    const registryComponents = await getAllComponents(registryType, { noCache: options.cache === false });
+    const registryIndex = new Map(registryComponents.map((item) => [item.name.toLowerCase(), item]));
+    const targets = componentName ? installed.filter((item) => item.name.toLowerCase() === componentName.toLowerCase()) : installed;
+    if (componentName && targets.length === 0) {
+      logger.warn(`Component "${componentName}" not found in local project structure`);
+      return;
+    }
+    const results = [];
+    logger.info(CLI_MESSAGES.info.checkingForUpdates);
+    for (const item of targets) {
+      const remoteComponent = registryIndex.get(item.name.toLowerCase());
+      if (!remoteComponent) {
+        results.push({
+          component: item.name,
+          type: "unknown",
+          status: "missing-remote",
+          files: [{ path: item.filePath, changed: false }]
+        });
+        continue;
+      }
+      const fileSummary = await compareComponentFiles(item, remoteComponent, defaultConfig);
+      const hasChanges = fileSummary.some((file) => file.changed);
+      results.push({
+        component: item.name,
+        type: remoteComponent.type,
+        status: hasChanges ? "update" : "up-to-date",
+        files: fileSummary
+      });
+    }
+    if (options.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+    const updates = results.filter((item) => item.status === "update").length;
+    const upToDate = results.filter((item) => item.status === "up-to-date").length;
+    for (const result of results) {
+      if (result.status === "missing-remote") {
+        logger.warn(`
+\u26A0\uFE0F  ${result.component}: not found in registry`);
+        continue;
+      }
+      const statusTitle = result.status === "update" ? `${chalk10.yellow("UPDATE")}` : chalk10.green("UP-TO-DATE");
+      const title = `${statusTitle} ${result.component} (${result.type})`;
+      logger.info(title);
+      for (const file of result.files) {
+        console.log(`  ${chalk10.white(file.path)}`);
+        if (file.changed && file.diff) {
+          const preview = formatDiffPreview(file.diff, 120);
+          console.log(colorDiff(preview));
+        } else {
+          console.log(chalk10.dim("  No changes"));
+        }
+      }
+    }
+    console.log(
+      `
+${CLI_MESSAGES.info.localDiffSummary} ${chalk10.yellow(updates)} component(s) have updates, ${chalk10.green(upToDate)} up to date`
+    );
+    if (updates > 0) {
+      console.log('Run "ui8kit add <component> --force" to update.');
+    }
+  } catch (error) {
+    handleError(error);
+  }
+}
+async function compareComponentFiles(installed, remote, config) {
+  const localContent = await fs10.readFile(installed.filePath, "utf-8");
+  const remoteCandidate = remote.files.find((file) => {
+    const candidateName = path11.basename(file.path);
+    return candidateName.toLowerCase() === path11.basename(installed.filePath).toLowerCase();
+  });
+  if (!remoteCandidate) {
+    return [{ path: installed.filePath, changed: false }];
+  }
+  const remoteContent = applyTransforms(remoteCandidate.content, config.aliases);
+  const changed = hasDiff(localContent, remoteContent);
+  return changed ? [{
+    path: installed.filePath,
+    changed: true,
+    diff: buildUnifiedDiff(installed.filePath, `${remote.name}/${path11.basename(installed.filePath)}`, localContent, remoteContent)
+  }] : [{ path: installed.filePath, changed: false }];
+}
+async function scanLocalComponents(config) {
+  const componentsDir = path11.resolve(process.cwd(), config.componentsDir || SCHEMA_CONFIG.defaultDirectories.components);
+  const componentsUiDir = path11.join(componentsDir, "ui");
+  const blocksDir = path11.resolve(process.cwd(), SCHEMA_CONFIG.defaultDirectories.blocks);
+  const layoutsDir = path11.resolve(process.cwd(), SCHEMA_CONFIG.defaultDirectories.layouts);
+  const directories = [componentsUiDir, componentsDir, blocksDir, layoutsDir];
+  const entries = [];
+  const patterns = directories.map((dir) => path11.join(dir, "*.{ts,tsx}").replace(/\\/g, "/"));
+  for (const pattern of patterns) {
+    const baseDir = path11.dirname(pattern);
+    if (!await fs10.pathExists(baseDir)) {
+      continue;
+    }
+    const filePaths = await glob2(pattern, { windowsPathsNoEscape: true });
+    for (const filePath of filePaths) {
+      const fileName = path11.basename(filePath);
+      if (fileName === "index.tsx" || fileName === "index.ts") {
+        continue;
+      }
+      entries.push({
+        name: path11.parse(fileName).name.toLowerCase(),
+        filePath: path11.resolve(process.cwd(), filePath)
+      });
+    }
+  }
+  const uniqueByName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!uniqueByName.has(entry.name)) {
+      uniqueByName.set(entry.name, entry);
+    }
+  }
+  return Array.from(uniqueByName.values());
+}
+function colorDiff(value) {
+  return value.split("\n").map((line) => {
+    if (line.startsWith("+")) {
+      return chalk10.green(line);
+    }
+    if (line.startsWith("-")) {
+      return chalk10.red(line);
+    }
+    return line;
+  }).join("\n");
+}
+function resolveRegistryType3(registryInput) {
+  if (!registryInput) {
+    return SCHEMA_CONFIG.defaultRegistryType;
+  }
+  if (SCHEMA_CONFIG.registryTypes.includes(registryInput)) {
+    return registryInput;
+  }
+  logger.warn(`\u26A0\uFE0F  Unknown registry type: ${registryInput}`);
+  logger.warn(`Available registries: ${SCHEMA_CONFIG.registryTypes.join(", ")}`);
+  return SCHEMA_CONFIG.defaultRegistryType;
+}
+
+// src/commands/cache.ts
+async function cacheClearCommand() {
+  try {
+    await clearCache();
+    logger.success(`${CLI_MESSAGES.success.cacheCleared} (${getCacheDir()})`);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/commands/info.ts
+import fs11 from "fs-extra";
+import os2 from "os";
+import path12 from "path";
+import fetch4 from "node-fetch";
+import chalk11 from "chalk";
+
+// src/utils/cli-version.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function findPackageJsonPath() {
+  const roots = [process.argv[1], __dirname];
+  for (const rawRoot of roots) {
+    if (!rawRoot) {
+      continue;
+    }
+    let current = rawRoot.endsWith(".js") ? dirname(rawRoot) : rawRoot;
+    for (let i = 0; i < 8; i += 1) {
+      const candidate = resolve(current, "package.json");
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+      const parent = dirname(current);
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  return null;
+}
+function getCliVersion() {
+  const packageJsonPath = findPackageJsonPath();
+  if (!packageJsonPath) {
+    return "0.0.0";
+  }
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/commands/info.ts
+async function infoCommand(options = {}) {
+  const version = getCliVersion();
+  const pm = await detectPackageManager();
+  const cwd = process.cwd();
+  const configStatus = await readConfigStatus();
+  const cache = await readCacheStatus();
+  const cdn = await checkPrimaryCdn();
+  if (options.json) {
+    console.log(JSON.stringify({
+      version,
+      node: process.version,
+      os: `${os2.platform()} ${os2.arch()}`,
+      packageManager: pm,
+      cwd,
+      config: configStatus.config,
+      configFound: configStatus.found,
+      cache,
+      cdn,
+      registry: SCHEMA_CONFIG.defaultRegistry
+    }, null, 2));
+    return;
+  }
+  console.log(`ui8kit v${version}`);
+  console.log(`Node    ${process.version}`);
+  console.log(`OS      ${os2.platform()} ${os2.arch()}`);
+  console.log(`PM      ${pm}`);
+  console.log(`CWD     ${cwd}`);
+  console.log("");
+  if (configStatus.found) {
+    console.log(chalk11.green(`Config  ${configStatus.path} (found)`));
+    const config = configStatus.config;
+    console.log(`  framework    ${config.framework}`);
+    console.log(`  typescript   ${config.typescript}`);
+    console.log(`  globalCss    ${config.globalCss}`);
+    console.log(`  componentsDir ${config.componentsDir}`);
+    console.log(`  libDir       ${config.libDir}`);
+  } else {
+    console.log(chalk11.yellow("Config  not found"));
+  }
+  console.log("");
+  console.log(`Registry  ${SCHEMA_CONFIG.defaultRegistry}`);
+  console.log(`CDN       ${cdn.url} (${cdn.ok ? "ok" : "failed"})`);
+  console.log(`Cache     ${cache.path} (${cache.items} items, ${cache.mb} MB)`);
+}
+async function readConfigStatus() {
+  const candidatePaths = [
+    path12.join(process.cwd(), "ui8kit.config.json"),
+    path12.join(process.cwd(), "src", "ui8kit.config.json"),
+    path12.join(process.cwd(), SCHEMA_CONFIG.defaultRegistryType, "ui8kit.config.json")
+  ];
+  for (const configPath of candidatePaths) {
+    if (await fs11.pathExists(configPath)) {
+      try {
+        const config = await fs11.readJson(configPath);
+        return {
+          found: true,
+          path: `./${path12.relative(process.cwd(), configPath).replace(/\\/g, "/")}`,
+          config: {
+            framework: config.framework ?? "unknown",
+            typescript: config.typescript ?? false,
+            globalCss: config.globalCss ?? "src/index.css",
+            componentsDir: config.componentsDir ?? SCHEMA_CONFIG.defaultDirectories.components,
+            libDir: config.libDir ?? SCHEMA_CONFIG.defaultDirectories.lib
+          }
+        };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return {
+    found: false,
+    path: null,
+    config: null
+  };
+}
+async function readCacheStatus() {
+  const cachePath = getCacheDir();
+  let items = 0;
+  let bytes = 0;
+  if (await fs11.pathExists(cachePath)) {
+    const result = await countCacheFiles(cachePath);
+    items = result.count;
+    bytes = result.bytes;
+  }
+  return {
+    path: cachePath.replace(/\\/g, "/"),
+    items,
+    mb: `${(bytes / (1024 * 1024)).toFixed(1)}`
+  };
+}
+async function countCacheFiles(dirPath) {
+  let count = 0;
+  let size = 0;
+  const entries = await fs11.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path12.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await countCacheFiles(fullPath);
+      count += nested.count;
+      size += nested.bytes;
+      continue;
+    }
+    count += 1;
+    const stat = await fs11.stat(fullPath);
+    size += stat.size;
+  }
+  return { count, bytes: size };
+}
+async function checkPrimaryCdn() {
+  const url = SCHEMA_CONFIG.cdnBaseUrls[0];
+  try {
+    const response = await fetch4(`${url}/index.json`, { method: "HEAD" });
+    if (response.status >= 200 && response.status < 400) {
+      return { url, ok: true };
+    }
+  } catch {
+  }
+  return { url, ok: false };
+}
+
 // src/index.ts
+import { resolve as resolve2 } from "node:path";
 var program = new Command();
-program.name("ui8kit").description("A CLI for adding UI components to your Vite React projects (UI8Kit registry)").version("0.1.0");
+program.option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-v, --verbose", "Enable verbose output").option("--no-cache", "Bypass registry cache").name("ui8kit").description("A CLI for adding UI components to your Vite React projects (UI8Kit registry)").version(getCliVersion());
+program.command("list").description("List available components in registry").option("-r, --registry <type>", "Registry type: ui", "ui").option("--json", "Output raw JSON").action((options) => listCommand(options));
+program.command("diff").description("Show local vs registry differences").argument("[component]", "Component name").option("-r, --registry <type>", "Registry type: ui", "ui").option("--json", "Output diff in machine-readable JSON").action((component, options) => diffCommand(component, options));
+program.command("cache").description("Manage local cache").command("clear").description("Clear registry cache").action(cacheClearCommand);
+program.command("info").description("Show environment and config diagnostics").option("--json", "Output diagnostics as JSON").action(infoCommand);
 program.command("init").description("Initialize UI8Kit structure in your project").option("-y, --yes", "Skip prompts and use defaults").option("-r, --registry <type>", "Registry type: ui", "ui").action(initCommand);
-program.command("add").description("Add components to your project from the registry").argument("[components...]", "Components to add").option("-a, --all", "Install all available components").option("-f, --force", "Overwrite existing files").option("-r, --registry <type>", "Registry type: ui", "ui").option("--dry-run", "Show what would be installed without installing").option("--retry", "Enable retry logic for unreliable connections").action(addCommand);
-program.command("scan").description("Scan and generate registry from existing components").option("-r, --registry <type|path>", "Registry type (ui) or custom path", "ui").option("-o, --output <file>", "Output registry file").option("-s, --source <dir>", "Source directory to scan").option("--cwd <dir>", "Working directory").action(async (options) => {
+program.command("add").description("Add components to your project from the registry").argument("[components...]", "Components to add").option("-a, --all", "Install all available components").option("-f, --force", "Overwrite existing files").option("-r, --registry <type>", "Registry type: ui", "ui").option("--dry-run", "Show what would be installed without installing").option("--retry", "Aggressive retry mode (3 attempts per CDN request)").action(addCommand);
+program.command("scan").description("Scan and generate registry from existing components").option("-r, --registry <type|path>", "Registry type (ui) or custom path", "ui").option("-o, --output <file>", "Output registry file").option("-s, --source <dir>", "Source directory to scan").action(async (options) => {
   await scanCommand(options);
 });
-program.command("build").description("Build components registry").argument("[registry]", "Path to registry.json file", "./src/registry.json").option("-o, --output <path>", "Output directory", "./packages/registry/r").option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(buildCommand);
+program.command("build").description("Build components registry").argument("[registry]", "Path to registry.json file", "./src/registry.json").option("-o, --output <path>", "Output directory", "./packages/registry/r").action(buildCommand);
 program.on("command:*", () => {
-  console.error(chalk7.red(`Invalid command: ${program.args.join(" ")}`));
+  console.error(chalk12.red(`Invalid command: ${program.args.join(" ")}`));
   console.log("See --help for a list of available commands.");
   process.exit(1);
 });
+program.hook("preAction", (_, actionCommand) => {
+  const actionOptions = actionCommand?.opts?.();
+  const globalOptions = program.opts();
+  const verbose = globalOptions.verbose || actionOptions?.verbose;
+  const cwd = actionOptions?.cwd || globalOptions.cwd;
+  if (verbose) {
+    logger.setVerbose(true);
+  }
+  if (cwd && resolve2(process.cwd()) !== resolve2(cwd)) {
+    process.chdir(cwd);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map