@buildpad/cli 0.1.4

package/dist/index.js

@@ -0,0 +1,2582 @@
+#!/usr/bin/env node
+import {
+  getRegistry,
+  init,
+  loadConfig,
+  resolveSourceFile,
+  saveConfig,
+  sourceFileExists
+} from "./chunk-J4KKVECI.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import prompts from "prompts";
+
+// src/commands/transformer.ts
+import path from "path";
+function getImportMappings(config) {
+  const libAlias = config.aliases.lib;
+  const componentsAlias = config.aliases.components;
+  return [
+    // Types
+    {
+      from: /from ['"]@buildpad\/types['"]/g,
+      to: `from '${libAlias}/types'`
+    },
+    {
+      from: /from ['"]@buildpad\/types\/([^'"]+)['"]/g,
+      to: `from '${libAlias}/types/$1'`
+    },
+    // Services
+    {
+      from: /from ['"]@buildpad\/services['"]/g,
+      to: `from '${libAlias}/services'`
+    },
+    {
+      from: /from ['"]@buildpad\/services\/([^'"]+)['"]/g,
+      to: `from '${libAlias}/services/$1'`
+    },
+    // Hooks
+    {
+      from: /from ['"]@buildpad\/hooks['"]/g,
+      to: `from '${libAlias}/hooks'`
+    },
+    {
+      from: /from ['"]@buildpad\/hooks\/([^'"]+)['"]/g,
+      to: `from '${libAlias}/hooks/$1'`
+    },
+    // UI Interfaces (component to component imports)
+    {
+      from: /from ['"]@buildpad\/ui-interfaces['"]/g,
+      to: `from '${componentsAlias}'`
+    },
+    {
+      from: /from ['"]@buildpad\/ui-interfaces\/([^'"]+)['"]/g,
+      to: `from '${componentsAlias}/$1'`
+    },
+    // UI Collections (component to component imports)
+    {
+      from: /from ['"]@buildpad\/ui-collections['"]/g,
+      to: `from '${componentsAlias}'`
+    },
+    {
+      from: /from ['"]@buildpad\/ui-collections\/([^'"]+)['"]/g,
+      to: `from '${componentsAlias}/$1'`
+    },
+    // Utils
+    {
+      from: /from ['"]@buildpad\/utils['"]/g,
+      to: `from '${libAlias}/utils'`
+    },
+    {
+      from: /from ['"]@buildpad\/utils\/([^'"]+)['"]/g,
+      to: `from '${libAlias}/utils/$1'`
+    },
+    // UI Form (VForm and related components)
+    {
+      from: /from ['"]@buildpad\/ui-form['"]/g,
+      to: `from '${componentsAlias}/vform'`
+    },
+    {
+      from: /from ['"]@buildpad\/ui-form\/([^'"]+)['"]/g,
+      to: `from '${componentsAlias}/vform/$1'`
+    },
+    // UI Table (VTable - type-import pattern MUST come before general pattern
+    // so type imports resolve to vtable-types while value imports resolve to vtable)
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/ui-table['"]/g,
+      to: `import type {$1} from '${componentsAlias}/vtable-types'`
+    },
+    {
+      from: /from ['"]@buildpad\/ui-table['"]/g,
+      to: `from '${componentsAlias}/vtable'`
+    },
+    {
+      from: /from ['"]@buildpad\/ui-table\/([^'"]+)['"]/g,
+      to: `from '${componentsAlias}/$1'`
+    },
+    // Import type statements
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/types['"]/g,
+      to: `import type {$1} from '${libAlias}/types'`
+    },
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/hooks['"]/g,
+      to: `import type {$1} from '${libAlias}/hooks'`
+    },
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/services['"]/g,
+      to: `import type {$1} from '${libAlias}/services'`
+    },
+    // Import type for utils
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/utils['"]/g,
+      to: `import type {$1} from '${libAlias}/utils'`
+    },
+    // Import type for ui-form
+    {
+      from: /import type \{([^}]+)\} from ['"]@buildpad\/ui-form['"]/g,
+      to: `import type {$1} from '${componentsAlias}/vform'`
+    },
+    // Dynamic imports - import('@buildpad/services') etc.
+    {
+      from: /import\s*\(\s*['"]@buildpad\/services['"]\s*\)/g,
+      to: `import('${libAlias}/services')`
+    },
+    {
+      from: /import\s*\(\s*['"]@buildpad\/hooks['"]\s*\)/g,
+      to: `import('${libAlias}/hooks')`
+    },
+    {
+      from: /import\s*\(\s*['"]@buildpad\/types['"]\s*\)/g,
+      to: `import('${libAlias}/types')`
+    },
+    {
+      from: /import\s*\(\s*['"]@buildpad\/utils['"]\s*\)/g,
+      to: `import('${libAlias}/utils')`
+    }
+  ];
+}
+function transformImports(content, config, targetPath) {
+  const mappings = getImportMappings(config);
+  let result = content;
+  for (const mapping of mappings) {
+    result = result.replace(mapping.from, mapping.to);
+  }
+  result = normalizeImportPaths(result, targetPath);
+  return result;
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function normalizeImportPaths(content, targetPath) {
+  if (content.includes("@buildpad-preserve-casing")) {
+    return content;
+  }
+  if (targetPath && (targetPath.includes("/vform/") || targetPath.includes("/ui-form/") || targetPath.includes("VForm") || targetPath.includes("FormField"))) {
+    return content;
+  }
+  const pascalCaseImportPattern = /from\s+['"](\.\.\/?|\.\/)([A-Z][a-zA-Z0-9]*(?:\/[A-Z][a-zA-Z0-9]*)?)['"]/g;
+  let result = content.replace(pascalCaseImportPattern, (_match, prefix, importPath) => {
+    const parts = importPath.split("/");
+    const fileName = parts[parts.length - 1];
+    const kebabFileName = toKebabCase(fileName);
+    if (prefix === "../" && parts.length >= 1) {
+      return `from './${kebabFileName}'`;
+    }
+    return `from '${prefix}${kebabFileName}'`;
+  });
+  const dynamicImportPattern = /import\s*\(\s*['"](\.\/)([A-Z][a-zA-Z0-9]*)['"]\s*\)/g;
+  result = result.replace(dynamicImportPattern, (_match, prefix, componentName) => {
+    const kebabName = toKebabCase(componentName);
+    return `import('${prefix}${kebabName}')`;
+  });
+  return result;
+}
+function transformIntraComponentImports(content, sourceFile, targetFile, fileMappings) {
+  if (!fileMappings || fileMappings.length <= 1) return content;
+  const sourceDir = path.posix.dirname(sourceFile);
+  const targetDir = path.posix.dirname(targetFile);
+  const sourceToTarget = /* @__PURE__ */ new Map();
+  const sourceToTargetExt = /* @__PURE__ */ new Map();
+  for (const fm of fileMappings) {
+    sourceToTarget.set(fm.source.replace(/\.\w+$/, ""), fm.target.replace(/\.\w+$/, ""));
+    sourceToTargetExt.set(fm.source, fm.target);
+  }
+  let result = content.replace(
+    /from\s+(['"])(\.[^'"]+)\1/g,
+    (match, _quote, importPath) => {
+      const resolved = path.posix.join(sourceDir, importPath);
+      const resolvedNoExt = resolved.replace(/\.\w+$/, "");
+      const mapped = sourceToTarget.get(resolvedNoExt) ?? sourceToTarget.get(resolved);
+      if (mapped) {
+        let rel = path.posix.relative(targetDir, mapped);
+        if (!rel.startsWith(".")) rel = "./" + rel;
+        return match.replace(importPath, rel);
+      }
+      return match;
+    }
+  );
+  result = result.replace(
+    /import\s+(['"])(\.[^'"]+)\1/g,
+    (match, _quote, importPath) => {
+      const resolved = path.posix.join(sourceDir, importPath);
+      const mappedExt = sourceToTargetExt.get(resolved);
+      if (mappedExt) {
+        let rel = path.posix.relative(targetDir, mappedExt);
+        if (!rel.startsWith(".")) rel = "./" + rel;
+        return match.replace(importPath, rel);
+      }
+      const resolvedNoExt = resolved.replace(/\.\w+$/, "");
+      const mapped = sourceToTarget.get(resolvedNoExt);
+      if (mapped) {
+        let rel = path.posix.relative(targetDir, mapped);
+        if (!rel.startsWith(".")) rel = "./" + rel;
+        return match.replace(importPath, rel);
+      }
+      return match;
+    }
+  );
+  return result;
+}
+var RELATIVE_IMPORT_MAPPINGS = {
+  // file-image/FileImage.tsx imports from ../upload → ./upload
+  "../upload": "./upload"
+  // file/File.tsx imports from ../upload → ./upload
+  // files/Files.tsx imports from ../upload → ./upload
+  // list-o2m imports from ../upload → ./upload
+};
+var VFORM_IMPORT_MAPPINGS = {
+  // Files in vform/components/ folder
+  "components": {
+    "../types": "../types",
+    "./types": "../types"
+  },
+  // Files in vform/utils/ folder  
+  "utils": {
+    "../types": "../types",
+    "./types": "../types"
+  },
+  // Files in vform/ root folder
+  "root": {
+    "./types": "./types"
+  }
+};
+function transformVFormImports(content, sourceFile, _targetFile) {
+  let result = content;
+  let folder = "root";
+  if (sourceFile.includes("/components/")) {
+    folder = "components";
+  } else if (sourceFile.includes("/utils/")) {
+    folder = "utils";
+  }
+  const mappings = VFORM_IMPORT_MAPPINGS[folder] || {};
+  for (const [from, to] of Object.entries(mappings)) {
+    const importPattern = new RegExp(
+      `(from\\s+['"])${from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(['"])`,
+      "g"
+    );
+    result = result.replace(importPattern, `$1${to}$2`);
+  }
+  return result;
+}
+function transformRelativeImports(content, _sourceFile, _targetFile, _componentsAlias) {
+  let result = content;
+  for (const [from, to] of Object.entries(RELATIVE_IMPORT_MAPPINGS)) {
+    const importPattern = new RegExp(
+      `(from\\s+['"])${from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(['"])`,
+      "g"
+    );
+    result = result.replace(importPattern, `$1${to}$2`);
+  }
+  const siblingImportPattern = /from\s+['"](\.\.\/([a-z][-a-z0-9]*)(?:\/[A-Z][a-zA-Z]*)?)['"]/g;
+  result = result.replace(siblingImportPattern, (_match, _fullPath, componentFolder) => {
+    const kebabName = toKebabCase(componentFolder);
+    return `from './${kebabName}'`;
+  });
+  return result;
+}
+function generateOriginHeader(componentName, sourcePackage, version = "1.0.0") {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `/**
+ * @buildpad-origin ${sourcePackage}/${componentName}
+ * @buildpad-version ${version}
+ * @buildpad-date ${timestamp}
+ * 
+ * This file was copied from Buildpad UI Packages.
+ * To update, run: npx @buildpad/cli add ${componentName} --overwrite
+ * 
+ * Docs: https://buildpad.dev/components/${componentName}
+ */
+
+`;
+}
+function addOriginHeader(content, componentName, sourcePackage, version = "1.0.0") {
+  const header = generateOriginHeader(componentName, sourcePackage, version);
+  const useClientMatch = content.match(/^(["']use client["'];?\s*\n)/);
+  if (useClientMatch) {
+    return useClientMatch[1] + header + content.slice(useClientMatch[0].length);
+  }
+  return header + content;
+}
+function hasBuildpadOrigin(content) {
+  return content.includes("@buildpad-origin");
+}
+function extractOriginInfo(content) {
+  const originMatch = content.match(/@buildpad-origin\s+([^\n*]+)/);
+  const versionMatch = content.match(/@buildpad-version\s+([^\n*]+)/);
+  const dateMatch = content.match(/@buildpad-date\s+([^\n*]+)/);
+  if (!originMatch) return null;
+  return {
+    origin: originMatch[1].trim(),
+    version: versionMatch?.[1].trim(),
+    date: dateMatch?.[1].trim()
+  };
+}
+
+// src/commands/validate.ts
+import fs from "fs-extra";
+import path2 from "path";
+import chalk from "chalk";
+import ora from "ora";
+import fg from "fast-glob";
+import { execSync } from "child_process";
+async function checkUntransformedImports(cwd, config) {
+  const errors = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const patterns = [
+    path2.join(srcDir, "components/**/*.{ts,tsx,js,jsx}"),
+    path2.join(srcDir, "lib/buildpad/**/*.{ts,tsx,js,jsx}")
+  ];
+  for (const pattern of patterns) {
+    const files = await fg(pattern, { ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      const content = await fs.readFile(file, "utf-8");
+      const lines = content.split("\n");
+      lines.forEach((line, index) => {
+        if ((line.includes("from '@buildpad/") || line.includes('from "@buildpad/')) && !line.trim().startsWith("//") && !line.trim().startsWith("*")) {
+          errors.push({
+            file: path2.relative(cwd, file),
+            line: index + 1,
+            message: `Untransformed import: ${line.trim()}`,
+            code: "UNTRANSFORMED_IMPORT"
+          });
+        }
+      });
+    }
+  }
+  return errors;
+}
+async function checkMissingCssFiles(cwd, config) {
+  const warnings = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const componentsDir = path2.join(srcDir, "components/ui");
+  const cssRequirements = {
+    "input-block-editor.tsx": "InputBlockEditor.css",
+    "rich-text-html.tsx": "RichTextHTML.css",
+    "rich-text-markdown.tsx": "RichTextMarkdown.css"
+  };
+  for (const [component, cssFile] of Object.entries(cssRequirements)) {
+    const componentPath = path2.join(componentsDir, component);
+    const cssPath = path2.join(componentsDir, cssFile);
+    if (fs.existsSync(componentPath) && !fs.existsSync(cssPath)) {
+      warnings.push({
+        file: cssFile,
+        message: `Missing CSS file for ${component}`,
+        code: "MISSING_CSS"
+      });
+    }
+  }
+  return warnings;
+}
+async function checkLibModules(cwd, config) {
+  const errors = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const libDir = path2.join(srcDir, "lib/buildpad");
+  const requiredModules = {
+    types: ["types/index.ts", "types/core.ts"],
+    services: ["services/index.ts", "services/api-request.ts"],
+    hooks: ["hooks/index.ts"],
+    utils: ["utils.ts", "field-interface-mapper.ts"]
+  };
+  for (const [module, files] of Object.entries(requiredModules)) {
+    if (config.installedLib.includes(module)) {
+      for (const file of files) {
+        const filePath = path2.join(libDir, file);
+        if (!fs.existsSync(filePath)) {
+          errors.push({
+            file: `lib/buildpad/${file}`,
+            message: `Missing required file for ${module} module`,
+            code: "MISSING_LIB_FILE"
+          });
+        }
+      }
+    }
+  }
+  const defineInterfacePath = path2.join(libDir, "define-interface.ts");
+  const interfaceRegistryPath = path2.join(libDir, "interface-registry.ts");
+  if (fs.existsSync(defineInterfacePath) && !fs.existsSync(interfaceRegistryPath)) {
+    errors.push({
+      file: "lib/buildpad/interface-registry.ts",
+      message: "Missing interface-registry.ts (required by define-interface.ts)",
+      code: "MISSING_INTERFACE_REGISTRY"
+    });
+  }
+  return errors;
+}
+async function checkSsrIssues(cwd, config) {
+  const warnings = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const componentsDir = path2.join(srcDir, "components/ui");
+  const indexPath = path2.join(componentsDir, "index.ts");
+  if (fs.existsSync(indexPath)) {
+    const content = await fs.readFile(indexPath, "utf-8");
+    if (content.includes("InputBlockEditor") && !content.includes("input-block-editor-wrapper") && content.includes("from './input-block-editor'")) {
+      warnings.push({
+        file: "components/ui/index.ts",
+        message: "InputBlockEditor exported directly may cause SSR errors. Use input-block-editor-wrapper instead.",
+        code: "SSR_UNSAFE_EXPORT"
+      });
+    }
+  }
+  return warnings;
+}
+async function checkApiRoutes(cwd) {
+  const warnings = [];
+  const srcDir = fs.existsSync(path2.join(cwd, "src/app")) ? path2.join(cwd, "src") : cwd;
+  const appDir = path2.join(srcDir, "app");
+  const apiDir = path2.join(appDir, "api");
+  const requiredRoutes = [
+    { path: "fields/[collection]/route.ts", description: "Fetch collection field schemas" },
+    { path: "items/[collection]/route.ts", description: "List/Create items" },
+    { path: "items/[collection]/[id]/route.ts", description: "Get/Update/Delete item" }
+  ];
+  const recommendedRoutes = [
+    { path: "relations/route.ts", description: "Relation definitions (for M2M/M2O/O2M)" },
+    { path: "files/route.ts", description: "File operations (for file components)" }
+  ];
+  if (!fs.existsSync(apiDir)) {
+    warnings.push({
+      file: "app/api/",
+      message: "Missing API directory. Forms require API routes to fetch data from DaaS.",
+      code: "MISSING_API_DIR"
+    });
+    return warnings;
+  }
+  for (const route of requiredRoutes) {
+    const routePath = path2.join(apiDir, route.path);
+    if (!fs.existsSync(routePath)) {
+      warnings.push({
+        file: `app/api/${route.path}`,
+        message: `Missing required API route: ${route.description}`,
+        code: "MISSING_API_ROUTE"
+      });
+    }
+  }
+  for (const route of recommendedRoutes) {
+    const routePath = path2.join(apiDir, route.path);
+    if (!fs.existsSync(routePath)) {
+      warnings.push({
+        file: `app/api/${route.path}`,
+        message: `Missing recommended API route: ${route.description}`,
+        code: "MISSING_OPTIONAL_API_ROUTE"
+      });
+    }
+  }
+  const authHeadersPath = path2.join(srcDir, "lib/api/auth-headers.ts");
+  if (!fs.existsSync(authHeadersPath)) {
+    warnings.push({
+      file: "lib/api/auth-headers.ts",
+      message: "Missing auth-headers helper. API routes need this to forward auth tokens.",
+      code: "MISSING_AUTH_HELPER"
+    });
+  }
+  return warnings;
+}
+async function checkBrokenRelativeImports(cwd, config) {
+  const errors = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const patterns = [
+    path2.join(srcDir, "components/**/*.{ts,tsx,js,jsx}"),
+    path2.join(srcDir, "lib/buildpad/**/*.{ts,tsx,js,jsx}")
+  ];
+  const relativeImportPattern = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+  for (const pattern of patterns) {
+    const files = await fg(pattern, { ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      const content = await fs.readFile(file, "utf-8");
+      const lines = content.split("\n");
+      const fileDir = path2.dirname(file);
+      lines.forEach((line, index) => {
+        if (line.trim().startsWith("//") || line.trim().startsWith("*")) {
+          return;
+        }
+        let match;
+        relativeImportPattern.lastIndex = 0;
+        while ((match = relativeImportPattern.exec(line)) !== null) {
+          const importPath = match[1];
+          const possibleExtensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx", ""];
+          const absolutePath = path2.resolve(fileDir, importPath);
+          const exists = possibleExtensions.some(
+            (ext) => fs.existsSync(absolutePath + ext)
+          );
+          if (!exists) {
+            errors.push({
+              file: path2.relative(cwd, file),
+              line: index + 1,
+              message: `Cannot find module '${importPath}'`,
+              code: "BROKEN_IMPORT"
+            });
+          }
+        }
+      });
+    }
+  }
+  return errors;
+}
+async function checkReact19Compatibility(cwd, config) {
+  const warnings = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const appDir = path2.join(srcDir, "app");
+  if (!fs.existsSync(appDir)) {
+    return warnings;
+  }
+  const serverComponentPattern = path2.join(appDir, "**/page.tsx");
+  const files = await fg(serverComponentPattern, { ignore: ["**/node_modules/**"] });
+  const componentPropPattern = /component=\{[A-Z][a-zA-Z]*\}/;
+  for (const file of files) {
+    const content = await fs.readFile(file, "utf-8");
+    if (content.includes('"use client"') || content.includes("'use client'")) {
+      continue;
+    }
+    const lines = content.split("\n");
+    lines.forEach((line, index) => {
+      if (componentPropPattern.test(line)) {
+        warnings.push({
+          file: path2.relative(cwd, file),
+          line: index + 1,
+          message: 'Passing component as prop in Server Component may cause React 19 errors. Add "use client" or use wrapper pattern.',
+          code: "REACT19_COMPONENT_PROP"
+        });
+      }
+    });
+  }
+  return warnings;
+}
+async function checkDuplicateExports(cwd, config) {
+  const warnings = [];
+  const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+  const indexPath = path2.join(srcDir, "components/ui/index.ts");
+  if (!fs.existsSync(indexPath)) {
+    return warnings;
+  }
+  const content = await fs.readFile(indexPath, "utf-8");
+  const exportPattern = /export \* from ['"]\.\/([^'"]+)['"]/g;
+  const exports = /* @__PURE__ */ new Map();
+  let match;
+  let lineNum = 0;
+  const lines = content.split("\n");
+  for (const line of lines) {
+    lineNum++;
+    exportPattern.lastIndex = 0;
+    while ((match = exportPattern.exec(line)) !== null) {
+      const exportPath = match[1];
+      if (exports.has(exportPath)) {
+        warnings.push({
+          file: "components/ui/index.ts",
+          line: lineNum,
+          message: `Duplicate export from './${exportPath}' (first at line ${exports.get(exportPath)})`,
+          code: "DUPLICATE_EXPORT"
+        });
+      } else {
+        exports.set(exportPath, lineNum);
+      }
+    }
+  }
+  const componentsDir = path2.join(srcDir, "components/ui");
+  const namedExports = /* @__PURE__ */ new Map();
+  for (const [exportFile] of exports) {
+    const filePath = path2.join(componentsDir, exportFile + ".tsx");
+    if (!fs.existsSync(filePath)) continue;
+    const fileContent = await fs.readFile(filePath, "utf-8");
+    const namedExportPattern = /export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/g;
+    let namedMatch;
+    while ((namedMatch = namedExportPattern.exec(fileContent)) !== null) {
+      const exportName = namedMatch[1];
+      if (namedExports.has(exportName)) {
+        const firstExport = namedExports.get(exportName);
+        warnings.push({
+          file: `components/ui/${exportFile}.tsx`,
+          message: `Conflicting export '${exportName}' also exported from '${firstExport.file}'. This will cause 'export *' conflicts in index.ts`,
+          code: "CONFLICTING_NAMED_EXPORT"
+        });
+      } else {
+        namedExports.set(exportName, { file: exportFile, line: 0 });
+      }
+    }
+  }
+  return warnings;
+}
+async function checkTypeScriptErrors(cwd, config) {
+  const errors = [];
+  const tsconfigPath = path2.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    return errors;
+  }
+  try {
+    const srcDir = config.srcDir ? path2.join(cwd, "src") : cwd;
+    const componentsDir = path2.join(srcDir, "components/ui");
+    if (!fs.existsSync(componentsDir)) {
+      return errors;
+    }
+    const result = execSync(
+      `npx --yes tsc --noEmit --skipLibCheck --pretty false 2>&1 || true`,
+      { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, timeout: 6e4, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const tsErrorPattern = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/gm;
+    let match;
+    while ((match = tsErrorPattern.exec(result)) !== null) {
+      const [, file, line, , severity, tsCode, message] = match;
+      const relativePath = path2.relative(cwd, file);
+      if (relativePath.includes("components/ui") || relativePath.includes("lib/buildpad")) {
+        if (severity === "error") {
+          errors.push({
+            file: relativePath,
+            line: parseInt(line, 10),
+            message: `${tsCode}: ${message}`,
+            code: "TYPESCRIPT_ERROR"
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return errors;
+}
+function generateSuggestions(errors, warnings) {
+  const suggestions = [];
+  const tsErrorCount = errors.filter((e) => e.code === "TYPESCRIPT_ERROR").length;
+  if (tsErrorCount > 0) {
+    suggestions.push(
+      `Fix ${tsErrorCount} TypeScript error(s) in component files`
+    );
+  }
+  const untransformedCount = errors.filter((e) => e.code === "UNTRANSFORMED_IMPORT").length;
+  if (untransformedCount > 0) {
+    suggestions.push(
+      `Fix ${untransformedCount} untransformed import(s) by running: pnpm cli add --all --overwrite --cwd .`
+    );
+  }
+  const brokenImportCount = errors.filter((e) => e.code === "BROKEN_IMPORT").length;
+  if (brokenImportCount > 0) {
+    suggestions.push(
+      `Fix ${brokenImportCount} broken import(s) by checking file paths or reinstalling components`
+    );
+  }
+  const missingLibCount = errors.filter((e) => e.code === "MISSING_LIB_FILE").length;
+  if (missingLibCount > 0) {
+    suggestions.push(
+      `Reinstall lib modules with: pnpm cli add vform --overwrite --cwd .`
+    );
+  }
+  if (errors.some((e) => e.code === "MISSING_INTERFACE_REGISTRY")) {
+    suggestions.push(
+      `Add missing interface-registry.ts by reinstalling utils module`
+    );
+  }
+  const missingCssCount = warnings.filter((w) => w.code === "MISSING_CSS").length;
+  if (missingCssCount > 0) {
+    suggestions.push(
+      `Copy missing CSS files from buildpad-ui/packages/ui-interfaces/src/`
+    );
+  }
+  if (warnings.some((w) => w.code === "SSR_UNSAFE_EXPORT")) {
+    suggestions.push(
+      `Update components/ui/index.ts to export InputBlockEditor from './input-block-editor-wrapper'`
+    );
+  }
+  const missingRouteCount = warnings.filter((w) => w.code === "MISSING_API_ROUTE").length;
+  const missingApiDir = warnings.some((w) => w.code === "MISSING_API_DIR");
+  const missingAuthHelper = warnings.some((w) => w.code === "MISSING_AUTH_HELPER");
+  if (missingApiDir || missingRouteCount > 0 || missingAuthHelper) {
+    suggestions.push(
+      `Install API routes and auth helpers: pnpm cli add api-routes --cwd .`
+    );
+  }
+  const react19Count = warnings.filter((w) => w.code === "REACT19_COMPONENT_PROP").length;
+  if (react19Count > 0) {
+    suggestions.push(
+      `Fix ${react19Count} React 19 compatibility issue(s): wrap component with "use client" or use Link directly`
+    );
+  }
+  const duplicateCount = warnings.filter((w) => w.code === "DUPLICATE_EXPORT").length;
+  if (duplicateCount > 0) {
+    suggestions.push(
+      `Remove ${duplicateCount} duplicate export(s) from components/ui/index.ts`
+    );
+  }
+  return suggestions;
+}
+async function validate(options) {
+  const { cwd, json = false, noExit = false } = options;
+  const config = await loadConfig(cwd);
+  if (!config) {
+    if (json) {
+      console.log(JSON.stringify({
+        valid: false,
+        errors: [{ file: "buildpad.json", message: "Not found", code: "NO_CONFIG" }],
+        warnings: [],
+        suggestions: ['Run "npx buildpad init" first']
+      }));
+    } else {
+      console.log(chalk.red('\n\u2717 buildpad.json not found. Run "npx buildpad init" first.\n'));
+    }
+    if (noExit) {
+      return { valid: false, errors: [{ file: "buildpad.json", message: "Not found", code: "NO_CONFIG" }], warnings: [], suggestions: ['Run "npx buildpad init" first'] };
+    }
+    process.exit(1);
+  }
+  const spinner = json ? null : ora("Validating Buildpad installation...").start();
+  try {
+    const [
+      untransformedErrors,
+      brokenImportErrors,
+      missingCssWarnings,
+      libModuleErrors,
+      ssrWarnings,
+      apiRouteWarnings,
+      react19Warnings,
+      duplicateExportWarnings
+    ] = await Promise.all([
+      checkUntransformedImports(cwd, config),
+      checkBrokenRelativeImports(cwd, config),
+      checkMissingCssFiles(cwd, config),
+      checkLibModules(cwd, config),
+      checkSsrIssues(cwd, config),
+      checkApiRoutes(cwd),
+      checkReact19Compatibility(cwd, config),
+      checkDuplicateExports(cwd, config)
+    ]);
+    if (spinner) {
+      spinner.text = "Running TypeScript check...";
+    }
+    const tsErrors = await checkTypeScriptErrors(cwd, config);
+    const errors = [...untransformedErrors, ...brokenImportErrors, ...libModuleErrors, ...tsErrors];
+    const warnings = [...missingCssWarnings, ...ssrWarnings, ...apiRouteWarnings, ...react19Warnings, ...duplicateExportWarnings];
+    const suggestions = generateSuggestions(errors, warnings);
+    const result = {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions
+    };
+    if (noExit) {
+      spinner?.stop();
+      return result;
+    }
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+    if (errors.length === 0 && warnings.length === 0) {
+      spinner?.succeed(chalk.green("Buildpad installation is valid! \u2713"));
+      console.log(chalk.dim(`
+  ${config.installedComponents.length} components installed`));
+      console.log(chalk.dim(`  ${config.installedLib.length} lib modules installed
+`));
+      return result;
+    }
+    spinner?.stop();
+    if (errors.length > 0) {
+      console.log(chalk.red(`
+\u2717 Found ${errors.length} error(s):
+`));
+      errors.forEach((error) => {
+        const location = error.line ? `:${error.line}` : "";
+        console.log(chalk.red(`  \u2717 ${error.file}${location}`));
+        console.log(chalk.dim(`    ${error.message}`));
+      });
+    }
+    if (warnings.length > 0) {
+      console.log(chalk.yellow(`
+\u26A0 Found ${warnings.length} warning(s):
+`));
+      warnings.forEach((warning) => {
+        console.log(chalk.yellow(`  \u26A0 ${warning.file}`));
+        console.log(chalk.dim(`    ${warning.message}`));
+      });
+    }
+    if (suggestions.length > 0) {
+      console.log(chalk.cyan("\n\u{1F4A1} Suggestions:\n"));
+      suggestions.forEach((suggestion, i) => {
+        console.log(chalk.cyan(`  ${i + 1}. ${suggestion}`));
+      });
+    }
+    console.log();
+    if (errors.length > 0) {
+      process.exit(1);
+    }
+    return result;
+  } catch (error) {
+    spinner?.fail("Validation failed");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/add.ts
+async function getRegistry2() {
+  try {
+    return await getRegistry();
+  } catch (err) {
+    console.error(chalk2.red("Failed to load registry:", err.message));
+    process.exit(1);
+  }
+}
+var COMPONENT_ALIASES = {
+  "form": "vform",
+  "dynamicform": "vform",
+  "v-form": "vform",
+  "select": "select-dropdown",
+  "dropdown": "select-dropdown",
+  "checkbox": "boolean",
+  "switch": "toggle",
+  "date": "datetime",
+  "time": "datetime",
+  "datepicker": "datetime",
+  "text": "input",
+  "textinput": "input",
+  "textfield": "input",
+  "image": "file-image",
+  "imageupload": "file-image",
+  "wysiwyg": "rich-text-html",
+  "richtext": "rich-text-html",
+  "markdown": "rich-text-markdown",
+  "md": "rich-text-markdown",
+  "m2m": "list-m2m",
+  "m2o": "list-m2o",
+  "o2m": "list-o2m",
+  "m2a": "list-m2a",
+  "manytomany": "list-m2m",
+  "manytoone": "list-m2o",
+  "onetomany": "list-o2m",
+  "manytoany": "list-m2a",
+  "relation": "list-m2o",
+  "multiselect": "select-multiple-dropdown",
+  "checkboxes": "select-multiple-checkbox",
+  "radio": "select-radio",
+  "icon": "select-icon",
+  "colorpicker": "color",
+  "fileupload": "file",
+  "code": "input-code",
+  "blockeditor": "input-block-editor",
+  "editor": "input-block-editor"
+};
+function findComponentWithSuggestions(name, registry) {
+  const normalized = name.toLowerCase().replace(/-/g, "");
+  const directMatch = registry.components.find(
+    (c) => c.name.toLowerCase() === name.toLowerCase()
+  );
+  if (directMatch) return directMatch;
+  const titleMatch = registry.components.find(
+    (c) => c.title.toLowerCase() === name.toLowerCase()
+  );
+  if (titleMatch) return titleMatch;
+  const fuzzyMatch = registry.components.find(
+    (c) => c.name.toLowerCase().replace(/-/g, "") === normalized || c.title.toLowerCase().replace(/-/g, "") === normalized
+  );
+  if (fuzzyMatch) return fuzzyMatch;
+  const aliasedName = COMPONENT_ALIASES[normalized];
+  if (aliasedName) {
+    const aliasMatch = registry.components.find((c) => c.name === aliasedName);
+    if (aliasMatch) {
+      console.log(chalk2.yellow(`
+\u{1F4A1} "${name}" matched alias \u2192 using "${aliasMatch.name}"
+`));
+      return aliasMatch;
+    }
+  }
+  console.log(chalk2.red(`
+\u2717 Component not found: ${name}
+`));
+  const suggestions = registry.components.map((c) => ({
+    component: c,
+    score: calculateSimilarity(normalized, c.name.replace(/-/g, "")) + calculateSimilarity(normalized, c.title.toLowerCase().replace(/-/g, "")) + (c.description.toLowerCase().includes(name.toLowerCase()) ? 0.3 : 0)
+  })).filter((s) => s.score > 0.2).sort((a, b) => b.score - a.score).slice(0, 5);
+  if (suggestions.length > 0) {
+    console.log(chalk2.yellow("Did you mean one of these?\n"));
+    suggestions.forEach((s) => {
+      console.log(`  ${chalk2.green(s.component.name.padEnd(28))} ${chalk2.dim(s.component.description)}`);
+    });
+    console.log();
+  }
+  const categoryHint = registry.categories.find(
+    (cat) => name.toLowerCase().includes(cat.name.toLowerCase())
+  );
+  if (categoryHint) {
+    console.log(chalk2.dim(`Try: buildpad add --category ${categoryHint.name}
+`));
+  }
+  console.log(chalk2.dim("Commands to help you find components:"));
+  console.log(chalk2.dim("  buildpad list              List all components"));
+  console.log(chalk2.dim("  buildpad list --category   Filter by category"));
+  console.log(chalk2.dim("  buildpad info <name>       Get component details\n"));
+  return null;
+}
+function calculateSimilarity(a, b) {
+  if (a === b) return 1;
+  if (a.includes(b) || b.includes(a)) return 0.7;
+  let matches = 0;
+  const shorter = a.length < b.length ? a : b;
+  const longer = a.length < b.length ? b : a;
+  for (let i = 0; i < shorter.length; i++) {
+    if (longer.includes(shorter[i])) matches++;
+  }
+  return matches / longer.length;
+}
+async function copyLibModule(moduleName, registry, config, cwd, spinner) {
+  const libModule = registry.lib[moduleName];
+  if (!libModule) {
+    spinner.warn(`Lib module not found: ${moduleName}`);
+    return false;
+  }
+  if (config.installedLib.includes(moduleName)) {
+    return true;
+  }
+  if (libModule.internalDependencies) {
+    for (const dep of libModule.internalDependencies) {
+      if (!config.installedLib.includes(dep)) {
+        await copyLibModule(dep, registry, config, cwd, spinner);
+      }
+    }
+  }
+  if (libModule.path && libModule.target) {
+    const targetPath = path3.join(
+      config.srcDir ? path3.join(cwd, "src") : cwd,
+      libModule.target
+    );
+    if (await sourceFileExists(libModule.path)) {
+      let content = await resolveSourceFile(libModule.path);
+      content = transformImports(content, config);
+      content = addOriginHeader(content, moduleName, "@buildpad/lib", registry.version);
+      await fs2.ensureDir(path3.dirname(targetPath));
+      await fs2.writeFile(targetPath, content);
+    }
+  }
+  if (libModule.files) {
+    for (const file of libModule.files) {
+      const targetPath = path3.join(
+        config.srcDir ? path3.join(cwd, "src") : cwd,
+        file.target
+      );
+      if (await sourceFileExists(file.source)) {
+        let content = await resolveSourceFile(file.source);
+        content = transformImports(content, config);
+        const fileName = path3.basename(file.source, path3.extname(file.source));
+        content = addOriginHeader(content, `${moduleName}/${fileName}`, "@buildpad/lib", registry.version);
+        await fs2.ensureDir(path3.dirname(targetPath));
+        await fs2.writeFile(targetPath, content);
+      } else {
+        spinner.warn(`Source file not found: ${file.source}`);
+      }
+    }
+  }
+  config.installedLib.push(moduleName);
+  spinner.succeed(`Installed lib: ${moduleName}`);
+  return true;
+}
+async function copyComponent(component, registry, config, cwd, overwrite, spinner, installing = /* @__PURE__ */ new Set(), dryRun = false, dryRunInfo) {
+  if (installing.has(component.name)) {
+    return true;
+  }
+  if (config.installedComponents.includes(component.name) && !overwrite && !dryRun) {
+    if (installing.has("__nonInteractive__")) {
+      return true;
+    }
+    const { shouldOverwrite } = await prompts({
+      type: "confirm",
+      name: "shouldOverwrite",
+      message: `${component.title} already installed. Overwrite?`,
+      initial: false
+    });
+    if (!shouldOverwrite) {
+      spinner.info(`Skipped ${component.title}`);
+      return false;
+    }
+  }
+  installing.add(component.name);
+  const info2 = {
+    component: component.name,
+    files: component.files.map((f) => ({ source: f.source, target: f.target })),
+    dependencies: component.dependencies,
+    libDependencies: component.internalDependencies ?? []
+  };
+  for (const dep of component.internalDependencies ?? []) {
+    if (!config.installedLib.includes(dep)) {
+      spinner.text = `Installing dependency: ${dep}...`;
+      if (!dryRun) {
+        await copyLibModule(dep, registry, config, cwd, spinner);
+      }
+    }
+  }
+  if (component.registryDependencies) {
+    for (const depName of component.registryDependencies) {
+      if (!config.installedComponents.includes(depName) && !installing.has(depName)) {
+        const depComponent = registry.components.find((c) => c.name === depName);
+        if (depComponent) {
+          spinner.text = `Installing component dependency: ${depComponent.title}...`;
+          await copyComponent(depComponent, registry, config, cwd, overwrite, spinner, installing, dryRun, dryRunInfo);
+        }
+      }
+    }
+  }
+  if (dryRun) {
+    if (dryRunInfo) {
+      dryRunInfo.push(info2);
+    }
+    spinner.info(`Would add ${component.title}`);
+    return true;
+  }
+  for (const file of component.files) {
+    const targetPath = path3.join(
+      config.srcDir ? path3.join(cwd, "src") : cwd,
+      file.target
+    );
+    if (!await sourceFileExists(file.source)) {
+      spinner.warn(`Source not found: ${file.source}`);
+      continue;
+    }
+    let content = await resolveSourceFile(file.source);
+    content = transformIntraComponentImports(content, file.source, file.target, component.files);
+    content = transformImports(content, config, file.target);
+    content = transformRelativeImports(content, file.source, file.target, config.aliases.components);
+    if (component.name === "vform" || file.target.includes("/vform/")) {
+      content = transformVFormImports(content, file.source, file.target);
+    }
+    content = addOriginHeader(content, component.name, "@buildpad/ui-interfaces", registry.version);
+    await fs2.ensureDir(path3.dirname(targetPath));
+    const ext = config.tsx ? ".tsx" : ".jsx";
+    const finalPath = targetPath.replace(/\.tsx?$/, ext);
+    await fs2.writeFile(finalPath, content);
+  }
+  if (!config.installedComponents.includes(component.name)) {
+    config.installedComponents.push(component.name);
+  }
+  if (!config.componentVersions) {
+    config.componentVersions = {};
+  }
+  config.componentVersions[component.name] = {
+    version: registry.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "@buildpad/ui-interfaces"
+  };
+  spinner.succeed(`Added ${component.title}`);
+  return true;
+}
+async function generateComponentsIndex(config, cwd, registry, spinner) {
+  const srcDir = config.srcDir ? path3.join(cwd, "src") : cwd;
+  const componentsDir = path3.join(srcDir, "components/ui");
+  const indexPath = path3.join(componentsDir, "index.ts");
+  spinner.text = "Generating components/ui/index.ts...";
+  const exportLines = [
+    "/**",
+    " * Buildpad UI Components Index",
+    " * ",
+    " * Auto-generated by Buildpad CLI.",
+    ' * Re-run "buildpad add" to update after adding new components.',
+    " */",
+    ""
+  ];
+  const exportedPaths = /* @__PURE__ */ new Set();
+  const namedExportMap = /* @__PURE__ */ new Map();
+  const sortedComponents = [...config.installedComponents].sort();
+  const ssrUnsafeComponents = {
+    "input-block-editor": "input-block-editor-wrapper"
+  };
+  const skippedForWrapper = [];
+  for (const componentName of sortedComponents) {
+    const component = registry.components.find((c) => c.name === componentName);
+    if (!component) continue;
+    const mainFile = component.files[0];
+    if (!mainFile) continue;
+    const targetPath = mainFile.target;
+    let exportPath;
+    if (targetPath.includes("/vform/")) {
+      exportPath = "./vform";
+    } else {
+      const fileName = path3.basename(targetPath, path3.extname(targetPath));
+      if (ssrUnsafeComponents[fileName]) {
+        const wrapperPath = path3.join(componentsDir, `${ssrUnsafeComponents[fileName]}.tsx`);
+        if (fs2.existsSync(wrapperPath)) {
+          exportPath = `./${ssrUnsafeComponents[fileName]}`;
+          skippedForWrapper.push(fileName);
+        } else {
+          exportPath = `./${fileName}`;
+        }
+      } else {
+        exportPath = `./${fileName}`;
+      }
+    }
+    if (!exportedPaths.has(exportPath)) {
+      exportedPaths.add(exportPath);
+      exportLines.push(`export * from '${exportPath}';`);
+      const filePath = path3.join(componentsDir, exportPath.slice(2) + ".tsx");
+      if (fs2.existsSync(filePath)) {
+        try {
+          const content = await fs2.readFile(filePath, "utf-8");
+          const namedExportPattern = /export\s+(?:const|function|class)\s+(\w+)/g;
+          let match;
+          while ((match = namedExportPattern.exec(content)) !== null) {
+            const exportName = match[1];
+            if (!namedExportMap.has(exportName)) {
+              namedExportMap.set(exportName, []);
+            }
+            namedExportMap.get(exportName).push(exportPath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await fs2.writeFile(indexPath, exportLines.join("\n") + "\n");
+  const duplicates = Array.from(namedExportMap.entries()).filter(([_, files]) => files.length > 1);
+  if (duplicates.length > 0) {
+    spinner.warn("Generated components/ui/index.ts (with duplicate warnings)");
+    console.log(chalk2.yellow("\n\u26A0 Duplicate export names detected:"));
+    for (const [exportName, files] of duplicates) {
+      console.log(chalk2.dim(`  "${exportName}" exported from: ${files.join(", ")}`));
+    }
+    console.log(chalk2.dim("  Consider using named imports or renaming exports.\n"));
+  } else {
+    spinner.info("Generated components/ui/index.ts");
+  }
+  if (skippedForWrapper.length > 0) {
+    console.log(chalk2.dim(`  \u2139 Using SSR-safe wrappers for: ${skippedForWrapper.join(", ")}`));
+  }
+}
+async function add(components, options) {
+  const { cwd, all, withApi, category, overwrite = false, dryRun = false, nonInteractive = false } = options;
+  if (dryRun) {
+    console.log(chalk2.yellow("\n\u{1F50D} Dry Run Mode - No files will be modified\n"));
+  }
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log(chalk2.red('\n\u2717 buildpad.json not found. Run "npx buildpad init" first.\n'));
+    process.exit(1);
+  }
+  if (!config.componentVersions) {
+    config.componentVersions = {};
+  }
+  const registry = await getRegistry2();
+  if (withApi || all) {
+    console.log(chalk2.bold("\n\u{1F50C} Installing API routes and Supabase auth...\n"));
+    const spinner2 = ora2("Processing lib modules...").start();
+    if (registry.lib["supabase-auth"] && !config.installedLib.includes("supabase-auth")) {
+      await copyLibModule("supabase-auth", registry, config, cwd, spinner2);
+    }
+    if (registry.lib["api-routes"] && !config.installedLib.includes("api-routes")) {
+      await copyLibModule("api-routes", registry, config, cwd, spinner2);
+    }
+    spinner2.succeed("API routes and auth installed!");
+    await saveConfig(cwd, config);
+  }
+  let componentsToAdd = [];
+  if (all) {
+    componentsToAdd = registry.components;
+  } else if (category) {
+    componentsToAdd = registry.components.filter((c) => c.category === category);
+    if (componentsToAdd.length === 0) {
+      console.log(chalk2.red(`
+\u2717 No components found in category: ${category}
+`));
+      const categories = registry.categories.map((c) => c.name).join(", ");
+      console.log(chalk2.dim(`Available categories: ${categories}
+`));
+      process.exit(1);
+    }
+  } else if (components.length > 0) {
+    for (const name of components) {
+      const component = findComponentWithSuggestions(name, registry);
+      if (!component) {
+        process.exit(1);
+      }
+      componentsToAdd.push(component);
+    }
+  } else {
+    const choices = registry.categories.map((cat) => ({
+      title: chalk2.bold(cat.title),
+      value: cat.name,
+      description: cat.description
+    }));
+    const { selectedCategory } = await prompts({
+      type: "select",
+      name: "selectedCategory",
+      message: "Select a category",
+      choices
+    });
+    if (!selectedCategory) {
+      console.log(chalk2.yellow("\n\u2713 No category selected\n"));
+      return;
+    }
+    const categoryComponents = registry.components.filter(
+      (c) => c.category === selectedCategory
+    );
+    const { selected } = await prompts({
+      type: "multiselect",
+      name: "selected",
+      message: "Select components to add",
+      choices: categoryComponents.map((c) => ({
+        title: `${c.title} - ${c.description}`,
+        value: c.name,
+        selected: false
+      })),
+      hint: "- Space to select. Return to submit"
+    });
+    componentsToAdd = registry.components.filter((c) => selected?.includes(c.name));
+  }
+  if (componentsToAdd.length === 0) {
+    console.log(chalk2.yellow("\n\u2713 No components selected\n"));
+    return;
+  }
+  if (dryRun) {
+    console.log(chalk2.bold(`
+\u{1F50D} Dry Run: Would add ${componentsToAdd.length} component(s)
+`));
+    const dryRunInfo = [];
+    const spinner2 = ora2("Analyzing...").start();
+    for (const component of componentsToAdd) {
+      spinner2.text = `Analyzing ${component.title}...`;
+      await copyComponent(component, registry, config, cwd, overwrite, spinner2, /* @__PURE__ */ new Set(), true, dryRunInfo);
+    }
+    spinner2.stop();
+    console.log(chalk2.bold("\n\u{1F4CB} Files that would be created:\n"));
+    for (const info2 of dryRunInfo) {
+      console.log(chalk2.cyan(`  ${info2.component}:`));
+      for (const file of info2.files) {
+        console.log(chalk2.dim(`    \u2192 ${file.target}`));
+      }
+    }
+    const allDryRunDeps = /* @__PURE__ */ new Set();
+    dryRunInfo.forEach((info2) => info2.dependencies.forEach((dep) => allDryRunDeps.add(dep)));
+    if (allDryRunDeps.size > 0) {
+      console.log(chalk2.bold("\n\u{1F4E6} External dependencies needed:\n"));
+      Array.from(allDryRunDeps).forEach((dep) => console.log(chalk2.dim(`    ${dep}`)));
+    }
+    console.log(chalk2.dim("\n  Run without --dry-run to install components.\n"));
+    return;
+  }
+  console.log(chalk2.bold(`
+\u{1F4E6} Adding ${componentsToAdd.length} component(s)...
+`));
+  const spinner = ora2("Processing...").start();
+  const allDeps = /* @__PURE__ */ new Set();
+  try {
+    const sharedInstalling = /* @__PURE__ */ new Set();
+    if (nonInteractive || all) {
+      sharedInstalling.add("__nonInteractive__");
+    }
+    for (const component of componentsToAdd) {
+      spinner.text = `Adding ${component.title}...`;
+      await copyComponent(component, registry, config, cwd, overwrite, spinner, sharedInstalling, false);
+      component.dependencies.forEach((dep) => allDeps.add(dep));
+    }
+    for (const libName of config.installedLib) {
+      const libModule = registry.lib[libName];
+      if (libModule?.dependencies) {
+        for (const dep of libModule.dependencies) {
+          allDeps.add(dep.replace(/@[^@/]*$/, ""));
+        }
+      }
+    }
+    config.registryVersion = registry.version;
+    await saveConfig(cwd, config);
+    await generateComponentsIndex(config, cwd, registry, spinner);
+    spinner.succeed("All components added!");
+    if (!nonInteractive) {
+      console.log(chalk2.bold("\n\u{1F50D} Running post-install validation...\n"));
+      try {
+        await validate({ cwd, json: false });
+      } catch {
+      }
+    }
+    console.log(chalk2.bold("\n\u{1F4E6} External dependencies...\n"));
+    const packageJsonPath = path3.join(cwd, "package.json");
+    let missingDeps = [];
+    if (fs2.existsSync(packageJsonPath)) {
+      const packageJson = await fs2.readJSON(packageJsonPath);
+      const installed = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      missingDeps = Array.from(allDeps).filter((dep) => !installed[dep]);
+    } else {
+      missingDeps = Array.from(allDeps);
+    }
+    if (missingDeps.length > 0) {
+      console.log(chalk2.yellow("\u26A0 Missing dependencies:"));
+      missingDeps.forEach((dep) => console.log(chalk2.dim(`  - ${dep}`)));
+      let autoInstall = nonInteractive;
+      if (!nonInteractive) {
+        const answer = await prompts({
+          type: "confirm",
+          name: "autoInstall",
+          message: "Install missing dependencies automatically?",
+          initial: true
+        });
+        autoInstall = answer.autoInstall;
+      }
+      if (autoInstall) {
+        const installSpinner = ora2("Installing dependencies...").start();
+        try {
+          const hasYarnLock = fs2.existsSync(path3.join(cwd, "yarn.lock"));
+          const hasPnpmLock = fs2.existsSync(path3.join(cwd, "pnpm-lock.yaml"));
+          const hasBunLock = fs2.existsSync(path3.join(cwd, "bun.lockb"));
+          let installCmd;
+          if (hasPnpmLock) {
+            installCmd = `pnpm add ${missingDeps.join(" ")}`;
+          } else if (hasYarnLock) {
+            installCmd = `yarn add ${missingDeps.join(" ")}`;
+          } else if (hasBunLock) {
+            installCmd = `bun add ${missingDeps.join(" ")}`;
+          } else {
+            installCmd = `npm install ${missingDeps.join(" ")}`;
+          }
+          const { execSync: execSync3 } = await import("child_process");
+          execSync3(installCmd, { cwd, stdio: "pipe" });
+          installSpinner.succeed("Dependencies installed!");
+        } catch (error) {
+          installSpinner.fail("Failed to install dependencies");
+          console.log(chalk2.dim("\nInstall manually with:"));
+          console.log(chalk2.cyan(`  pnpm add ${missingDeps.join(" ")}
+`));
+        }
+      } else {
+        console.log(chalk2.dim("\nInstall manually with:"));
+        console.log(chalk2.cyan(`  pnpm add ${missingDeps.join(" ")}
+`));
+      }
+    } else {
+      console.log(chalk2.green("\u2713 All external dependencies installed\n"));
+    }
+    console.log(chalk2.bold.blue("\u{1F4CB} Summary:\n"));
+    console.log(chalk2.dim("Components installed:"));
+    config.installedComponents.forEach((name) => {
+      console.log(chalk2.green(`  \u2713 ${name}`));
+    });
+    if (config.installedLib.length > 0) {
+      console.log(chalk2.dim("\nLib modules installed:"));
+      config.installedLib.forEach((name) => {
+        console.log(chalk2.green(`  \u2713 ${name}`));
+      });
+    }
+    console.log(chalk2.bold.green("\n\u2728 Done!\n"));
+    console.log(chalk2.dim("Components are now part of your codebase. Customize freely!"));
+    console.log(chalk2.dim(`Location: ${config.aliases.components}
+`));
+  } catch (error) {
+    spinner.fail("Failed to add components");
+    console.error(chalk2.red(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import chalk3 from "chalk";
+async function getRegistry3() {
+  try {
+    return await getRegistry();
+  } catch (err) {
+    console.error(chalk3.red("Failed to load registry:", err.message));
+    process.exit(1);
+  }
+}
+async function list(options) {
+  const { category, json, cwd = process.cwd() } = options;
+  const registry = await getRegistry3();
+  const config = await loadConfig(cwd);
+  let components = category ? registry.components.filter((c) => c.category === category) : registry.components;
+  if (json) {
+    console.log(JSON.stringify(components, null, 2));
+    return;
+  }
+  console.log(chalk3.bold("\n\u{1F4E6} Buildpad Components (Copy & Own)\n"));
+  console.log(chalk3.dim("Components are copied to your project as source files.\n"));
+  const byCategory = components.reduce((acc, c) => {
+    if (!acc[c.category]) acc[c.category] = [];
+    acc[c.category].push(c);
+    return acc;
+  }, {});
+  const categoryTitles = registry.categories.reduce((acc, cat) => {
+    acc[cat.name] = cat.title;
+    return acc;
+  }, {});
+  for (const [cat, items] of Object.entries(byCategory)) {
+    const catTitle = categoryTitles[cat] || cat.toUpperCase();
+    console.log(chalk3.bold.cyan(`
+${catTitle}`));
+    items.forEach((item) => {
+      const installed = config?.installedComponents.includes(item.name);
+      const status2 = installed ? chalk3.green("\u2713") : " ";
+      const name = item.name.padEnd(28);
+      console.log(
+        `  ${status2} ${chalk3.green(name)} ${chalk3.dim(item.description)}`
+      );
+      if (item.internalDependencies.length > 0) {
+        console.log(
+          `      ${chalk3.dim("requires:")} ${chalk3.yellow(item.internalDependencies.join(", "))}`
+        );
+      }
+    });
+  }
+  console.log(chalk3.bold("\n\u{1F4C2} Categories"));
+  registry.categories.forEach((cat) => {
+    const count = registry.components.filter((c) => c.category === cat.name).length;
+    console.log(`  ${chalk3.cyan(cat.name.padEnd(15))} ${count} components - ${chalk3.dim(cat.description)}`);
+  });
+  if (config) {
+    console.log(chalk3.bold("\n\u{1F4CB} Installed"));
+    console.log(`  Components: ${chalk3.green(config.installedComponents.length)}`);
+    console.log(`  Lib modules: ${chalk3.green(config.installedLib.length)} ${chalk3.dim(`(${config.installedLib.join(", ") || "none"})`)}`);
+  }
+  console.log(chalk3.bold("\n\u{1F4A1} Usage"));
+  console.log(chalk3.dim("  npx buildpad add input"));
+  console.log(chalk3.dim("  npx buildpad add input select-dropdown datetime"));
+  console.log(chalk3.dim("  npx buildpad add --category selection"));
+  console.log(chalk3.dim("  npx buildpad add --all\n"));
+}
+
+// src/commands/diff.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+import chalk4 from "chalk";
+async function getRegistry4() {
+  try {
+    return await getRegistry();
+  } catch (err) {
+    console.error(chalk4.red("Failed to load registry:", err.message));
+    process.exit(1);
+  }
+}
+async function diff(component, options) {
+  const { cwd } = options;
+  console.log(chalk4.bold(`
+\u{1F4CB} Preview: ${component}
+`));
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log(chalk4.red('\u2717 buildpad.json not found. Run "npx buildpad init" first.\n'));
+    process.exit(1);
+  }
+  const registry = await getRegistry4();
+  const comp = registry.components.find(
+    (c) => c.name.toLowerCase() === component.toLowerCase() || c.title.toLowerCase() === component.toLowerCase()
+  );
+  if (!comp) {
+    console.log(chalk4.red(`\u2717 Component not found: ${component}
+`));
+    console.log(chalk4.dim('Run "npx buildpad list" to see available components.\n'));
+    process.exit(1);
+  }
+  console.log(chalk4.bold.cyan(`${comp.title}`));
+  console.log(chalk4.dim(comp.description));
+  console.log();
+  console.log(chalk4.bold("Files to be created:"));
+  for (const file of comp.files) {
+    const targetPath = path4.join(
+      config.srcDir ? path4.join(cwd, "src") : cwd,
+      file.target
+    );
+    const relativePath = path4.relative(cwd, targetPath);
+    const exists = fs3.existsSync(targetPath);
+    if (exists) {
+      console.log(chalk4.yellow(`  \u26A0 ${relativePath} (exists, will be overwritten)`));
+    } else {
+      console.log(chalk4.green(`  + ${relativePath}`));
+    }
+  }
+  if (comp.internalDependencies.length > 0) {
+    console.log();
+    console.log(chalk4.bold("Lib modules required:"));
+    for (const dep of comp.internalDependencies) {
+      const installed = config.installedLib.includes(dep);
+      if (installed) {
+        console.log(chalk4.dim(`  \u2713 ${dep} (already installed)`));
+      } else {
+        console.log(chalk4.cyan(`  \u2192 ${dep}`));
+        const libModule = registry.lib[dep];
+        if (libModule?.files) {
+          for (const file of libModule.files) {
+            console.log(chalk4.dim(`      + ${file.target}`));
+          }
+        }
+      }
+    }
+  }
+  if (comp.dependencies.length > 0) {
+    console.log();
+    console.log(chalk4.bold("External dependencies:"));
+    const packageJsonPath = path4.join(cwd, "package.json");
+    let installed = {};
+    if (fs3.existsSync(packageJsonPath)) {
+      const pkg = await fs3.readJSON(packageJsonPath);
+      installed = { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    for (const dep of comp.dependencies) {
+      if (installed[dep]) {
+        console.log(chalk4.dim(`  \u2713 ${dep} (v${installed[dep]})`));
+      } else {
+        console.log(chalk4.yellow(`  \u26A0 ${dep} (not installed)`));
+      }
+    }
+  }
+  console.log();
+  console.log(chalk4.bold("Import transformation preview:"));
+  const sampleSource = comp.files[0]?.source;
+  if (sampleSource) {
+    try {
+      const content = await resolveSourceFile(sampleSource);
+      const lines = content.split("\n").slice(0, 15);
+      console.log(chalk4.dim("\nOriginal imports:"));
+      lines.filter((l) => l.startsWith("import")).forEach((line) => {
+        if (line.includes("@buildpad/")) {
+          console.log(chalk4.red(`  ${line}`));
+        }
+      });
+      const transformed = transformImports(content, config);
+      const transformedLines = transformed.split("\n").slice(0, 15);
+      console.log(chalk4.dim("\nTransformed imports:"));
+      transformedLines.filter((l) => l.startsWith("import")).forEach((line) => {
+        if (line.includes(config.aliases.lib) || line.includes(config.aliases.components)) {
+          console.log(chalk4.green(`  ${line}`));
+        }
+      });
+    } catch {
+      console.log(chalk4.dim("\n  (source preview not available in remote mode)"));
+    }
+  }
+  console.log();
+  console.log(chalk4.dim("Run the following to add this component:"));
+  console.log(chalk4.cyan(`  npx buildpad add ${comp.name}
+`));
+}
+
+// src/commands/status.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+import chalk5 from "chalk";
+async function findBuildpadFiles(dir) {
+  const files = [];
+  if (!fs4.existsSync(dir)) {
+    return files;
+  }
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+        const subFiles = await findBuildpadFiles(fullPath);
+        files.push(...subFiles);
+      }
+    } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+      const content = await fs4.readFile(fullPath, "utf-8");
+      if (hasBuildpadOrigin(content)) {
+        const info2 = extractOriginInfo(content);
+        if (info2 && info2.origin) {
+          files.push({
+            path: fullPath,
+            origin: info2.origin,
+            version: info2.version || "unknown",
+            date: info2.date || "unknown",
+            modified: false
+            // TODO: Compare with registry hash
+          });
+        }
+      }
+    }
+  }
+  return files;
+}
+function groupByOrigin(files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const [pkg, component] = file.origin.split("/").slice(0, 2);
+    const key = `${pkg}/${component || "root"}`;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(file);
+  }
+  return groups;
+}
+async function status(options) {
+  const { cwd, json = false } = options;
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log(chalk5.red("\n\u2717 buildpad.json not found.\n"));
+    console.log("This project may not be initialized with Buildpad.");
+    console.log('Run "npx @buildpad/cli init" to initialize.\n');
+    return;
+  }
+  const srcDir = config.srcDir ? path5.join(cwd, "src") : cwd;
+  const files = await findBuildpadFiles(srcDir);
+  if (json) {
+    console.log(JSON.stringify({
+      config: {
+        installedLib: config.installedLib,
+        installedComponents: config.installedComponents
+      },
+      files: files.map((f) => ({
+        ...f,
+        path: path5.relative(cwd, f.path)
+      }))
+    }, null, 2));
+    return;
+  }
+  console.log("\n" + chalk5.bold("\u{1F4E6} Buildpad Status\n"));
+  console.log(chalk5.gray("Config file: ") + "buildpad.json");
+  console.log(chalk5.gray("Lib modules: ") + (config.installedLib.join(", ") || "none"));
+  console.log(chalk5.gray("Components:  ") + (config.installedComponents.join(", ") || "none"));
+  if (files.length === 0) {
+    console.log("\n" + chalk5.yellow("No files with @buildpad-origin headers found."));
+    console.log(chalk5.gray("This may mean components were installed before origin tracking was added."));
+    return;
+  }
+  const groups = groupByOrigin(files);
+  console.log("\n" + chalk5.bold("Installed Files:\n"));
+  for (const [origin, groupFiles] of groups) {
+    console.log(chalk5.cyan(`  ${origin}`));
+    for (const file of groupFiles) {
+      const relativePath = path5.relative(cwd, file.path);
+      console.log(chalk5.gray(`    \u2514\u2500 ${relativePath}`));
+      console.log(chalk5.gray(`       v${file.version} (${file.date})`));
+    }
+    console.log();
+  }
+  console.log(chalk5.gray(`
+Total: ${files.length} files from Buildpad
+`));
+}
+
+// src/commands/info.ts
+import chalk6 from "chalk";
+async function getRegistry5() {
+  try {
+    return await getRegistry();
+  } catch (err) {
+    console.error(chalk6.red("Failed to load registry:", err.message));
+    process.exit(1);
+  }
+}
+function findComponent(name, registry) {
+  const normalized = name.toLowerCase().replace(/-/g, "");
+  const direct = registry.components.find(
+    (c) => c.name.toLowerCase() === name.toLowerCase() || c.title.toLowerCase() === name.toLowerCase()
+  );
+  if (direct) return direct;
+  const fuzzy = registry.components.find(
+    (c) => c.name.toLowerCase().replace(/-/g, "") === normalized || c.title.toLowerCase().replace(/-/g, "") === normalized
+  );
+  if (fuzzy) return fuzzy;
+  const aliases = {
+    "form": "vform",
+    "dynamicform": "vform",
+    "select": "select-dropdown",
+    "dropdown": "select-dropdown",
+    "checkbox": "boolean",
+    "switch": "toggle",
+    "date": "datetime",
+    "time": "datetime",
+    "text": "input",
+    "textinput": "input",
+    "image": "file-image",
+    "wysiwyg": "rich-text-html",
+    "markdown": "rich-text-markdown",
+    "m2m": "list-m2m",
+    "m2o": "list-m2o",
+    "o2m": "list-o2m",
+    "m2a": "list-m2a",
+    "manytomany": "list-m2m",
+    "manytoone": "list-m2o",
+    "onetomany": "list-o2m",
+    "manytoany": "list-m2a"
+  };
+  const aliased = aliases[normalized];
+  if (aliased) {
+    return registry.components.find((c) => c.name === aliased);
+  }
+  return void 0;
+}
+function calculateTotalDependencies(component, registry, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(component.name)) {
+    return { components: [], libs: [], npm: [] };
+  }
+  visited.add(component.name);
+  const result = {
+    components: [component.name],
+    libs: [...component.internalDependencies],
+    npm: [...component.dependencies]
+  };
+  if (component.registryDependencies) {
+    for (const depName of component.registryDependencies) {
+      const dep = registry.components.find((c) => c.name === depName);
+      if (dep) {
+        const subDeps = calculateTotalDependencies(dep, registry, visited);
+        result.components.push(...subDeps.components);
+        result.libs.push(...subDeps.libs);
+        result.npm.push(...subDeps.npm);
+      }
+    }
+  }
+  return {
+    components: [...new Set(result.components)],
+    libs: [...new Set(result.libs)],
+    npm: [...new Set(result.npm)]
+  };
+}
+async function info(componentName, options) {
+  const { json } = options;
+  const registry = await getRegistry5();
+  const component = findComponent(componentName, registry);
+  if (!component) {
+    console.log(chalk6.red(`
+\u2717 Component not found: ${componentName}
+`));
+    const suggestions = registry.components.filter(
+      (c) => c.name.includes(componentName.toLowerCase()) || c.title.toLowerCase().includes(componentName.toLowerCase()) || c.description.toLowerCase().includes(componentName.toLowerCase())
+    ).slice(0, 5);
+    if (suggestions.length > 0) {
+      console.log(chalk6.yellow("Did you mean one of these?\n"));
+      suggestions.forEach((s) => {
+        console.log(`  ${chalk6.green(s.name.padEnd(25))} ${chalk6.dim(s.description)}`);
+      });
+      console.log();
+    }
+    console.log(chalk6.dim('Run "buildpad list" to see all available components.\n'));
+    process.exit(1);
+  }
+  const totals = calculateTotalDependencies(component, registry);
+  const category = registry.categories.find((c) => c.name === component.category);
+  if (json) {
+    console.log(JSON.stringify({
+      ...component,
+      categoryTitle: category?.title,
+      totalDependencies: totals
+    }, null, 2));
+    return;
+  }
+  console.log(chalk6.bold.blue(`
+\u{1F4E6} ${component.title}`));
+  console.log(chalk6.dim(`   ${component.name} \u2022 ${category?.title || component.category}
+`));
+  console.log(`${component.description}
+`);
+  console.log(chalk6.bold("\u{1F4C1} Source Files"));
+  component.files.forEach((file) => {
+    console.log(`   ${chalk6.green(file.source)}`);
+    console.log(`   ${chalk6.dim("\u2192")} ${chalk6.cyan(file.target)}`);
+  });
+  if (component.dependencies.length > 0) {
+    console.log(chalk6.bold("\n\u{1F4E6} NPM Dependencies"));
+    console.log(`   ${chalk6.yellow(component.dependencies.join(", "))}`);
+  }
+  if (component.internalDependencies.length > 0) {
+    console.log(chalk6.bold("\n\u{1F527} Lib Modules"));
+    component.internalDependencies.forEach((lib) => {
+      const libModule = registry.lib[lib];
+      console.log(`   ${chalk6.magenta(lib)} ${chalk6.dim(`- ${libModule?.description || ""}`)}`);
+    });
+  }
+  if (component.registryDependencies && component.registryDependencies.length > 0) {
+    console.log(chalk6.bold("\n\u{1F517} Component Dependencies"));
+    console.log(`   ${chalk6.cyan(component.registryDependencies.length)} components will be installed:`);
+    const chunks = [];
+    for (let i = 0; i < component.registryDependencies.length; i += 6) {
+      chunks.push(component.registryDependencies.slice(i, i + 6).join(", "));
+    }
+    chunks.forEach((chunk) => console.log(`   ${chalk6.dim(chunk)}`));
+  }
+  if (component.interface) {
+    console.log(chalk6.bold("\n\u{1F3A8} Interface Metadata"));
+    console.log(`   ID: ${chalk6.green(component.interface.id)}`);
+    console.log(`   Icon: ${chalk6.cyan(component.interface.icon)}`);
+    console.log(`   Field Types: ${chalk6.yellow(component.interface.types.join(", "))}`);
+    if (component.interface.recommended) {
+      console.log(`   ${chalk6.green("\u2605")} Recommended interface for its field types`);
+    }
+  }
+  console.log(chalk6.bold("\n\u{1F4CA} Installation Summary"));
+  console.log(`   Components: ${chalk6.green(totals.components.length)}`);
+  console.log(`   Lib modules: ${chalk6.green(totals.libs.length)} ${chalk6.dim(`(${totals.libs.join(", ") || "none"})`)}`);
+  console.log(`   NPM packages: ${chalk6.yellow(totals.npm.length)}`);
+  console.log(chalk6.bold("\n\u{1F4A1} Usage"));
+  console.log(chalk6.dim(`   buildpad add ${component.name}`));
+  console.log(chalk6.dim(`   buildpad tree ${component.name}
+`));
+}
+
+// src/commands/tree.ts
+import chalk7 from "chalk";
+async function getRegistry6() {
+  try {
+    return await getRegistry();
+  } catch (err) {
+    console.error(chalk7.red("Failed to load registry:", err.message));
+    process.exit(1);
+  }
+}
+function findComponent2(name, registry) {
+  return registry.components.find(
+    (c) => c.name.toLowerCase() === name.toLowerCase() || c.title.toLowerCase() === name.toLowerCase()
+  );
+}
+function buildTree(component, registry, visited = /* @__PURE__ */ new Set(), depth = 0, maxDepth = 3) {
+  const node = {
+    name: component.name,
+    type: "component",
+    description: component.description,
+    children: []
+  };
+  if (visited.has(component.name) || depth >= maxDepth) {
+    return node;
+  }
+  visited.add(component.name);
+  for (const libName of component.internalDependencies) {
+    const libModule = registry.lib[libName];
+    const libNode = {
+      name: libName,
+      type: "lib",
+      description: libModule?.description,
+      children: []
+    };
+    if (libModule?.internalDependencies) {
+      for (const subLib of libModule.internalDependencies) {
+        if (!visited.has(`lib:${subLib}`)) {
+          visited.add(`lib:${subLib}`);
+          const subLibModule = registry.lib[subLib];
+          libNode.children.push({
+            name: subLib,
+            type: "lib",
+            description: subLibModule?.description,
+            children: []
+          });
+        }
+      }
+    }
+    node.children.push(libNode);
+  }
+  if (component.registryDependencies) {
+    for (const depName of component.registryDependencies) {
+      const dep = findComponent2(depName, registry);
+      if (dep) {
+        node.children.push(buildTree(dep, registry, visited, depth + 1, maxDepth));
+      }
+    }
+  }
+  for (const npmDep of component.dependencies) {
+    node.children.push({
+      name: npmDep,
+      type: "npm",
+      children: []
+    });
+  }
+  return node;
+}
+function renderTree(node, prefix = "", isLast = true, isRoot = true) {
+  const connector = isRoot ? "" : isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+  const childPrefix = isRoot ? "" : isLast ? "    " : "\u2502   ";
+  let icon = "";
+  let color = chalk7.white;
+  switch (node.type) {
+    case "component":
+      icon = "\u{1F4E6}";
+      color = chalk7.green;
+      break;
+    case "lib":
+      icon = "\u{1F527}";
+      color = chalk7.magenta;
+      break;
+    case "npm":
+      icon = "\u{1F4DA}";
+      color = chalk7.yellow;
+      break;
+  }
+  console.log(
+    prefix + connector + icon + " " + color(node.name) + (node.description && isRoot ? chalk7.dim(` - ${node.description}`) : "")
+  );
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    const isChildLast = i === node.children.length - 1;
+    renderTree(child, prefix + childPrefix, isChildLast, false);
+  }
+}
+function flattenTree(node) {
+  const result = {
+    components: /* @__PURE__ */ new Set(),
+    libs: /* @__PURE__ */ new Set(),
+    npm: /* @__PURE__ */ new Set()
+  };
+  function traverse(n) {
+    switch (n.type) {
+      case "component":
+        result.components.add(n.name);
+        break;
+      case "lib":
+        result.libs.add(n.name);
+        break;
+      case "npm":
+        result.npm.add(n.name);
+        break;
+    }
+    n.children.forEach(traverse);
+  }
+  traverse(node);
+  return {
+    components: Array.from(result.components),
+    libs: Array.from(result.libs),
+    npm: Array.from(result.npm)
+  };
+}
+async function tree(componentName, options) {
+  const { json, depth = 2 } = options;
+  const registry = await getRegistry6();
+  const component = findComponent2(componentName, registry);
+  if (!component) {
+    console.log(chalk7.red(`
+\u2717 Component not found: ${componentName}
+`));
+    const suggestions = registry.components.filter(
+      (c) => c.name.includes(componentName.toLowerCase()) || c.title.toLowerCase().includes(componentName.toLowerCase())
+    ).slice(0, 5);
+    if (suggestions.length > 0) {
+      console.log(chalk7.yellow("Did you mean one of these?\n"));
+      suggestions.forEach((s) => {
+        console.log(`  ${chalk7.green(s.name.padEnd(25))} ${chalk7.dim(s.description)}`);
+      });
+      console.log();
+    }
+    console.log(chalk7.dim('Run "buildpad list" to see all available components.\n'));
+    process.exit(1);
+  }
+  const treeData = buildTree(component, registry, /* @__PURE__ */ new Set(), 0, depth);
+  const flattened = flattenTree(treeData);
+  if (json) {
+    console.log(JSON.stringify({
+      tree: treeData,
+      summary: flattened
+    }, null, 2));
+    return;
+  }
+  console.log(chalk7.bold.blue(`
+\u{1F333} Dependency Tree: ${component.title}
+`));
+  renderTree(treeData);
+  console.log(chalk7.bold("\n\u{1F4CA} Summary"));
+  console.log(`   ${chalk7.green("\u{1F4E6} Components:")} ${flattened.components.length}`);
+  console.log(`   ${chalk7.magenta("\u{1F527} Lib modules:")} ${flattened.libs.length} ${chalk7.dim(`(${flattened.libs.join(", ") || "none"})`)}`);
+  console.log(`   ${chalk7.yellow("\u{1F4DA} NPM packages:")} ${flattened.npm.length}`);
+  if (flattened.npm.length > 0) {
+    console.log(chalk7.bold("\n\u{1F4E6} Install NPM Dependencies"));
+    console.log(chalk7.dim(`   pnpm add ${flattened.npm.join(" ")}
+`));
+  }
+  console.log(chalk7.bold("\u{1F4A1} Add this component"));
+  console.log(chalk7.dim(`   buildpad add ${component.name}
+`));
+}
+
+// src/commands/fix.ts
+import fs5 from "fs-extra";
+import path6 from "path";
+import chalk8 from "chalk";
+import ora3 from "ora";
+import fg2 from "fast-glob";
+import prompts2 from "prompts";
+import { execSync as execSync2 } from "child_process";
+async function fixUntransformedImports(cwd, config, dryRun) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const patterns = [
+    path6.join(srcDir, "components/**/*.{ts,tsx,js,jsx}"),
+    path6.join(srcDir, "lib/buildpad/**/*.{ts,tsx,js,jsx}")
+  ];
+  for (const pattern of patterns) {
+    const files = await fg2(pattern, { ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      const content = await fs5.readFile(file, "utf-8");
+      if (content.includes("from '@buildpad/") || content.includes('from "@buildpad/')) {
+        const transformed = transformImports(content, config);
+        if (transformed !== content) {
+          if (dryRun) {
+            console.log(chalk8.dim(`  Would fix: ${path6.relative(cwd, file)}`));
+          } else {
+            await fs5.writeFile(file, transformed);
+          }
+          result.fixed++;
+        }
+      }
+    }
+  }
+  return result;
+}
+async function fixSsrUnsafeExports(cwd, config, dryRun) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const indexPath = path6.join(srcDir, "components/ui/index.ts");
+  if (!fs5.existsSync(indexPath)) {
+    return result;
+  }
+  let content = await fs5.readFile(indexPath, "utf-8");
+  let modified = false;
+  if (content.includes("from './input-block-editor'") && !content.includes("from './input-block-editor-wrapper'")) {
+    const wrapperPath = path6.join(srcDir, "components/ui/input-block-editor-wrapper.tsx");
+    if (fs5.existsSync(wrapperPath)) {
+      content = content.replace(
+        /export \* from ['"]\.\/input-block-editor['"]/g,
+        "export * from './input-block-editor-wrapper'"
+      );
+      modified = true;
+      result.fixed++;
+    }
+  }
+  if (modified && !dryRun) {
+    await fs5.writeFile(indexPath, content);
+  } else if (modified && dryRun) {
+    console.log(chalk8.dim(`  Would fix SSR exports in: components/ui/index.ts`));
+  }
+  return result;
+}
+async function fixDuplicateExports(cwd, config, dryRun) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const indexPath = path6.join(srcDir, "components/ui/index.ts");
+  if (!fs5.existsSync(indexPath)) {
+    return result;
+  }
+  const content = await fs5.readFile(indexPath, "utf-8");
+  const componentsDir = path6.join(srcDir, "components/ui");
+  const exportPattern = /export \* from ['"]\.\/([^'"]+)['"]/g;
+  const namedExports = /* @__PURE__ */ new Map();
+  const namedExportPattern = /export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/g;
+  let match;
+  while ((match = exportPattern.exec(content)) !== null) {
+    const exportFile = match[1];
+    const filePath = path6.join(componentsDir, exportFile + ".tsx");
+    if (!fs5.existsSync(filePath)) continue;
+    const fileContent = await fs5.readFile(filePath, "utf-8");
+    let namedMatch;
+    while ((namedMatch = namedExportPattern.exec(fileContent)) !== null) {
+      const exportName = namedMatch[1];
+      if (!namedExports.has(exportName)) {
+        namedExports.set(exportName, { files: [exportFile], count: 1 });
+      } else {
+        const existing = namedExports.get(exportName);
+        existing.files.push(exportFile);
+        existing.count++;
+      }
+    }
+  }
+  const conflicts = Array.from(namedExports.entries()).filter(([_, info2]) => info2.count > 1);
+  if (conflicts.length > 0 && !dryRun) {
+    console.log(chalk8.yellow(`
+\u26A0 Found ${conflicts.length} conflicting export(s):`));
+    conflicts.forEach(([name, info2]) => {
+      console.log(chalk8.dim(`  ${name}: exported from ${info2.files.join(", ")}`));
+    });
+    console.log(chalk8.dim("\nTo fix, manually update components/ui/index.ts to use explicit named exports."));
+    console.log(chalk8.dim('Example: export { ComponentA } from "./file-a";'));
+    result.skipped = conflicts.length;
+  } else if (conflicts.length > 0 && dryRun) {
+    console.log(chalk8.dim(`  Would report ${conflicts.length} conflicting exports`));
+  }
+  return result;
+}
+async function fixBrokenImports(cwd, config, dryRun) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const componentsDir = path6.join(srcDir, "components/ui");
+  const files = await fg2(path6.join(componentsDir, "**/*.{ts,tsx}"), {
+    ignore: ["**/node_modules/**"]
+  });
+  for (const file of files) {
+    const content = await fs5.readFile(file, "utf-8");
+    const fileDir = path6.dirname(file);
+    let modified = false;
+    let newContent = content;
+    const relativeImportPattern = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+    let match;
+    while ((match = relativeImportPattern.exec(content)) !== null) {
+      const importPath = match[1];
+      const absolutePath = path6.resolve(fileDir, importPath);
+      const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", ""];
+      const exists = extensions.some((ext) => fs5.existsSync(absolutePath + ext));
+      if (!exists) {
+        const baseName = path6.basename(importPath);
+        const kebabName = toKebabCase(baseName);
+        const dirName = path6.dirname(importPath);
+        const newImportPath = dirName === "." ? `./${kebabName}` : `${dirName}/${kebabName}`;
+        const newAbsolutePath = path6.resolve(fileDir, newImportPath);
+        const newExists = extensions.some((ext) => fs5.existsSync(newAbsolutePath + ext));
+        if (newExists) {
+          newContent = newContent.replace(
+            new RegExp(`from\\s+['"]${importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`),
+            `from '${newImportPath}'`
+          );
+          modified = true;
+          result.fixed++;
+        }
+      }
+    }
+    if (modified && !dryRun) {
+      await fs5.writeFile(file, newContent);
+    } else if (modified && dryRun) {
+      console.log(chalk8.dim(`  Would fix imports in: ${path6.relative(cwd, file)}`));
+    }
+  }
+  return result;
+}
+async function fixMissingCss(cwd, config, dryRun) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const componentsDir = path6.join(srcDir, "components/ui");
+  const cssRequirements = {
+    "input-block-editor.tsx": {
+      component: "input-block-editor",
+      cssFile: "InputBlockEditor.css"
+    },
+    "rich-text-html.tsx": {
+      component: "rich-text-html",
+      cssFile: "RichTextHTML.css"
+    },
+    "rich-text-markdown.tsx": {
+      component: "rich-text-markdown",
+      cssFile: "RichTextMarkdown.css"
+    }
+  };
+  for (const [componentFile, info2] of Object.entries(cssRequirements)) {
+    const componentPath = path6.join(componentsDir, componentFile);
+    const cssPath = path6.join(componentsDir, info2.cssFile);
+    if (fs5.existsSync(componentPath) && !fs5.existsSync(cssPath)) {
+      if (dryRun) {
+        console.log(chalk8.dim(`  Would copy missing CSS: ${info2.cssFile}`));
+        result.fixed++;
+      } else {
+        console.log(chalk8.yellow(`  Missing CSS: ${info2.cssFile}`));
+        console.log(chalk8.dim(`    Reinstall component: npx buildpad add ${info2.component} --overwrite`));
+        result.skipped++;
+      }
+    }
+  }
+  return result;
+}
+var KNOWN_NPM_PACKAGES = /* @__PURE__ */ new Set([
+  // Mantine ecosystem
+  "@mantine/core",
+  "@mantine/hooks",
+  "@mantine/dates",
+  "@mantine/notifications",
+  "@mantine/tiptap",
+  "@mantine/form",
+  "@mantine/dropzone",
+  "@mantine/modals",
+  // Icons
+  "@tabler/icons-react",
+  // TipTap rich text
+  "@tiptap/react",
+  "@tiptap/starter-kit",
+  "@tiptap/extension-highlight",
+  "@tiptap/extension-text-align",
+  "@tiptap/extension-superscript",
+  "@tiptap/extension-subscript",
+  "@tiptap/extension-placeholder",
+  "@tiptap/extension-color",
+  "@tiptap/extension-text-style",
+  "@tiptap/extension-underline",
+  "@tiptap/extension-link",
+  "@tiptap/extension-code-block-lowlight",
+  // EditorJS block editor
+  "@editorjs/editorjs",
+  "@editorjs/header",
+  "@editorjs/nested-list",
+  "@editorjs/paragraph",
+  "@editorjs/code",
+  "@editorjs/quote",
+  "@editorjs/checklist",
+  "@editorjs/delimiter",
+  "@editorjs/table",
+  "@editorjs/underline",
+  "@editorjs/inline-code",
+  // Utilities
+  "lowlight",
+  "highlight.js",
+  "dayjs",
+  "axios",
+  // Maps
+  "maplibre-gl",
+  "@mapbox/mapbox-gl-draw",
+  // Supabase auth
+  "@supabase/ssr",
+  "@supabase/supabase-js",
+  // React / Next.js (framework — usually present)
+  "react",
+  "react-dom",
+  "next",
+  // Styling utility
+  "clsx",
+  "tailwind-merge"
+]);
+function extractPackageName(moduleSpec) {
+  if (moduleSpec.startsWith("@")) {
+    const parts = moduleSpec.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+  return moduleSpec.split("/")[0];
+}
+function collectTypeScriptErrors(cwd, config) {
+  const tsconfigPath = path6.join(cwd, "tsconfig.json");
+  if (!fs5.existsSync(tsconfigPath)) return [];
+  const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+  const componentsDir = path6.join(srcDir, "components/ui");
+  if (!fs5.existsSync(componentsDir)) return [];
+  try {
+    const output = execSync2(
+      `npx --yes tsc --noEmit --skipLibCheck --pretty false 2>&1 || true`,
+      { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, timeout: 12e4, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const errors = [];
+    const pattern = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm;
+    let match;
+    while ((match = pattern.exec(output)) !== null) {
+      const [, file, line, col, code, message] = match;
+      const rel = path6.relative(cwd, file);
+      if (rel.includes("components/ui") || rel.includes("lib/buildpad")) {
+        errors.push({ file, line: parseInt(line, 10), col: parseInt(col, 10), code, message });
+      }
+    }
+    return errors;
+  } catch {
+    return [];
+  }
+}
+async function fixTypeScriptErrors(cwd, config, dryRun, spinner) {
+  const result = { fixed: 0, skipped: 0, errors: [] };
+  if (spinner) spinner.text = "Running TypeScript check...";
+  const tsErrors = collectTypeScriptErrors(cwd, config);
+  if (tsErrors.length === 0) return result;
+  const missingModules = /* @__PURE__ */ new Set();
+  const missingNpmPackages = /* @__PURE__ */ new Set();
+  const undeclaredModules = /* @__PURE__ */ new Set();
+  const suppressTargets = [];
+  for (const err of tsErrors) {
+    if (err.code === "TS2307" || err.code === "TS7016") {
+      const moduleMatch = err.message.match(/(?:Cannot find module|Could not find a declaration file for module)\s+'([^']+)'/);
+      if (moduleMatch) {
+        const moduleSpec = moduleMatch[1];
+        if (moduleSpec.startsWith(".")) continue;
+        if (moduleSpec.startsWith("@buildpad/")) continue;
+        const pkgName = extractPackageName(moduleSpec);
+        missingModules.add(moduleSpec);
+        if (KNOWN_NPM_PACKAGES.has(pkgName)) {
+          missingNpmPackages.add(pkgName);
+        } else {
+          undeclaredModules.add(moduleSpec);
+        }
+      }
+    } else {
+      suppressTargets.push({ file: err.file, line: err.line, message: err.message });
+    }
+  }
+  if (missingNpmPackages.size > 0) {
+    const packageJsonPath = path6.join(cwd, "package.json");
+    let installedDeps = {};
+    if (fs5.existsSync(packageJsonPath)) {
+      const pkg = await fs5.readJSON(packageJsonPath);
+      installedDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    const toInstall = Array.from(missingNpmPackages).filter((p) => !installedDeps[p]);
+    if (toInstall.length > 0) {
+      if (dryRun) {
+        console.log(chalk8.dim(`  Would install ${toInstall.length} missing package(s): ${toInstall.join(", ")}`));
+        result.fixed += toInstall.length;
+      } else {
+        if (spinner) spinner.text = `Installing ${toInstall.length} missing package(s)...`;
+        const hasPnpmLock = fs5.existsSync(path6.join(cwd, "pnpm-lock.yaml"));
+        const hasYarnLock = fs5.existsSync(path6.join(cwd, "yarn.lock"));
+        const hasBunLock = fs5.existsSync(path6.join(cwd, "bun.lockb"));
+        let installCmd;
+        if (hasPnpmLock || !hasYarnLock && !hasBunLock) {
+          installCmd = `pnpm add ${toInstall.join(" ")}`;
+        } else if (hasYarnLock) {
+          installCmd = `yarn add ${toInstall.join(" ")}`;
+        } else {
+          installCmd = `bun add ${toInstall.join(" ")}`;
+        }
+        try {
+          execSync2(installCmd, { cwd, stdio: "pipe", timeout: 12e4 });
+          result.fixed += toInstall.length;
+          if (spinner) spinner.text = "Packages installed";
+        } catch {
+          result.errors.push(`Failed to install: ${toInstall.join(", ")}`);
+          result.skipped += toInstall.length;
+        }
+      }
+    }
+  }
+  if (undeclaredModules.size > 0) {
+    const srcDir = config.srcDir ? path6.join(cwd, "src") : cwd;
+    const declFile = path6.join(srcDir, "types", "modules.d.ts");
+    let existingContent = "";
+    if (fs5.existsSync(declFile)) {
+      existingContent = await fs5.readFile(declFile, "utf-8");
+    }
+    const newDeclarations = [];
+    for (const mod of undeclaredModules) {
+      const pkgName = extractPackageName(mod);
+      if (!existingContent.includes(`'${mod}'`) && !existingContent.includes(`'${pkgName}'`)) {
+        const declTarget = mod.includes("/") && mod !== pkgName ? pkgName : mod;
+        if (!newDeclarations.some((d) => d.includes(`'${declTarget}'`))) {
+          newDeclarations.push(`declare module '${declTarget}';`);
+        }
+      }
+    }
+    if (newDeclarations.length > 0) {
+      if (dryRun) {
+        console.log(chalk8.dim(`  Would add ${newDeclarations.length} module declaration(s) to types/modules.d.ts`));
+        result.fixed += newDeclarations.length;
+      } else {
+        await fs5.ensureDir(path6.dirname(declFile));
+        const separator = existingContent && !existingContent.endsWith("\n") ? "\n" : "";
+        const header = existingContent ? "" : "// Auto-generated module declarations for untyped packages\n";
+        const content = existingContent + separator + header + newDeclarations.join("\n") + "\n";
+        await fs5.writeFile(declFile, content);
+        result.fixed += newDeclarations.length;
+      }
+    }
+  }
+  if (suppressTargets.length > 0) {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const t of suppressTargets) {
+      const arr = byFile.get(t.file) || [];
+      arr.push({ line: t.line, message: t.message });
+      byFile.set(t.file, arr);
+    }
+    for (const [filePath, targets] of byFile) {
+      if (dryRun) {
+        console.log(chalk8.dim(`  Would suppress ${targets.length} error(s) in ${path6.relative(cwd, filePath)}`));
+        result.fixed += targets.length;
+        continue;
+      }
+      try {
+        const content = await fs5.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        const sorted = [...targets].sort((a, b) => b.line - a.line);
+        const alreadySuppressed = /* @__PURE__ */ new Set();
+        for (const { line, message } of sorted) {
+          const idx = line - 1;
+          if (idx < 0 || idx >= lines.length) continue;
+          if (alreadySuppressed.has(line)) continue;
+          if (idx > 0 && (lines[idx - 1].includes("@ts-expect-error") || lines[idx - 1].includes("@ts-ignore"))) {
+            alreadySuppressed.add(line);
+            continue;
+          }
+          const indent = lines[idx].match(/^(\s*)/)?.[1] || "";
+          const shortMsg = message.length > 80 ? message.slice(0, 77) + "..." : message;
+          lines.splice(idx, 0, `${indent}// @ts-expect-error \u2014 auto-suppressed: ${shortMsg}`);
+          result.fixed++;
+          alreadySuppressed.add(line);
+        }
+        await fs5.writeFile(filePath, lines.join("\n"));
+      } catch {
+        result.skipped += targets.length;
+      }
+    }
+  }
+  return result;
+}
+async function fix(options) {
+  const { cwd, dryRun = false, yes = false } = options;
+  console.log(chalk8.bold("\n\u{1F527} Buildpad Fix\n"));
+  if (dryRun) {
+    console.log(chalk8.yellow("Dry run mode - no changes will be made\n"));
+  }
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log(chalk8.red('\u2717 buildpad.json not found. Run "npx buildpad init" first.\n'));
+    process.exit(1);
+  }
+  if (!yes && !dryRun) {
+    const { confirm } = await prompts2({
+      type: "confirm",
+      name: "confirm",
+      message: "This will modify files in your project. Continue?",
+      initial: true
+    });
+    if (!confirm) {
+      console.log(chalk8.yellow("\n\u2713 Cancelled\n"));
+      return;
+    }
+  }
+  const spinner = ora3("Scanning for issues...").start();
+  try {
+    spinner.text = "Fixing untransformed imports...";
+    const importResult = await fixUntransformedImports(cwd, config, dryRun);
+    spinner.text = "Fixing broken relative imports...";
+    const brokenResult = await fixBrokenImports(cwd, config, dryRun);
+    spinner.text = "Fixing SSR-unsafe exports...";
+    const ssrResult = await fixSsrUnsafeExports(cwd, config, dryRun);
+    spinner.text = "Checking duplicate exports...";
+    const duplicateResult = await fixDuplicateExports(cwd, config, dryRun);
+    spinner.text = "Checking missing CSS files...";
+    const cssResult = await fixMissingCss(cwd, config, dryRun);
+    const tsResult = await fixTypeScriptErrors(cwd, config, dryRun, spinner);
+    spinner.stop();
+    const totalFixed = importResult.fixed + brokenResult.fixed + ssrResult.fixed + cssResult.fixed + tsResult.fixed;
+    const totalSkipped = importResult.skipped + brokenResult.skipped + ssrResult.skipped + duplicateResult.skipped + cssResult.skipped + tsResult.skipped;
+    console.log(chalk8.bold("\n\u{1F4CB} Fix Summary:\n"));
+    if (importResult.fixed > 0) {
+      console.log(chalk8.green(`  \u2713 Fixed ${importResult.fixed} untransformed import(s)`));
+    }
+    if (brokenResult.fixed > 0) {
+      console.log(chalk8.green(`  \u2713 Fixed ${brokenResult.fixed} broken import(s)`));
+    }
+    if (ssrResult.fixed > 0) {
+      console.log(chalk8.green(`  \u2713 Fixed ${ssrResult.fixed} SSR-unsafe export(s)`));
+    }
+    if (cssResult.fixed > 0) {
+      console.log(chalk8.green(`  \u2713 Fixed ${cssResult.fixed} missing CSS file(s)`));
+    }
+    if (tsResult.fixed > 0) {
+      console.log(chalk8.green(`  \u2713 Fixed ${tsResult.fixed} TypeScript error(s)`));
+    }
+    if (tsResult.errors.length > 0) {
+      tsResult.errors.forEach((e) => console.log(chalk8.yellow(`  \u26A0 ${e}`)));
+    }
+    if (totalSkipped > 0) {
+      console.log(chalk8.yellow(`
+  \u26A0 Skipped ${totalSkipped} issue(s) requiring manual fix`));
+    }
+    if (totalFixed === 0 && totalSkipped === 0) {
+      console.log(chalk8.green("  \u2713 No issues found!\n"));
+    } else if (dryRun) {
+      console.log(chalk8.dim("\n  Run without --dry-run to apply fixes\n"));
+    } else {
+      console.log(chalk8.green("\n\u2728 Fixes applied!\n"));
+      console.log(chalk8.dim('Run "npx buildpad validate" to verify.\n'));
+    }
+  } catch (error) {
+    spinner.fail("Fix failed");
+    console.error(chalk8.red(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/bootstrap.ts
+import fs6 from "fs-extra";
+import path7 from "path";
+import chalk9 from "chalk";
+async function bootstrap(options) {
+  const { cwd, skipDeps = false, skipValidate = false } = options;
+  const startTime = Date.now();
+  console.log(chalk9.bold.blue("\n\u{1F680} Buildpad Bootstrap - Full Project Setup\n"));
+  console.log(chalk9.dim(`Target: ${cwd}
+`));
+  console.log(chalk9.bold("\u2501".repeat(60)));
+  console.log(chalk9.bold("Step 1/3: Initializing project...\n"));
+  try {
+    await init({ yes: true, cwd });
+  } catch (error) {
+    console.error(chalk9.red("\n\u2717 Init failed:"), error);
+    process.exit(1);
+  }
+  console.log(chalk9.bold("\n" + "\u2501".repeat(60)));
+  console.log(chalk9.bold("Step 2/3: Adding all components...\n"));
+  try {
+    await add([], {
+      all: true,
+      withApi: true,
+      cwd,
+      nonInteractive: true
+    });
+  } catch (error) {
+    console.error(chalk9.red("\n\u2717 Component installation failed:"), error);
+    process.exit(1);
+  }
+  if (!skipDeps) {
+    console.log(chalk9.bold("\n" + "\u2501".repeat(60)));
+    console.log(chalk9.bold("Step 3/3: Installing npm dependencies...\n"));
+    try {
+      const { execSync: execSync3 } = await import("child_process");
+      const hasPnpmLock = fs6.existsSync(path7.join(cwd, "pnpm-lock.yaml"));
+      const hasYarnLock = fs6.existsSync(path7.join(cwd, "yarn.lock"));
+      const hasBunLock = fs6.existsSync(path7.join(cwd, "bun.lockb"));
+      let installCmd;
+      if (hasPnpmLock || !hasYarnLock && !hasBunLock) {
+        installCmd = "pnpm install";
+      } else if (hasYarnLock) {
+        installCmd = "yarn install";
+      } else {
+        installCmd = "bun install";
+      }
+      console.log(chalk9.dim(`  Running: ${installCmd}
+`));
+      execSync3(installCmd, { cwd, stdio: "inherit" });
+      console.log(chalk9.green("\n\u2713 Dependencies installed!"));
+    } catch (error) {
+      console.log(chalk9.yellow('\n\u26A0 Dependency installation had issues. Run "pnpm install" manually.'));
+    }
+  } else {
+    console.log(chalk9.dim("\nSkipped dependency installation (--skip-deps)\n"));
+  }
+  if (!skipValidate) {
+    console.log(chalk9.bold("\n" + "\u2501".repeat(60)));
+    console.log(chalk9.bold("Validating installation...\n"));
+    try {
+      const result = await validate({ cwd, json: false, noExit: true });
+      if (result && !result.valid) {
+        const tsErrors = result.errors.filter((e) => e.code === "TYPESCRIPT_ERROR");
+        const structuralErrors = result.errors.filter((e) => e.code !== "TYPESCRIPT_ERROR");
+        if (tsErrors.length > 0) {
+          console.log(chalk9.yellow(`
+\u26A0 ${tsErrors.length} TypeScript type error(s) detected in component files.`));
+          console.log(chalk9.yellow('  These may cause build failures. Run "pnpm cli fix --cwd ." to attempt auto-fix,'));
+          console.log(chalk9.yellow("  or ensure all component dependencies are installed.\n"));
+        }
+        if (structuralErrors.length > 0) {
+          console.log(chalk9.red(`
+\u2717 ${structuralErrors.length} structural error(s) found that need fixing.`));
+        }
+      }
+    } catch {
+      console.log(chalk9.yellow("\n\u26A0 Validation encountered issues (see above). Bootstrap still completed.\n"));
+    }
+  }
+  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+  console.log(chalk9.bold("\n" + "\u2501".repeat(60)));
+  console.log(chalk9.bold.green(`
+\u2728 Bootstrap complete! (${elapsed}s)
+`));
+  console.log(chalk9.dim("Your project is ready with:"));
+  console.log(chalk9.dim("  \u2022 buildpad.json configuration"));
+  console.log(chalk9.dim("  \u2022 40+ UI components in components/ui/"));
+  console.log(chalk9.dim("  \u2022 Types, services, hooks in lib/buildpad/"));
+  console.log(chalk9.dim("  \u2022 API proxy routes in app/api/"));
+  console.log(chalk9.dim("  \u2022 Supabase auth utilities"));
+  console.log(chalk9.dim("  \u2022 Next.js skeleton (layout, page, config)"));
+  console.log(chalk9.bold("\nNext steps:"));
+  console.log(chalk9.cyan("  1. ") + chalk9.dim("Configure .env.local with your DaaS URL"));
+  console.log(chalk9.cyan("  2. ") + chalk9.dim("pnpm dev"));
+  console.log(chalk9.cyan("  3. ") + chalk9.dim("Create pages that import from @/components/ui/\n"));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("buildpad").description("Copy & Own CLI - Add Buildpad components to your project").version("1.0.0");
+program.command("init").description("Initialize Buildpad in your project (creates buildpad.json)").option("-y, --yes", "Skip prompts and use defaults").option("-c, --cwd <path>", "Project directory", process.cwd()).action(init);
+program.command("add").description("Copy components to your project (with transformed imports)").argument("[components...]", "Component names to add").option("-a, --all", "Add all components").option("--with-api", "Also add API routes and Supabase auth templates").option("--category <name>", "Add all components from a category").option("-o, --overwrite", "Overwrite existing components").option("-n, --dry-run", "Preview changes without modifying files").option("--cwd <path>", "Project directory", process.cwd()).action(add);
+program.command("list").description("List all available components").option("--category <name>", "Filter by category").option("--json", "Output as JSON").option("--cwd <path>", "Project directory", process.cwd()).action(list);
+program.command("diff").description("Preview changes before adding a component").argument("<component>", "Component name").option("--cwd <path>", "Project directory", process.cwd()).action(diff);
+program.command("status").description("Show installed Buildpad components and their origins").option("--json", "Output as JSON").option("--cwd <path>", "Project directory", process.cwd()).action(status);
+program.command("info").description("Show detailed information about a component (sources, dependencies, interface)").argument("<component>", "Component name").option("--json", "Output as JSON").action(info);
+program.command("tree").description("Display dependency tree for a component").argument("<component>", "Component name").option("--json", "Output as JSON").option("-d, --depth <number>", "Max depth to display", "2").action((component, options) => tree(component, { ...options, depth: parseInt(options.depth) }));
+program.command("validate").description("Validate Buildpad installation (check imports, missing files, SSR issues)").option("--json", "Output as JSON").option("--cwd <path>", "Project directory", process.cwd()).action(async (options) => {
+  await validate(options);
+});
+program.command("bootstrap").description("Full project setup: init + add --all + install deps + validate (single command for AI agents)").option("--cwd <path>", "Project directory", process.cwd()).option("--skip-deps", "Skip npm dependency installation").option("--skip-validate", "Skip post-install validation").action(async (options) => {
+  await bootstrap({
+    cwd: options.cwd,
+    skipDeps: options.skipDeps,
+    skipValidate: options.skipValidate
+  });
+});
+program.command("fix").description("Automatically fix common issues (untransformed imports, broken paths, SSR exports)").option("-n, --dry-run", "Preview fixes without modifying files").option("-y, --yes", "Skip confirmation prompts").option("--cwd <path>", "Project directory", process.cwd()).action(fix);
+program.command("outdated").description("Check for component updates (compares installed versions to registry)").option("--json", "Output as JSON").option("--cwd <path>", "Project directory", process.cwd()).action(async (options) => {
+  const { outdated } = await import("./outdated-JMAYAZ7W.js");
+  await outdated(options);
+});
+program.parse();
+//# sourceMappingURL=index.js.map