ui8kit 1.0.6 → 1.3.0

package/dist/index.js

@@ -0,0 +1,2930 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk12 from "chalk";
+
+// src/commands/add.ts
+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";
+
+// src/registry/schema.ts
+import { z } from "zod";
+
+// src/utils/schema-config.ts
+var SCHEMA_CONFIG = {
+  // Base schema information
+  schemaVersion: "http://json-schema.org/draft-07/schema#",
+  baseUrl: "https://ui.buildy.tw/schema",
+  // Framework configuration
+  supportedFrameworks: ["vite-react"],
+  // Default aliases for path mapping
+  defaultAliases: {
+    "@": "./src",
+    "@/components": "./src/components",
+    "@/ui": "./src/components/ui",
+    "@/layouts": "./src/layouts",
+    "@/blocks": "./src/blocks",
+    "@/lib": "./src/lib",
+    "@/variants": "./src/variants"
+  },
+  // Registry configuration
+  defaultRegistry: "@ui8kit",
+  registryTypes: ["ui"],
+  // Default registry type
+  defaultRegistryType: "ui",
+  // CDN base URLs (registryName will be substituted)
+  cdnBaseUrls: [
+    "https://cdn.jsdelivr.net/npm/@ui8kit/registry@latest/r",
+    "https://unpkg.com/@ui8kit/registry@latest/r",
+    "https://raw.githubusercontent.com/buildy-ui/ui/main/packages/@ui8kit/registry/r"
+  ],
+  // Component categories
+  componentCategories: ["ui", "composite", "components", "layouts", "lib", "blocks", "variants"],
+  // Component types (should match registryItemTypeSchema)
+  componentTypes: [
+    "registry:lib",
+    "registry:block",
+    "registry:component",
+    "registry:ui",
+    "registry:composite",
+    "registry:layout",
+    "registry:variants"
+  ],
+  // Default directories structure
+  // Source directories (where CLI scans for components)
+  defaultDirectories: {
+    components: "./src/components",
+    lib: "./src/lib",
+    layouts: "./src/layouts",
+    blocks: "./src/blocks",
+    variants: "./src/variants"
+  },
+  // Schema descriptions and titles
+  descriptions: {
+    config: {
+      title: "UI8Kit Configuration",
+      description: "Configuration file for ui8kit CLI (UI8Kit structure)"
+    },
+    registry: {
+      title: "UI8Kit Registry",
+      description: "Registry schema for UI8Kit component system"
+    },
+    registryItem: {
+      title: "UI8Kit Registry Item",
+      description: "Schema for individual registry items in the UI8Kit component system"
+    }
+  },
+  // Field descriptions
+  fieldDescriptions: {
+    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",
+    libDir: "Directory for utility libraries",
+    registryName: "Registry name",
+    registryHomepage: "Registry homepage URL",
+    registryType: "Registry type (e.g., ui)",
+    registryVersion: "Registry version",
+    lastUpdated: "Last update timestamp",
+    categories: "Available component categories",
+    components: "Component metadata for quick lookup",
+    items: "Full component definitions"
+  }
+};
+var TYPE_TO_FOLDER = {
+  "registry:ui": "components/ui",
+  "registry:composite": "components",
+  "registry:block": "blocks",
+  "registry:component": "components",
+  "registry:lib": "lib",
+  "registry:layout": "layouts",
+  "registry:variants": "variants"
+};
+function getCdnUrls(_registryType) {
+  return [...SCHEMA_CONFIG.cdnBaseUrls];
+}
+function isExternalDependency(moduleName) {
+  return !moduleName.startsWith(".") && !moduleName.startsWith("@/") && !moduleName.startsWith("~/") && !moduleName.startsWith("@ui8kit/") && !moduleName.includes("\\") && moduleName !== "" && !moduleName.startsWith("file:");
+}
+function getSchemaRef(schemaName) {
+  return `${SCHEMA_CONFIG.baseUrl}/${schemaName}.json`;
+}
+
+// src/registry/schema.ts
+var componentFileSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+  target: z.string().optional()
+});
+var componentSchema = z.object({
+  name: z.string(),
+  type: z.enum(SCHEMA_CONFIG.componentTypes),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  dependencies: z.array(z.string()).default([]),
+  devDependencies: z.array(z.string()).default([]),
+  registryDependencies: z.array(z.string()).optional(),
+  files: z.array(componentFileSchema),
+  tailwind: z.object({
+    config: z.object({
+      content: z.array(z.string()).optional(),
+      theme: z.record(z.string(), z.any()).optional(),
+      plugins: z.array(z.string()).optional()
+    }).optional()
+  }).optional(),
+  cssVars: z.object({
+    theme: z.record(z.string(), z.string()).optional(),
+    light: z.record(z.string(), z.string()).optional(),
+    dark: z.record(z.string(), z.string()).optional()
+  }).optional(),
+  meta: z.record(z.string(), z.any()).optional()
+});
+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/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;
+  }
+  console.log(`${prefix} ${message}`, ...args);
+}
+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();
+  }
+};
+
+// 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;
+  }
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+async function getCachedJson(key, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  if (options.noCache) {
+    return null;
+  }
+  const { dataPath, metaPath } = cacheFilePath(key);
+  if (!await fs.pathExists(dataPath) || !await fs.pathExists(metaPath)) {
+    return null;
+  }
+  try {
+    const meta = await fs.readJson(metaPath);
+    const lastFetched = parseTimestamp(meta?.lastFetched);
+    const metaTtl = parseTimestamp(meta?.ttl) ?? ttlMs;
+    if (!lastFetched) {
+      return null;
+    }
+    const now = Date.now();
+    if (now - lastFetched > metaTtl) {
+      return null;
+    }
+    return await fs.readJson(dataPath);
+  } catch {
+    return null;
+  }
+}
+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 clearCache() {
+  const cacheDir = getCacheDir();
+  if (await fs.pathExists(cacheDir)) {
+    await fs.remove(cacheDir);
+  }
+}
+
+// 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(path13);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRegistryCache(registryType) {
+  if (!registryCache.has(registryType)) {
+    registryCache.set(registryType, {
+      workingCDN: null,
+      registryIndex: null
+    });
+  }
+  return registryCache.get(registryType);
+}
+async function fetchJsonWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    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);
+  }
+}
+async function fetchJsonWithRetry(url, maxRetries, timeoutMs) {
+  let attempt = 0;
+  let lastError;
+  while (attempt < maxRetries) {
+    attempt += 1;
+    try {
+      return await fetchJsonWithTimeout(url, timeoutMs);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries) {
+        break;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Request failed");
+}
+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);
+  const orderedUrls = cache.workingCDN ? [cache.workingCDN, ...cdnUrls.filter((url) => url !== cache.workingCDN)] : [...cdnUrls];
+  let lastError;
+  for (const baseUrl of orderedUrls) {
+    try {
+      const data = await fetchJsonWithRetry(`${baseUrl}/${requestPath}`, maxRetries, timeoutMs);
+      if (cache.workingCDN !== baseUrl) {
+        cache.registryIndex = null;
+      }
+      cache.workingCDN = baseUrl;
+      return data;
+    } catch (error) {
+      lastError = error;
+      if (cache.workingCDN === baseUrl) {
+        cache.workingCDN = null;
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(`No working ${registryType} CDN found`);
+}
+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;
+  }
+  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 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 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) {
+      logger.debug(`Component ${name} not found in ${registryType} registry`);
+      return null;
+    }
+    const folder = componentInfo.type === "registry:variants" ? "components/variants" : TYPE_TO_FOLDER[componentInfo.type];
+    if (!folder) {
+      logger.debug(`Unknown component type: ${componentInfo.type}`);
+      return null;
+    }
+    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) {
+    logger.debug(`Failed to get component by type: ${error.message}`);
+    return null;
+  }
+}
+async function getComponent(name, registryType = SCHEMA_CONFIG.defaultRegistryType, options = {}) {
+  try {
+    if (isUrl(name)) {
+      return await fetchFromUrl(name, options);
+    }
+    return await getComponentByType(name, registryType, options);
+  } catch (error) {
+    logger.debug(`Failed to fetch ${name} from ${registryType}: ${error.message}`);
+    return null;
+  }
+}
+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 getAllComponents(registryType = SCHEMA_CONFIG.defaultRegistryType, options = {}) {
+  try {
+    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) {
+        if (excludeTypes.includes(componentInfo.type)) {
+          continue;
+        }
+        const component = await getComponent(componentInfo.name, registryType, options);
+        if (component) {
+          components.push(component);
+        }
+      }
+    }
+    return components;
+  } catch (error) {
+    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;
+}
+
+// src/utils/project.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+var MODERN_CONFIG_NAME = "ui8kit.config.json";
+async function isViteProject() {
+  const viteConfigFiles = [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mts",
+    "vite.config.mjs"
+  ];
+  for (const file of viteConfigFiles) {
+    if (await fs2.pathExists(file)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function hasReact() {
+  const packageJsonPath = path2.join(process.cwd(), "package.json");
+  if (!await fs2.pathExists(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = await fs2.readJson(packageJsonPath);
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  return "react" in deps;
+}
+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 (registryConfig)
+      return registryConfig;
+  }
+  return null;
+}
+async function getConfig(registryPath) {
+  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 fs2.readJson(configPath);
+    return configSchema.parse(config);
+  } catch (error) {
+    console.error("\u274C Invalid ui8kit.config.json:", error.message);
+    return null;
+  }
+}
+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 fs2.ensureDir(dirPath);
+}
+
+// src/utils/registry-validator.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+import chalk6 from "chalk";
+import prompts2 from "prompts";
+
+// src/commands/init.ts
+import chalk5 from "chalk";
+import prompts from "prompts";
+import ora3 from "ora";
+
+// src/utils/cli-messages.ts
+var CLI_MESSAGES = {
+  // Error messages
+  errors: {
+    noComponentsSpecified: "Please specify at least one component to add.",
+    notInitialized: "ui8kit is not initialized in this project.",
+    notViteProject: "This doesn't appear to be a Vite project.",
+    reactNotInstalled: "React is not installed in this project.",
+    buildFailed: "Build failed:",
+    scanFailed: "Scan failed:",
+    registryTempUnavailable: "registry temporarily unavailable",
+    noCDNFound: (registryType) => `No working ${registryType} CDN found`,
+    componentNotFound: (name, registryType) => `Component "${name}" not found in ${registryType} registry`,
+    unknownComponentType: (type) => `Unknown component type: ${type}`,
+    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: (path13) => `Warning: Could not analyze dependencies for ${path13}:`,
+    dependenciesFailed: "Failed to install dependencies",
+    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: {
+    initialized: (registryName) => `UI8Kit ${registryName} structure initialized successfully!`,
+    setupComplete: (registryName) => `UI8Kit ${registryName} Setup complete!`,
+    installed: (name, registryType) => `Installed ${name} from ${registryType}`,
+    allInstalled: (registryType) => `All ${registryType} components installed successfully!`,
+    componentsInstalled: "Components installed successfully!",
+    depsInstalled: "Dependencies installed",
+    registryBuilt: "Registry built successfully!",
+    schemasGenerated: "Schema files generated successfully!",
+    registryGenerated: (registryName) => `${registryName} registry generated successfully!`,
+    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: "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...`,
+    building: "Building registry...",
+    processingComponents: "Processing components...",
+    scanningDirectories: "Scanning directories...",
+    analyzingDeps: "Found {count} components, analyzing dependencies...",
+    installationCancelled: "Initialization cancelled.",
+    workspaceDepsDetected: "Workspace dependency detected. Installing individually...",
+    checkingConnection: "Checking internet connection...",
+    testing: (registryType, baseUrl) => `Testing ${registryType} CDN: ${baseUrl}`,
+    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:",
+    checkingForUpdates: "Checking for component updates...",
+    localDiffSummary: "Local components compared with registry."
+  },
+  // Prompts
+  prompts: {
+    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
+  examples: {
+    add: [
+      "Example: npx ui8kit@latest add button card",
+      "Example: npx ui8kit@latest add button --registry ui",
+      "Example: npx ui8kit@latest add all  # Install all components",
+      "Example: npx ui8kit@latest add --all --registry ui  # Install all ui components",
+      "Example: npx ui8kit@latest add --retry  # Enable retry for unreliable connections",
+      'Example: npx ui8kit@latest add "https://example.com/component.json"'
+    ],
+    init: [
+      `npx ui8kit@latest add button --registry ui - Add a button component`,
+      `npx ui8kit@latest add card input --registry ui - Add multiple components`,
+      `npx ui8kit@latest add --all --registry ui - Add all components`,
+      `npx ui8kit@latest add "https://example.com/component.json" - Add from external URL`
+    ],
+    troubleshooting: [
+      "Check your internet connection",
+      "Use --retry flag: npx ui8kit@latest add --all --retry",
+      "Use VPN if available",
+      "Install from URL: npx ui8kit@latest add 'https://...'",
+      "Check https://ui.buildy.tw for manual download"
+    ]
+  },
+  // Directory descriptions
+  directories: {
+    lib: "Utils, helpers, functions",
+    variants: "CVA variant configurations",
+    "components/ui": "UI components",
+    components: "Complex components",
+    layouts: "Page layouts and structures",
+    blocks: "Component blocks"
+  },
+  // Spinners and status
+  status: {
+    installing: (name, registryType) => `Installing ${name} from ${registryType}...`,
+    wouldInstall: (name, registryType) => `Would install: ${name} from ${registryType}`,
+    foundComponents: (count, registryType) => `Found ${count} components in ${registryType}`,
+    wouldInstallFrom: (registryType) => `Would install from ${registryType}:`,
+    builtComponents: (count) => `Built ${count} components`,
+    scannedComponents: (count) => `Scanned ${count} components`,
+    skipped: (fileName) => `Skipped ${fileName} (already exists, use --force to overwrite)`
+  }
+};
+
+// 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: []
+    };
+  }
+  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/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);
+      if (depStatus.workspace.length > 0) {
+        console.log(chalk3.blue(`   \u{1F517} Using workspace dependencies: ${depStatus.workspace.join(", ")}`));
+      }
+      return;
+    }
+    showDependencyStatus(depStatus);
+    const packageManager = await detectPackageManager();
+    const installCommand = packageManager === "npm" ? ["install", ...missingDependencies] : ["add", ...missingDependencies];
+    await execa(packageManager, installCommand, {
+      cwd: process.cwd(),
+      stdio: "pipe"
+    });
+    spinner?.succeed(CLI_MESSAGES.success.depsInstalled);
+  } catch (error) {
+    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((result) => result.success)) {
+        console.log(chalk3.green("\u2705 Some dependencies installed successfully"));
+        return;
+      }
+    }
+    throw new Error(`${CLI_MESSAGES.errors.dependenciesFailed}: ${errorMessage}`);
+  }
+}
+async function installDependenciesIndividually(dependencies) {
+  const packageManager = await detectPackageManager();
+  const results = [];
+  const missingDeps = await filterMissingDependencies(dependencies);
+  for (const dep of missingDeps) {
+    try {
+      const installCommand = packageManager === "npm" ? ["install", dep] : ["add", dep];
+      await execa(packageManager, installCommand, {
+        cwd: process.cwd(),
+        stdio: "pipe"
+      });
+      console.log(chalk3.green(`   \u2705 Installed ${dep}`));
+      results.push({ dep, success: true });
+    } catch {
+      console.log(chalk3.yellow(`   \u26A0\uFE0F  Skipped ${dep} (may already be available)`));
+      results.push({ dep, success: false });
+    }
+  }
+  return results;
+}
+async function detectPackageManager() {
+  let dir = process.cwd();
+  while (true) {
+    if (await fs4.pathExists(path4.join(dir, "bun.lock")) || await fs4.pathExists(path4.join(dir, "bun.lockb"))) {
+      return "bun";
+    }
+    if (await fs4.pathExists(path4.join(dir, "pnpm-lock.yaml")))
+      return "pnpm";
+    if (await fs4.pathExists(path4.join(dir, "yarn.lock")))
+      return "yarn";
+    const packageJsonPath = path4.join(dir, "package.json");
+    if (await fs4.pathExists(packageJsonPath)) {
+      try {
+        const packageJson = await fs4.readJson(packageJsonPath);
+        const packageManager = String(packageJson.packageManager ?? "");
+        if (packageManager.startsWith("bun@"))
+          return "bun";
+        if (packageManager.startsWith("pnpm@"))
+          return "pnpm";
+        if (packageManager.startsWith("yarn@"))
+          return "yarn";
+        if (packageManager.startsWith("npm@"))
+          return "npm";
+      } catch {
+      }
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return "npm";
+}
+
+// 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));
+    }
+    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
+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;
+  logger.info(CLI_MESSAGES.info.initializing(registryName));
+  const viteDetected = await isViteProject();
+  if (!viteDetected) {
+    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(chalk5.red(`\u274C ${CLI_MESSAGES.errors.reactNotInstalled}`));
+    console.log("Please install React first: npm install react react-dom");
+    process.exit(1);
+  }
+  const existingConfig = await findConfig(registryName);
+  if (existingConfig && !options.yes) {
+    const { overwrite } = await prompts({
+      type: "confirm",
+      name: "overwrite",
+      message: CLI_MESSAGES.prompts.overwrite(registryName),
+      initial: false
+    });
+    if (!overwrite) {
+      logger.warn(CLI_MESSAGES.info.installationCancelled);
+      return;
+    }
+  }
+  let config;
+  if (options.yes) {
+    config = buildInitConfig({ yes: true, registry: registryName });
+  } else {
+    const responses = await prompts([
+      {
+        type: "text",
+        name: "globalCss",
+        message: CLI_MESSAGES.prompts.globalCss,
+        initial: "src/index.css"
+      },
+      {
+        type: "text",
+        name: "aliasComponents",
+        message: CLI_MESSAGES.prompts.aliasComponents,
+        initial: "@/components"
+      }
+    ]);
+    const aliasComponents = responses.aliasComponents?.trim() || "@/components";
+    const globalCss = responses.globalCss || "src/index.css";
+    config = buildInitConfig({
+      yes: false,
+      registry: registryName,
+      globalCss,
+      aliasComponents
+    });
+  }
+  const spinner = ora3(CLI_MESSAGES.info.initializing(registryName)).start();
+  try {
+    await saveConfig(config);
+    await ensureDir(config.libDir);
+    await ensureDir(config.componentsDir);
+    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));
+    logger.success(`
+\u2705 ${CLI_MESSAGES.success.setupComplete(registryName)}`);
+    console.log("\nDirectories created:");
+    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(`  ${chalk5.cyan(example)}`));
+  } catch (error) {
+    spinner.fail(CLI_MESSAGES.errors.buildFailed);
+    handleError(error);
+  }
+}
+async function installCoreFiles(registryType, config, spinner) {
+  const cdnUrls = getCdnUrls(registryType);
+  let registryIndex = null;
+  for (const baseUrl of cdnUrls) {
+    try {
+      const indexUrl = `${baseUrl}/index.json`;
+      const response = await fetch2(indexUrl);
+      if (response.ok) {
+        registryIndex = await response.json();
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!registryIndex) {
+    spinner.text = "\u26A0\uFE0F  Could not fetch registry index, creating local utils...";
+    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);
+  }
+  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;
+  }
+  if (SCHEMA_CONFIG.registryTypes.includes(registryInput)) {
+    return registryInput;
+  }
+  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 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");
+          }
+          spinner.succeed("Installed components index");
+          return;
+        }
+      } catch {
+        continue;
+      }
+    }
+    spinner.info("Components index not found in registry (optional)");
+  } catch (error) {
+    spinner.fail("Could not install components index");
+  }
+}
+
+// src/commands/build.ts
+import fs8 from "fs-extra";
+import path9 from "path";
+import chalk7 from "chalk";
+import ora5 from "ora";
+
+// src/registry/build-schema.ts
+import { z as z2 } from "zod";
+var registryItemTypeSchema = z2.enum([
+  "registry:lib",
+  "registry:block",
+  "registry:component",
+  "registry:ui",
+  "registry:composite",
+  "registry:layout",
+  "registry:variants"
+]);
+var registryItemFileSchema = z2.object({
+  path: z2.string(),
+  content: z2.string().optional(),
+  // Populated during build
+  target: z2.string().optional()
+});
+var registryItemTailwindSchema = z2.object({
+  config: z2.object({
+    content: z2.array(z2.string()).optional(),
+    theme: z2.record(z2.string(), z2.any()).optional(),
+    plugins: z2.array(z2.string()).optional()
+  }).optional()
+});
+var registryItemCssVarsSchema = z2.object({
+  theme: z2.record(z2.string(), z2.string()).optional(),
+  light: z2.record(z2.string(), z2.string()).optional(),
+  dark: z2.record(z2.string(), z2.string()).optional()
+});
+var registryItemSchema = z2.object({
+  $schema: z2.string().optional(),
+  name: z2.string(),
+  type: registryItemTypeSchema,
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  dependencies: z2.array(z2.string()).default([]),
+  devDependencies: z2.array(z2.string()).default([]),
+  registryDependencies: z2.array(z2.string()).optional(),
+  files: z2.array(registryItemFileSchema),
+  tailwind: registryItemTailwindSchema.optional(),
+  cssVars: registryItemCssVarsSchema.optional(),
+  meta: z2.record(z2.string(), z2.any()).optional()
+});
+var registrySchema = z2.object({
+  $schema: z2.string().optional(),
+  items: z2.array(registryItemSchema)
+});
+
+// src/utils/schema-generator.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { z as z3 } from "zod";
+var fullRegistrySchema = z3.object({
+  $schema: z3.string().optional(),
+  name: z3.string().optional(),
+  homepage: z3.string().optional(),
+  registry: z3.enum(SCHEMA_CONFIG.registryTypes).optional(),
+  version: z3.string().optional(),
+  lastUpdated: z3.string().optional(),
+  categories: z3.array(z3.enum(SCHEMA_CONFIG.componentCategories)).optional(),
+  components: z3.array(z3.object({
+    name: z3.string(),
+    type: registryItemTypeSchema,
+    description: z3.string().optional()
+  })).optional(),
+  items: z3.array(registryItemSchema)
+});
+function generateConfigSchema() {
+  const baseSchema = zodToJsonSchema(configSchema, {
+    name: "UI8KitConfiguration",
+    $refStrategy: "none"
+  });
+  const actualSchema = baseSchema.definitions?.UI8KitConfiguration || baseSchema;
+  return {
+    "$schema": SCHEMA_CONFIG.schemaVersion,
+    "title": SCHEMA_CONFIG.descriptions.config.title,
+    "description": SCHEMA_CONFIG.descriptions.config.description,
+    "type": "object",
+    "properties": {
+      "$schema": {
+        "type": "string",
+        "description": SCHEMA_CONFIG.fieldDescriptions.schema
+      },
+      "framework": {
+        "type": "string",
+        "enum": SCHEMA_CONFIG.supportedFrameworks,
+        "description": SCHEMA_CONFIG.fieldDescriptions.framework
+      },
+      "typescript": {
+        "type": "boolean",
+        "default": true,
+        "description": SCHEMA_CONFIG.fieldDescriptions.typescript
+      },
+      "globalCss": {
+        "type": "string",
+        "default": "src/index.css",
+        "description": SCHEMA_CONFIG.fieldDescriptions.globalCss
+      },
+      "aliases": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "string"
+        },
+        "default": SCHEMA_CONFIG.defaultAliases,
+        "description": SCHEMA_CONFIG.fieldDescriptions.aliases
+      },
+      "registry": {
+        "type": "string",
+        "default": SCHEMA_CONFIG.defaultRegistry,
+        "description": SCHEMA_CONFIG.fieldDescriptions.registry
+      },
+      "componentsDir": {
+        "type": "string",
+        "default": SCHEMA_CONFIG.defaultDirectories.components,
+        "description": SCHEMA_CONFIG.fieldDescriptions.componentsDir
+      },
+      "libDir": {
+        "type": "string",
+        "default": SCHEMA_CONFIG.defaultDirectories.lib,
+        "description": SCHEMA_CONFIG.fieldDescriptions.libDir
+      }
+    },
+    "required": ["framework"],
+    "additionalProperties": false
+  };
+}
+function generateRegistrySchema() {
+  const baseSchema = zodToJsonSchema(fullRegistrySchema, {
+    name: "UI8KitRegistry",
+    $refStrategy: "none"
+  });
+  const actualSchema = baseSchema.definitions?.UI8KitRegistry || baseSchema;
+  return {
+    "$schema": SCHEMA_CONFIG.schemaVersion,
+    "title": SCHEMA_CONFIG.descriptions.registry.title,
+    "description": SCHEMA_CONFIG.descriptions.registry.description,
+    "type": "object",
+    "properties": {
+      "$schema": {
+        "type": "string",
+        "description": SCHEMA_CONFIG.fieldDescriptions.schema
+      },
+      "name": {
+        "type": "string",
+        "description": SCHEMA_CONFIG.fieldDescriptions.registryName
+      },
+      "homepage": {
+        "type": "string",
+        "description": SCHEMA_CONFIG.fieldDescriptions.registryHomepage
+      },
+      "registry": {
+        "type": "string",
+        "enum": SCHEMA_CONFIG.registryTypes,
+        "description": SCHEMA_CONFIG.fieldDescriptions.registryType
+      },
+      "version": {
+        "type": "string",
+        "description": SCHEMA_CONFIG.fieldDescriptions.registryVersion
+      },
+      "lastUpdated": {
+        "type": "string",
+        "format": "date-time",
+        "description": SCHEMA_CONFIG.fieldDescriptions.lastUpdated
+      },
+      "categories": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "enum": SCHEMA_CONFIG.componentCategories
+        },
+        "description": SCHEMA_CONFIG.fieldDescriptions.categories
+      },
+      "components": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": { "type": "string" },
+            "type": {
+              "type": "string",
+              "enum": actualSchema.properties?.components?.items?.properties?.type?.enum || [
+                "registry:lib",
+                "registry:block",
+                "registry:component",
+                "registry:ui",
+                "registry:template"
+              ]
+            },
+            "description": { "type": "string" }
+          },
+          "required": ["name", "type"],
+          "additionalProperties": false
+        },
+        "description": SCHEMA_CONFIG.fieldDescriptions.components
+      },
+      "items": {
+        "type": "array",
+        "items": { "$ref": getSchemaRef("registry-item") },
+        "description": SCHEMA_CONFIG.fieldDescriptions.items
+      }
+    },
+    "required": ["items"],
+    "additionalProperties": false
+  };
+}
+function generateRegistryItemSchema() {
+  const baseSchema = zodToJsonSchema(registryItemSchema, {
+    name: "UI8KitRegistryItem",
+    $refStrategy: "none"
+  });
+  const actualSchema = baseSchema.definitions?.UI8KitRegistryItem || baseSchema;
+  return {
+    "$schema": SCHEMA_CONFIG.schemaVersion,
+    "title": SCHEMA_CONFIG.descriptions.registryItem.title,
+    "description": SCHEMA_CONFIG.descriptions.registryItem.description,
+    "type": "object",
+    "properties": actualSchema.properties,
+    "required": actualSchema.required || ["name", "type", "files"],
+    "additionalProperties": false
+  };
+}
+
+// src/commands/build.ts
+async function buildCommand(registryPath = "./src/registry.json", options = {}) {
+  const buildOptions = {
+    cwd: path9.resolve(options.cwd || process.cwd()),
+    registryFile: path9.resolve(registryPath),
+    outputDir: path9.resolve(options.output || "./packages/registry/r")
+  };
+  console.log(chalk7.blue(CLI_MESSAGES.info.building));
+  try {
+    const registryContent = await fs8.readFile(buildOptions.registryFile, "utf-8");
+    const registryData = JSON.parse(registryContent);
+    const registry = registrySchema.parse(registryData);
+    await ensureVariantsIndexItem(registry, buildOptions.cwd);
+    await fs8.ensureDir(buildOptions.outputDir);
+    await generateSchemaFiles(buildOptions.outputDir);
+    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 = 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 = 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(chalk7.green(`\u2705 ${CLI_MESSAGES.success.registryBuilt}`));
+    console.log(`Output: ${buildOptions.outputDir}`);
+    console.log(chalk7.green(`\u2705 ${CLI_MESSAGES.success.schemasGenerated}`));
+  } catch (error) {
+    handleError(error);
+  }
+}
+var BUILD_OUTPUT_FOLDERS = {
+  "registry:ui": "components/ui",
+  "registry:composite": "components",
+  "registry:block": "blocks",
+  "registry:component": "components",
+  "registry:lib": "lib",
+  "registry:layout": "layouts",
+  "registry:variants": "components/variants"
+};
+function getOutputDir(type) {
+  const folder = BUILD_OUTPUT_FOLDERS[type];
+  return folder || "misc";
+}
+async function createIndexFile(registry, outputDir) {
+  const index = {
+    $schema: "https://ui.buildy.tw/schema/registry.json",
+    components: registry.items.map((item) => ({
+      name: item.name,
+      type: item.type,
+      title: item.title,
+      description: item.description
+    })),
+    categories: SCHEMA_CONFIG.componentCategories,
+    version: "1.0.0",
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    registry: registry?.registry || SCHEMA_CONFIG.defaultRegistryType
+  };
+  await fs8.writeFile(
+    path9.join(outputDir, "index.json"),
+    JSON.stringify(index, null, 2)
+  );
+}
+async function generateSchemaFiles(outputDir) {
+  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 fs8.writeFile(
+    path9.join(registryBaseDir, "schema.json"),
+    JSON.stringify(configSchemaJson, null, 2)
+  );
+  await fs8.writeFile(
+    path9.join(schemaDir, "registry.json"),
+    JSON.stringify(registrySchemaJson, null, 2)
+  );
+  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 = {
+    name: "index",
+    type: "registry:variants",
+    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.name === "index"
+  );
+  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 importRegex = /import\s+[^;\n]+?from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const moduleName = match[1];
+    if (isExternalDependency(moduleName)) {
+      dependencies.add(moduleName);
+    }
+  }
+  return [...dependencies];
+}
+
+// src/commands/scan.ts
+import fs9 from "fs-extra";
+import path10 from "path";
+import chalk8 from "chalk";
+import ora6 from "ora";
+import { glob } from "glob";
+import * as ts2 from "typescript";
+var DEV_PATTERNS = [
+  "@types/",
+  "eslint",
+  "prettier",
+  "typescript",
+  "jest",
+  "vitest",
+  "testing-library",
+  "@testing-library/",
+  "storybook",
+  "@storybook/",
+  "webpack",
+  "vite",
+  "rollup",
+  "babel",
+  "@babel/",
+  "postcss",
+  "tailwindcss",
+  "autoprefixer"
+];
+async function scanCommand(options = {}) {
+  const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
+  const registryPath = `./${registryName}`;
+  const scanOptions = {
+    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(chalk8.blue(`\u{1F50D} ${CLI_MESSAGES.info.scanningComponents(registryName)}`));
+  try {
+    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(path10.join(variantsDir, "index.ts"), "registry:variants");
+    const componentsIndexItem = await scanSingleFile(path10.join(componentsDir, "index.ts"), "registry:composite");
+    const allComponentsRaw = [
+      ...uiComponents,
+      ...compositeComponents,
+      ...variantComponents,
+      ...variantsIndexItem ? [variantsIndexItem] : [],
+      ...componentsIndexItem ? [componentsIndexItem] : [],
+      ...blockComponents,
+      ...layoutComponents,
+      ...libComponents
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const allComponents = [];
+    for (const comp of allComponentsRaw) {
+      const key = `${comp.type}:${comp.name}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      allComponents.push(comp);
+    }
+    spinner.text = CLI_MESSAGES.info.analyzingDeps.replace("{count}", allComponents.length.toString());
+    for (const component of allComponents) {
+      const analysis = await analyzeComponentDependencies(component.files, scanOptions.cwd);
+      component.dependencies = analysis.dependencies;
+      component.devDependencies = analysis.devDependencies;
+      if (analysis.description && !component.description) {
+        component.description = analysis.description;
+      }
+    }
+    const registry = {
+      $schema: "https://ui.buildy.tw/schema/registry.json",
+      items: allComponents,
+      version: "1.0.0",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      registry: registryName
+    };
+    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(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(chalk8.blue("\n\u{1F4CA} Component Summary:"));
+    Object.entries(summary).forEach(([type, count]) => {
+      console.log(`   ${type}: ${count}`);
+    });
+    const allDeps = /* @__PURE__ */ new Set();
+    const allDevDeps = /* @__PURE__ */ new Set();
+    allComponents.forEach((comp) => {
+      comp.dependencies.forEach((dep) => allDeps.add(dep));
+      comp.devDependencies.forEach((dep) => allDevDeps.add(dep));
+    });
+    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) {
+    handleError(error);
+  }
+}
+async function scanDirectory(dirPath, type, ignorePatterns = []) {
+  if (!await fs9.pathExists(dirPath)) {
+    return [];
+  }
+  const components = [];
+  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 = 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 fs9.readFile(filePath, "utf-8");
+      const description = extractDescription(content);
+      if (!hasValidExports(content)) {
+        continue;
+      }
+      components.push({
+        name: fileName,
+        type,
+        description,
+        dependencies: [],
+        devDependencies: [],
+        files: [{
+          path: relativePath,
+          target: getTargetFromType(type)
+        }]
+      });
+    } catch (error) {
+      console.warn(`Warning: Could not process ${filePath}:`, error.message);
+    }
+  }
+  return components;
+}
+async function scanDirectoryFlat(dirPath, type, ignoreFiles = []) {
+  if (!await fs9.pathExists(dirPath)) {
+    return [];
+  }
+  const components = [];
+  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 = 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 fs9.readFile(filePath, "utf-8");
+      const description = extractDescription(content);
+      if (!hasValidExports(content)) {
+        continue;
+      }
+      components.push({
+        name: fileName,
+        type,
+        description,
+        dependencies: [],
+        devDependencies: [],
+        files: [{
+          path: relativePath,
+          target: getTargetFromType(type)
+        }]
+      });
+    } catch (error) {
+      console.warn(`Warning: Could not process ${filePath}:`, error.message);
+    }
+  }
+  return components;
+}
+async function scanSingleFile(filePath, type) {
+  if (!await fs9.pathExists(filePath)) {
+    return null;
+  }
+  try {
+    const content = await fs9.readFile(filePath, "utf-8");
+    const description = extractDescription(content);
+    if (!hasValidExports(content)) {
+      return null;
+    }
+    const relativePath = path10.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const fileName = path10.basename(filePath, path10.extname(filePath));
+    return {
+      name: fileName,
+      type,
+      description,
+      dependencies: [],
+      devDependencies: [],
+      files: [{
+        path: relativePath,
+        target: getTargetFromType(type)
+      }]
+    };
+  } catch (error) {
+    console.warn(`Warning: Could not process ${filePath}:`, error.message);
+    return null;
+  }
+}
+function extractDescription(content) {
+  const jsdocMatch = content.match(/\/\*\*\s*\n\s*\*\s*(.+?)\s*\n\s*\*\//s);
+  if (jsdocMatch) {
+    return jsdocMatch[1].trim();
+  }
+  const commentMatch = content.match(/^\/\/\s*(.+)$/m);
+  if (commentMatch) {
+    return commentMatch[1].trim();
+  }
+  return "";
+}
+function hasValidExports(content) {
+  return /export\s+(default\s+)?(function|const|class|interface|type)/m.test(content) || /export\s*\{/.test(content);
+}
+async function analyzeComponentDependencies(files, cwd) {
+  const allDependencies = /* @__PURE__ */ new Set();
+  const allDevDependencies = /* @__PURE__ */ new Set();
+  let description;
+  for (const file of files) {
+    try {
+      const filePath = path10.resolve(cwd, file.path);
+      const content = await fs9.readFile(filePath, "utf-8");
+      const sourceFile = ts2.createSourceFile(
+        file.path,
+        content,
+        ts2.ScriptTarget.Latest,
+        true
+      );
+      const analysis = analyzeAST(sourceFile);
+      analysis.dependencies.forEach((dep) => allDependencies.add(dep));
+      analysis.devDependencies.forEach((dep) => allDevDependencies.add(dep));
+      if (analysis.description && !description) {
+        description = analysis.description;
+      }
+    } catch (error) {
+      console.warn(CLI_MESSAGES.errors.failedToAnalyzeDeps(file.path), error.message);
+    }
+  }
+  return {
+    dependencies: Array.from(allDependencies),
+    devDependencies: Array.from(allDevDependencies),
+    description
+  };
+}
+function analyzeAST(sourceFile) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const devDependencies = /* @__PURE__ */ new Set();
+  let description;
+  let hasExports = false;
+  function visit(node) {
+    if (ts2.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (ts2.isStringLiteral(moduleSpecifier)) {
+        const moduleName = moduleSpecifier.text;
+        if (isExternalDependency(moduleName)) {
+          if (isDevDependency(moduleName)) {
+            devDependencies.add(moduleName);
+          } else {
+            dependencies.add(moduleName);
+          }
+        }
+      }
+    }
+    if (ts2.isExportDeclaration(node)) {
+      hasExports = true;
+    } else if (ts2.isExportAssignment(node)) {
+      hasExports = true;
+    } else if (hasExportModifier(node)) {
+      hasExports = true;
+    }
+    const jsDocComment = getJSDocComment(node);
+    if (jsDocComment && !description) {
+      description = jsDocComment;
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return {
+    dependencies: Array.from(dependencies),
+    devDependencies: Array.from(devDependencies),
+    description,
+    hasExports
+  };
+}
+function isDevDependency(moduleName) {
+  return DEV_PATTERNS.some((pattern) => moduleName.includes(pattern));
+}
+function hasExportModifier(node) {
+  if ("modifiers" in node && node.modifiers) {
+    return node.modifiers.some(
+      (mod) => mod.kind === ts2.SyntaxKind.ExportKeyword
+    );
+  }
+  return false;
+}
+function getJSDocComment(node) {
+  try {
+    const jsDocTags = ts2.getJSDocCommentsAndTags(node);
+    for (const tag of jsDocTags) {
+      if (ts2.isJSDoc(tag) && tag.comment) {
+        if (typeof tag.comment === "string") {
+          return tag.comment.trim();
+        } else if (Array.isArray(tag.comment)) {
+          return tag.comment.map((part) => part.text).join("").trim();
+        }
+      }
+    }
+  } catch (error) {
+  }
+  return void 0;
+}
+function getTargetFromType(type) {
+  const folder = TYPE_TO_FOLDER[type];
+  return folder || "components";
+}
+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.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", "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").action(buildCommand);
+program.on("command:*", () => {
+  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