@rootnative/cli 0.0.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1823 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import chalk2 from "chalk";
+import prompts from "prompts";
+
+// src/lib/config.ts
+import path from "path";
+import fs from "fs-extra";
+var CONFIG_FILE = "rootnative.json";
+var DEFAULT_CONFIG = {
+  $schema: "https://rootnative.github.io/ui/schema.json",
+  aliases: {
+    components: "@/components/ui",
+    lib: "@/lib"
+  },
+  registryUrl: "https://raw.githubusercontent.com/rootnative/ui",
+  registryVersion: "main"
+};
+function getConfigPath(cwd) {
+  return path.resolve(cwd, CONFIG_FILE);
+}
+async function configExists(cwd) {
+  return fs.pathExists(getConfigPath(cwd));
+}
+async function readConfig(cwd) {
+  const configPath = getConfigPath(cwd);
+  const exists = await fs.pathExists(configPath);
+  if (!exists) {
+    throw new Error('rootnative.json not found. Run "rootnative init" first.');
+  }
+  const raw = await fs.readJSON(configPath);
+  return raw;
+}
+async function writeConfig(cwd, config) {
+  const configPath = getConfigPath(cwd);
+  await fs.writeJSON(configPath, config, { spaces: 2 });
+}
+function resolveAliasPath(alias, cwd) {
+  const resolved = alias.replace(/^@\//, "src/");
+  return path.resolve(cwd, resolved);
+}
+
+// src/lib/detector.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+async function detectProjectType(cwd) {
+  const pkgPath = path2.resolve(cwd, "package.json");
+  const hasPackageJson = await fs2.pathExists(pkgPath);
+  if (!hasPackageJson) {
+    return "unknown";
+  }
+  const pkg = await fs2.readJSON(pkgPath);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (allDeps.expo) {
+    return "expo";
+  }
+  if (allDeps["react-native"]) {
+    return "react-native";
+  }
+  return "unknown";
+}
+async function detectPackageManager(cwd) {
+  const lockFiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  for (const [file, manager] of lockFiles) {
+    if (await fs2.pathExists(path2.resolve(cwd, file))) {
+      return manager;
+    }
+  }
+  return "npm";
+}
+async function detectTypeScript(cwd) {
+  return fs2.pathExists(path2.resolve(cwd, "tsconfig.json"));
+}
+async function detectSrcDir(cwd) {
+  const candidates = ["src", "app"];
+  for (const dir of candidates) {
+    const dirPath = path2.resolve(cwd, dir);
+    if (await fs2.pathExists(dirPath)) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function detectAliases(cwd) {
+  const tsconfigPath = path2.resolve(cwd, "tsconfig.json");
+  if (!await fs2.pathExists(tsconfigPath)) {
+    return null;
+  }
+  try {
+    const raw = await fs2.readFile(tsconfigPath, "utf-8");
+    const stripped = raw.replace(
+      /\/\*[\s\S]*?\*\/|\/\/.*/g,
+      ""
+    );
+    const tsconfig = JSON.parse(stripped);
+    const paths = tsconfig.compilerOptions?.paths;
+    if (!paths) {
+      return null;
+    }
+    const aliases = {};
+    for (const [alias, targets] of Object.entries(paths)) {
+      if (!Array.isArray(targets) || targets.length === 0) continue;
+      const cleanAlias = alias.replace(/\/\*$/, "");
+      const cleanTarget = targets[0].replace(/\/\*$/, "").replace(/^\.\//, "");
+      aliases[cleanAlias] = cleanTarget;
+    }
+    return Object.keys(aliases).length > 0 ? aliases : null;
+  } catch {
+    return null;
+  }
+}
+async function detectProject(cwd) {
+  const [type, packageManager, hasTypeScript, srcDir, aliases] = await Promise.all([
+    detectProjectType(cwd),
+    detectPackageManager(cwd),
+    detectTypeScript(cwd),
+    detectSrcDir(cwd),
+    detectAliases(cwd)
+  ]);
+  return { type, packageManager, hasTypeScript, srcDir, aliases };
+}
+function getInstallCommand(pm, packages) {
+  const pkgs = packages.join(" ");
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${pkgs}`;
+    case "yarn":
+      return `yarn add ${pkgs}`;
+    case "bun":
+      return `bun add ${pkgs}`;
+    default:
+      return `npm install ${pkgs}`;
+  }
+}
+
+// src/lib/installer.ts
+import path3 from "path";
+import { execa } from "execa";
+import fs3 from "fs-extra";
+
+// src/lib/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var logger = {
+  info(message) {
+    console.log(chalk.cyan("info"), message);
+  },
+  success(message) {
+    console.log(chalk.green("success"), message);
+  },
+  warn(message) {
+    console.log(chalk.yellow("warn"), message);
+  },
+  error(message) {
+    console.log(chalk.red("error"), message);
+  },
+  break() {
+    console.log();
+  }
+};
+function createSpinner(text) {
+  return ora({ text, color: "cyan" });
+}
+
+// src/lib/registry.ts
+function buildBaseUrl(config) {
+  return `${config.registryUrl}/${config.registryVersion}`;
+}
+async function fetchJSON(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function fetchRegistryIndex(config) {
+  const url = `${buildBaseUrl(config)}/registry/index.json`;
+  return fetchJSON(url);
+}
+async function fetchComponentEntry(config, name) {
+  const url = `${buildBaseUrl(config)}/registry/components/${name}.json`;
+  return fetchJSON(url);
+}
+async function fetchUtilsRegistry(config) {
+  const url = `${buildBaseUrl(config)}/registry/utils.json`;
+  return fetchJSON(url);
+}
+async function fetchFileContent(config, filePath) {
+  const url = `${buildBaseUrl(config)}/${filePath}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch file ${filePath}: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.text();
+}
+
+// src/lib/resolver.ts
+async function resolveComponents(config, requestedNames) {
+  const resolved = /* @__PURE__ */ new Map();
+  const utilsRegistry = await fetchUtilsRegistry(config);
+  async function resolve(name, isDirect) {
+    if (resolved.has(name)) return;
+    const entry = await fetchComponentEntry(config, name);
+    resolved.set(name, { entry, isDirectRequest: isDirect });
+    for (const dep of entry.componentDependencies) {
+      await resolve(dep, false);
+    }
+  }
+  for (const name of requestedNames) {
+    await resolve(name, true);
+  }
+  return buildResult(resolved, utilsRegistry);
+}
+function buildResult(resolved, utilsRegistry) {
+  const components = Array.from(resolved.values());
+  const utilSet = /* @__PURE__ */ new Set();
+  const npmDeps = {};
+  const optionalDeps = {};
+  for (const { entry } of components) {
+    for (const util of entry.utils) {
+      utilSet.add(util);
+    }
+    for (const [pkg, version] of Object.entries(entry.dependencies)) {
+      npmDeps[pkg] = version;
+    }
+    for (const [pkg, version] of Object.entries(entry.optionalDependencies)) {
+      optionalDeps[pkg] = version;
+    }
+  }
+  for (const utilName of utilSet) {
+    const utilEntry = utilsRegistry[utilName];
+    if (utilEntry) {
+      for (const [pkg, version] of Object.entries(utilEntry.dependencies)) {
+        optionalDeps[pkg] = version;
+      }
+    }
+  }
+  return {
+    components,
+    utils: Array.from(utilSet).sort(),
+    npmDependencies: npmDeps,
+    optionalNpmDependencies: optionalDeps
+  };
+}
+function getComponentNames(result) {
+  return result.components.map((c) => c.entry.name);
+}
+
+// src/lib/transform.ts
+var SINGLE_LINE_IMPORT_REGEX = /((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|[\w,\s]+)\s+from\s+)(['"])([^'"]+)\2/g;
+var MULTI_LINE_IMPORT_REGEX = /((?:import|export)\s+(?:type\s+)?\{[\s\S]*?\}\s+from\s+)(['"])([^'"]+)\2/g;
+function transformImports(source, options) {
+  const { config, installedComponents } = options;
+  const componentsAlias = config.aliases.components;
+  const libAlias = config.aliases.lib;
+  function rewriteImport(match, prefix, quote, importPath) {
+    if (importPath === "@rootnative/utils") {
+      return `${prefix}${quote}${libAlias}/rootnative-utils${quote}`;
+    }
+    if (importPath.startsWith("@rootnative/core")) {
+      return match;
+    }
+    if (importPath.startsWith("../")) {
+      const targetComponent = extractComponentName(importPath);
+      if (targetComponent && installedComponents.includes(targetComponent)) {
+        const restOfPath = importPath.replace(/^\.\.\//, "");
+        return `${prefix}${quote}${componentsAlias}/${restOfPath}${quote}`;
+      }
+    }
+    return match;
+  }
+  let result = source.replace(MULTI_LINE_IMPORT_REGEX, rewriteImport);
+  result = result.replace(SINGLE_LINE_IMPORT_REGEX, rewriteImport);
+  return result;
+}
+function extractComponentName(importPath) {
+  const match = importPath.match(/^\.\.\/([^/]+)/);
+  return match ? match[1] : null;
+}
+function generateUtilsBarrel(utilNames, utilExports, utilTypeExports = {}) {
+  const lines = ["// Auto-generated by rootnative CLI. Do not edit."];
+  for (const utilName of utilNames.sort()) {
+    const exports = utilExports[utilName];
+    if (exports && exports.length > 0) {
+      lines.push(`export { ${exports.join(", ")} } from './${utilName}'`);
+    }
+    const typeExports = utilTypeExports[utilName];
+    if (typeExports && typeExports.length > 0) {
+      lines.push(
+        `export type { ${typeExports.join(", ")} } from './${utilName}'`
+      );
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/lib/installer.ts
+async function installComponents(options) {
+  const { config, cwd, resolution, packageManager, force } = options;
+  const componentsDir = resolveAliasPath(config.aliases.components, cwd);
+  const libDir = resolveAliasPath(config.aliases.lib, cwd);
+  const allComponentNames = getComponentNames(resolution);
+  const spinner = createSpinner("Copying utility files...");
+  spinner.start();
+  const utilsRegistry = await fetchUtilsRegistry(config);
+  await copyUtilFiles(config, resolution, utilsRegistry, libDir);
+  await generateBarrel(resolution, utilsRegistry, libDir);
+  spinner.succeed("Utility files copied");
+  for (const { entry } of resolution.components) {
+    const componentDir = path3.join(componentsDir, entry.name);
+    const exists = await fs3.pathExists(componentDir);
+    if (exists && !force) {
+      logger.warn(
+        `${entry.name} already exists, skipping (use --force to overwrite)`
+      );
+      continue;
+    }
+    const compSpinner = createSpinner(`Adding ${entry.name}...`);
+    compSpinner.start();
+    await fs3.ensureDir(componentDir);
+    for (const filePath of entry.files) {
+      const content = await fetchFileContent(config, filePath);
+      const fileName = path3.basename(filePath);
+      const transformed = transformImports(content, {
+        config,
+        componentName: entry.name,
+        installedComponents: allComponentNames
+      });
+      await fs3.writeFile(
+        path3.join(componentDir, fileName),
+        transformed,
+        "utf-8"
+      );
+    }
+    compSpinner.succeed(`Added ${entry.name}`);
+  }
+  const depsToInstall = collectDepsToInstall(resolution, cwd);
+  if (depsToInstall.length > 0) {
+    const command = getInstallCommand(packageManager, depsToInstall);
+    const [cmd, ...args] = command.split(" ");
+    logger.break();
+    logger.info("Installing dependencies...");
+    logger.break();
+    try {
+      await execa(cmd, args, { cwd, stdio: "inherit" });
+      logger.break();
+      logger.success("Dependencies installed");
+    } catch {
+      logger.break();
+      logger.error("Failed to install dependencies");
+      logger.error(`Run manually: ${command}`);
+    }
+  }
+}
+async function copyUtilFiles(config, resolution, utilsRegistry, libDir) {
+  await fs3.ensureDir(libDir);
+  for (const utilName of resolution.utils) {
+    const utilEntry = utilsRegistry[utilName];
+    if (!utilEntry) continue;
+    const content = await fetchFileContent(config, utilEntry.file);
+    const fileName = path3.basename(utilEntry.file);
+    await fs3.writeFile(path3.join(libDir, fileName), content, "utf-8");
+  }
+}
+async function generateBarrel(resolution, utilsRegistry, libDir) {
+  const utilExports = {};
+  const utilTypeExports = {};
+  for (const utilName of resolution.utils) {
+    const utilEntry = utilsRegistry[utilName];
+    if (utilEntry) {
+      utilExports[utilName] = utilEntry.exports;
+      if (utilEntry.typeExports) {
+        utilTypeExports[utilName] = utilEntry.typeExports;
+      }
+    }
+  }
+  const barrelContent = generateUtilsBarrel(
+    resolution.utils,
+    utilExports,
+    utilTypeExports
+  );
+  await fs3.writeFile(
+    path3.join(libDir, "rootnative-utils.ts"),
+    barrelContent,
+    "utf-8"
+  );
+}
+function collectDepsToInstall(resolution, cwd) {
+  const deps = [];
+  const pkgPath = path3.resolve(cwd, "package.json");
+  let existingDeps = {};
+  try {
+    const pkg = fs3.readJSONSync(pkgPath);
+    existingDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+  } catch {
+  }
+  for (const [pkg] of Object.entries(resolution.npmDependencies)) {
+    if (!existingDeps[pkg]) {
+      deps.push(pkg);
+    }
+  }
+  return deps;
+}
+
+// src/commands/add.ts
+async function addCommand(componentNames, cwd, options) {
+  logger.break();
+  const config = await readConfig(cwd);
+  const spinner = createSpinner("Fetching component registry...");
+  spinner.start();
+  const registryIndex = await fetchRegistryIndex(config);
+  spinner.succeed("Registry loaded");
+  const availableNames = registryIndex.components.map((c) => c.name);
+  const invalid = componentNames.filter(
+    (name) => !availableNames.includes(name)
+  );
+  if (invalid.length > 0) {
+    logger.error(
+      `Unknown component(s): ${invalid.map((n) => chalk2.bold(n)).join(", ")}`
+    );
+    logger.info(`Available: ${availableNames.join(", ")}`);
+    process.exit(1);
+  }
+  const resolveSpinner = createSpinner("Resolving dependencies...");
+  resolveSpinner.start();
+  const resolution = await resolveComponents(config, componentNames);
+  resolveSpinner.succeed("Dependencies resolved");
+  const allNames = getComponentNames(resolution);
+  logger.break();
+  console.log(chalk2.bold("Components to add:"));
+  for (const { entry, isDirectRequest } of resolution.components) {
+    const suffix = isDirectRequest ? "" : chalk2.dim(` (dependency)`);
+    console.log(`  ${chalk2.green("+")} ${entry.name}${suffix}`);
+  }
+  if (resolution.utils.length > 0) {
+    logger.break();
+    console.log(chalk2.bold("Utilities to copy:"));
+    console.log(`  ${resolution.utils.map((u) => `${u}.ts`).join(", ")}`);
+  }
+  const npmDeps = Object.keys(resolution.npmDependencies);
+  const optionalDeps = Object.keys(resolution.optionalNpmDependencies);
+  if (npmDeps.length > 0 || optionalDeps.length > 0) {
+    logger.break();
+    console.log(chalk2.bold("npm packages:"));
+    for (const pkg of npmDeps) {
+      console.log(`  ${chalk2.green("+")} ${pkg}`);
+    }
+    for (const pkg of optionalDeps) {
+      console.log(`  ${chalk2.green("+")} ${pkg} ${chalk2.dim("(optional)")}`);
+    }
+  }
+  logger.break();
+  if (options.dryRun) {
+    logger.info("Dry run complete. No files were written.");
+    return;
+  }
+  const { proceed } = await prompts({
+    type: "confirm",
+    name: "proceed",
+    message: "Proceed with installation?",
+    initial: true
+  });
+  if (!proceed) {
+    logger.info("Cancelled.");
+    return;
+  }
+  const project = await detectProject(cwd);
+  const pm = options.packageManager ?? project.packageManager;
+  await installComponents({
+    config,
+    cwd,
+    resolution,
+    packageManager: pm,
+    force: options.force
+  });
+  logger.break();
+  logger.success(
+    `Added ${allNames.length} component(s): ${allNames.join(", ")}`
+  );
+  logger.break();
+}
+
+// src/commands/create.ts
+import path4 from "path";
+import chalk3 from "chalk";
+import { execa as execa2 } from "execa";
+import fs4 from "fs-extra";
+import prompts2 from "prompts";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+var ROOTNATIVE_PACKAGES = ["@rootnative/core", "@rootnative/components"];
+async function resolveTemplateSource() {
+  const fallback = {
+    baseUrl: `${DEFAULT_CONFIG.registryUrl}/${DEFAULT_CONFIG.registryVersion}/templates`,
+    pinnedVersion: null
+  };
+  try {
+    const res = await fetch(`${NPM_REGISTRY}/@rootnative/core`);
+    if (!res.ok) return fallback;
+    const data = await res.json();
+    const version = data["dist-tags"]?.latest;
+    if (!version) return fallback;
+    const tagBaseUrl = `${DEFAULT_CONFIG.registryUrl}/v${version}/templates`;
+    const probe = await fetch(`${tagBaseUrl}/blank/package.json`);
+    if (probe.ok) {
+      return { baseUrl: tagBaseUrl, pinnedVersion: version };
+    }
+    return { baseUrl: fallback.baseUrl, pinnedVersion: version };
+  } catch {
+    return fallback;
+  }
+}
+var TEMPLATE_CONFIGS = {
+  blank: {
+    textFiles: [
+      "package.json",
+      "app.json",
+      "tsconfig.json",
+      "babel.config.js",
+      ".gitignore",
+      "index.js",
+      "App.tsx"
+    ],
+    dirs: ["assets"]
+  },
+  "with-router": {
+    textFiles: [
+      "package.json",
+      "app.json",
+      "tsconfig.json",
+      "babel.config.js",
+      ".gitignore",
+      "app/_layout.tsx",
+      "app/index.tsx"
+    ],
+    dirs: ["assets", "app"]
+  }
+};
+var TEMPLATE_BINARY_FILES = [
+  "assets/icon.png",
+  "assets/splash.png",
+  "assets/adaptive-icon.png",
+  "assets/favicon.png"
+];
+function isValidTemplate(value) {
+  return value in TEMPLATE_CONFIGS;
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toDisplayName(slug) {
+  return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function getInstallCommand2(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun install";
+    default:
+      return "npm install";
+  }
+}
+async function fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+  }
+  return res.text();
+}
+async function fetchBinary(url) {
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  return Buffer.from(await res.arrayBuffer());
+}
+async function createCommand(name, options = {}) {
+  logger.break();
+  let templateName;
+  if (options.template) {
+    if (!isValidTemplate(options.template)) {
+      logger.error(
+        `Unknown template "${options.template}". Available: blank, with-router`
+      );
+      process.exit(1);
+    }
+    templateName = options.template;
+  } else if (options.yes) {
+    templateName = "blank";
+  } else {
+    const { value } = await prompts2({
+      type: "select",
+      name: "value",
+      message: "Template:",
+      choices: [
+        { title: "Blank", description: "Minimal setup", value: "blank" },
+        {
+          title: "With Router",
+          description: "Includes Expo Router",
+          value: "with-router"
+        }
+      ],
+      initial: 0
+    });
+    if (value === void 0) {
+      logger.info("Create cancelled.");
+      return;
+    }
+    templateName = value;
+  }
+  let projectName;
+  if (name) {
+    projectName = slugify(name);
+  } else {
+    const { value } = await prompts2({
+      type: "text",
+      name: "value",
+      message: "Project name:",
+      initial: "my-app",
+      validate: (v) => v.trim().length > 0 || "Project name is required"
+    });
+    if (!value) {
+      logger.info("Create cancelled.");
+      return;
+    }
+    projectName = slugify(value);
+  }
+  let displayName;
+  if (options.yes) {
+    displayName = toDisplayName(projectName);
+  } else {
+    const { value } = await prompts2({
+      type: "text",
+      name: "value",
+      message: "Display name (shown on home screen):",
+      initial: toDisplayName(projectName)
+    });
+    if (!value) {
+      logger.info("Create cancelled.");
+      return;
+    }
+    displayName = value;
+  }
+  let packageManager;
+  if (options.packageManager) {
+    packageManager = options.packageManager;
+  } else if (options.yes) {
+    packageManager = "npm";
+  } else {
+    const { value } = await prompts2({
+      type: "select",
+      name: "value",
+      message: "Package manager:",
+      choices: [
+        { title: "npm", value: "npm" },
+        { title: "yarn", value: "yarn" },
+        { title: "pnpm", value: "pnpm" },
+        { title: "bun", value: "bun" }
+      ],
+      initial: 0
+    });
+    if (value === void 0) {
+      logger.info("Create cancelled.");
+      return;
+    }
+    packageManager = value;
+  }
+  const targetDir = path4.resolve(process.cwd(), projectName);
+  if (await fs4.pathExists(targetDir)) {
+    if (options.yes) {
+      logger.warn(`Directory ${chalk3.bold(projectName)} already exists.`);
+      process.exit(1);
+    }
+    const { overwrite } = await prompts2({
+      type: "confirm",
+      name: "overwrite",
+      message: `Directory ${chalk3.bold(projectName)} already exists. Overwrite?`,
+      initial: false
+    });
+    if (!overwrite) {
+      logger.info("Create cancelled.");
+      return;
+    }
+    await fs4.remove(targetDir);
+  }
+  const templateConfig = TEMPLATE_CONFIGS[templateName];
+  const { baseUrl, pinnedVersion } = await resolveTemplateSource();
+  const templateBaseUrl = `${baseUrl}/${templateName}`;
+  const spinner = createSpinner("Creating project...");
+  spinner.start();
+  try {
+    for (const dir of templateConfig.dirs) {
+      await fs4.ensureDir(path4.join(targetDir, dir));
+    }
+    for (const file of templateConfig.textFiles) {
+      let content = await fetchText(`${templateBaseUrl}/${file}`);
+      if (file === "package.json") {
+        const pkg = JSON.parse(content);
+        pkg.name = projectName;
+        if (pinnedVersion) {
+          for (const pkgName of ROOTNATIVE_PACKAGES) {
+            if (pkg.dependencies?.[pkgName]) {
+              pkg.dependencies[pkgName] = pinnedVersion;
+            }
+          }
+        }
+        content = JSON.stringify(pkg, null, 2) + "\n";
+      }
+      if (file === "app.json") {
+        const appJson = JSON.parse(content);
+        appJson.expo.name = displayName;
+        appJson.expo.slug = projectName;
+        if (appJson.expo.scheme) {
+          appJson.expo.scheme = projectName;
+        }
+        content = JSON.stringify(appJson, null, 2) + "\n";
+      }
+      await fs4.outputFile(path4.join(targetDir, file), content);
+    }
+    for (const file of TEMPLATE_BINARY_FILES) {
+      const buffer = await fetchBinary(`${templateBaseUrl}/${file}`);
+      if (buffer) {
+        await fs4.outputFile(path4.join(targetDir, file), buffer);
+      }
+    }
+    spinner.succeed("Project created");
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    throw error;
+  }
+  let shouldInstall = options.yes;
+  if (!options.yes) {
+    const { value } = await prompts2({
+      type: "confirm",
+      name: "value",
+      message: "Install dependencies?",
+      initial: true
+    });
+    shouldInstall = value;
+  }
+  if (shouldInstall) {
+    const installCmd = getInstallCommand2(packageManager);
+    const [cmd, ...args] = installCmd.split(" ");
+    logger.break();
+    logger.info("Installing dependencies...");
+    logger.break();
+    try {
+      await execa2(cmd, args, { cwd: targetDir, stdio: "inherit" });
+      logger.break();
+      logger.success("Dependencies installed");
+    } catch {
+      logger.break();
+      logger.error("Failed to install dependencies");
+      logger.info(
+        `Run manually: ${chalk3.bold(`cd ${projectName} && ${installCmd}`)}`
+      );
+    }
+  }
+  logger.break();
+  logger.success(`Project ${chalk3.bold(displayName)} is ready!`);
+  logger.break();
+  logger.info("Next steps:");
+  logger.info(`  cd ${projectName}`);
+  if (!shouldInstall) {
+    logger.info(`  ${getInstallCommand2(packageManager)}`);
+  }
+  logger.info("  npx expo start");
+  logger.break();
+}
+
+// src/commands/doctor.ts
+import path5 from "path";
+import chalk4 from "chalk";
+import fs5 from "fs-extra";
+function logCheck(status, message) {
+  const icon = status === "pass" ? chalk4.green("[pass]") : status === "warn" ? chalk4.yellow("[warn]") : chalk4.red("[fail]");
+  console.log(`  ${icon} ${message}`);
+}
+async function doctorCommand(cwd) {
+  logger.break();
+  console.log(chalk4.bold("RootNative Doctor"));
+  logger.break();
+  let issues = 0;
+  if (await configExists(cwd)) {
+    logCheck("pass", "rootnative.json found");
+  } else {
+    logCheck("fail", 'rootnative.json not found. Run "rootnative init" first.');
+    issues++;
+    logger.break();
+    logger.error(`${issues} issue(s) found.`);
+    return;
+  }
+  const config = await readConfig(cwd);
+  const project = await detectProject(cwd);
+  if (project.type !== "unknown") {
+    logCheck(
+      "pass",
+      `${project.type} project detected (${project.packageManager})`
+    );
+  } else {
+    logCheck("fail", "Not a React Native or Expo project");
+    issues++;
+  }
+  const pkgPath = path5.resolve(cwd, "package.json");
+  if (await fs5.pathExists(pkgPath)) {
+    const pkg = await fs5.readJSON(pkgPath);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    const rnVersion = allDeps["react-native"];
+    if (rnVersion) {
+      logCheck("pass", `react-native: ${rnVersion}`);
+    } else {
+      logCheck("fail", "react-native not found in dependencies");
+      issues++;
+    }
+  }
+  const corePkgPath = path5.resolve(
+    cwd,
+    "node_modules",
+    "@rootnative",
+    "core",
+    "package.json"
+  );
+  if (await fs5.pathExists(corePkgPath)) {
+    const corePkg = await fs5.readJSON(corePkgPath);
+    logCheck("pass", `@rootnative/core@${corePkg.version} installed`);
+  } else {
+    logCheck(
+      "fail",
+      '@rootnative/core not installed. Run "rootnative init" to install it.'
+    );
+    issues++;
+  }
+  if (project.hasTypeScript) {
+    logCheck("pass", "TypeScript configured");
+  } else {
+    logCheck(
+      "warn",
+      "TypeScript not detected. RootNative components use TypeScript."
+    );
+  }
+  const componentsDir = resolveAliasPath(config.aliases.components, cwd);
+  if (await fs5.pathExists(componentsDir)) {
+    const dirs = await fs5.readdir(componentsDir);
+    const componentDirs = [];
+    for (const dir of dirs) {
+      const fullPath = path5.join(componentsDir, dir);
+      const stat = await fs5.stat(fullPath);
+      if (stat.isDirectory()) {
+        componentDirs.push(dir);
+      }
+    }
+    if (componentDirs.length > 0) {
+      let integrityOk = true;
+      for (const dir of componentDirs) {
+        const indexPath = path5.join(componentsDir, dir, "index.ts");
+        if (!await fs5.pathExists(indexPath)) {
+          logCheck("warn", `Component ${dir} is missing index.ts`);
+          integrityOk = false;
+        }
+      }
+      if (integrityOk) {
+        logCheck(
+          "pass",
+          `${componentDirs.length} component(s) installed, all files present`
+        );
+      }
+    } else {
+      logCheck(
+        "warn",
+        'No components installed yet. Run "rootnative add <component>".'
+      );
+    }
+  } else {
+    logCheck(
+      "warn",
+      `Components directory not found at ${config.aliases.components}`
+    );
+  }
+  const libDir = resolveAliasPath(config.aliases.lib, cwd);
+  const barrelPath = path5.join(libDir, "rootnative-utils.ts");
+  if (await fs5.pathExists(barrelPath)) {
+    logCheck("pass", "Utility barrel file present");
+  } else {
+    if (await fs5.pathExists(componentsDir)) {
+      const dirs = await fs5.readdir(componentsDir);
+      if (dirs.length > 0) {
+        logCheck("warn", "Utility barrel file (rootnative-utils.ts) missing");
+      }
+    }
+  }
+  const nodeModules = path5.resolve(cwd, "node_modules");
+  const safeAreaInstalled = await fs5.pathExists(
+    path5.join(nodeModules, "react-native-safe-area-context")
+  );
+  if (safeAreaInstalled) {
+    logCheck("pass", "react-native-safe-area-context installed");
+  } else {
+    logCheck(
+      "warn",
+      "react-native-safe-area-context not installed (needed by: appbar, layout)"
+    );
+  }
+  const vectorIconsInstalled = await fs5.pathExists(
+    path5.join(nodeModules, "@expo", "vector-icons")
+  );
+  if (vectorIconsInstalled) {
+    logCheck("pass", "@expo/vector-icons installed");
+  } else {
+    logCheck(
+      "warn",
+      "@expo/vector-icons not installed (needed for icon support)"
+    );
+  }
+  logger.break();
+  if (issues > 0) {
+    logger.error(`${issues} issue(s) found.`);
+  } else {
+    logger.success("All checks passed!");
+  }
+  logger.break();
+}
+
+// src/commands/init.ts
+import chalk5 from "chalk";
+import { execa as execa3 } from "execa";
+import prompts3 from "prompts";
+async function initCommand(cwd, options = {}) {
+  logger.break();
+  if (await configExists(cwd)) {
+    if (options.yes) {
+      logger.info("Overwriting existing rootnative.json");
+    } else {
+      const { overwrite } = await prompts3({
+        type: "confirm",
+        name: "overwrite",
+        message: "rootnative.json already exists. Overwrite?",
+        initial: false
+      });
+      if (!overwrite) {
+        logger.info("Init cancelled.");
+        return;
+      }
+    }
+  }
+  const spinner = createSpinner("Detecting project...");
+  spinner.start();
+  const project = await detectProject(cwd);
+  spinner.stop();
+  if (project.type === "unknown") {
+    logger.error("No React Native or Expo project detected.");
+    logger.info(
+      "Make sure you are in a project with react-native or expo in package.json."
+    );
+    process.exit(1);
+  }
+  logger.info(
+    `Detected ${chalk5.bold(project.type)} project using ${chalk5.bold(project.packageManager)}`
+  );
+  if (!project.hasTypeScript) {
+    logger.warn(
+      "TypeScript not detected. RootNative components use TypeScript."
+    );
+  }
+  let defaultComponentsAlias = DEFAULT_CONFIG.aliases.components;
+  let defaultLibAlias = DEFAULT_CONFIG.aliases.lib;
+  if (project.aliases?.["@"]) {
+    defaultComponentsAlias = "@/components/ui";
+    defaultLibAlias = "@/lib";
+  } else if (project.aliases?.["~"]) {
+    defaultComponentsAlias = "~/components/ui";
+    defaultLibAlias = "~/lib";
+  }
+  let componentsAlias;
+  let libAlias;
+  if (options.yes) {
+    componentsAlias = options.componentsAlias ?? defaultComponentsAlias;
+    libAlias = options.libAlias ?? defaultLibAlias;
+  } else {
+    const answers = await prompts3([
+      {
+        type: "text",
+        name: "componentsAlias",
+        message: "Where should components be installed?",
+        initial: options.componentsAlias ?? defaultComponentsAlias
+      },
+      {
+        type: "text",
+        name: "libAlias",
+        message: "Where should utility files be placed?",
+        initial: options.libAlias ?? defaultLibAlias
+      }
+    ]);
+    if (!answers.componentsAlias || !answers.libAlias) {
+      logger.info("Init cancelled.");
+      return;
+    }
+    componentsAlias = answers.componentsAlias;
+    libAlias = answers.libAlias;
+  }
+  const config = {
+    ...DEFAULT_CONFIG,
+    aliases: {
+      components: componentsAlias,
+      lib: libAlias
+    }
+  };
+  await writeConfig(cwd, config);
+  logger.success("Created rootnative.json");
+  let installCore = options.yes;
+  if (!options.yes) {
+    const answer = await prompts3({
+      type: "confirm",
+      name: "installCore",
+      message: "Install @rootnative/core?",
+      initial: true
+    });
+    installCore = answer.installCore;
+  }
+  if (installCore) {
+    const pm = options.packageManager ?? project.packageManager;
+    const command = getInstallCommand(pm, ["@rootnative/core"]);
+    const [cmd, ...args] = command.split(" ");
+    logger.break();
+    logger.info("Installing @rootnative/core...");
+    logger.break();
+    try {
+      await execa3(cmd, args, { cwd, stdio: "inherit" });
+      logger.break();
+      logger.success("Installed @rootnative/core");
+    } catch {
+      logger.break();
+      logger.error("Failed to install @rootnative/core");
+      logger.info(`Run manually: ${chalk5.bold(command)}`);
+    }
+  }
+  logger.break();
+  logger.success("Project initialized!");
+  logger.info(
+    `Add components with: ${chalk5.bold("npx rootnative add <component>")}`
+  );
+  logger.break();
+}
+
+// src/commands/list.ts
+import path6 from "path";
+import chalk6 from "chalk";
+import fs6 from "fs-extra";
+async function listCommand(cwd) {
+  logger.break();
+  const config = await readConfig(cwd);
+  const componentsDir = resolveAliasPath(
+    config.aliases.components,
+    cwd
+  );
+  const spinner = createSpinner(
+    "Fetching component registry..."
+  );
+  spinner.start();
+  const registryIndex = await fetchRegistryIndex(config);
+  spinner.succeed("Registry loaded");
+  logger.break();
+  console.log(
+    chalk6.bold(`Available components (v${registryIndex.version}):`)
+  );
+  logger.break();
+  console.log(
+    `  ${chalk6.dim(padEnd("Name", 28))}${chalk6.dim(padEnd("Status", 14))}${chalk6.dim("Description")}`
+  );
+  console.log(
+    `  ${chalk6.dim("-".repeat(70))}`
+  );
+  for (const component of registryIndex.components) {
+    const componentDir = path6.join(componentsDir, component.name);
+    const installed = await fs6.pathExists(componentDir);
+    const status = installed ? chalk6.green("installed") : chalk6.dim("-");
+    const nameDisplay = installed ? chalk6.green(component.name) : component.name;
+    console.log(
+      `  ${padEnd(nameDisplay, installed ? 28 + 10 : 28)}${padEnd(status, installed ? 14 + 10 : 14)}${chalk6.dim(component.description)}`
+    );
+  }
+  logger.break();
+}
+function padEnd(str, length) {
+  const visibleLength = str.replace(
+    // eslint-disable-next-line no-control-regex
+    /\u001b\[\d+m/g,
+    ""
+  ).length;
+  const padding = Math.max(0, length - visibleLength);
+  return str + " ".repeat(padding);
+}
+
+// src/commands/update.ts
+import path7 from "path";
+import chalk8 from "chalk";
+import fs7 from "fs-extra";
+import prompts4 from "prompts";
+
+// src/lib/diff.ts
+import chalk7 from "chalk";
+function computeDiff(oldContent, newContent, fileName) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const lines = [];
+  let additions = 0;
+  let deletions = 0;
+  const lcs = buildLCS(oldLines, newLines);
+  let oldIdx = 0;
+  let newIdx = 0;
+  for (const [lcsOld, lcsNew] of lcs) {
+    while (oldIdx < lcsOld) {
+      lines.push({ type: "remove", content: oldLines[oldIdx] });
+      deletions++;
+      oldIdx++;
+    }
+    while (newIdx < lcsNew) {
+      lines.push({ type: "add", content: newLines[newIdx] });
+      additions++;
+      newIdx++;
+    }
+    lines.push({ type: "context", content: oldLines[oldIdx] });
+    oldIdx++;
+    newIdx++;
+  }
+  while (oldIdx < oldLines.length) {
+    lines.push({ type: "remove", content: oldLines[oldIdx] });
+    deletions++;
+    oldIdx++;
+  }
+  while (newIdx < newLines.length) {
+    lines.push({ type: "add", content: newLines[newIdx] });
+    additions++;
+    newIdx++;
+  }
+  return {
+    fileName,
+    hasChanges: additions > 0 || deletions > 0,
+    additions,
+    deletions,
+    lines
+  };
+}
+function buildLCS(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array(n + 1).fill(0)
+  );
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift([i - 1, j - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return result;
+}
+function formatDiff(diff, context = 3) {
+  if (!diff.hasChanges) {
+    return chalk7.dim(`  ${diff.fileName}: no changes`);
+  }
+  const output = [];
+  output.push(
+    chalk7.bold(`  ${diff.fileName}`) + chalk7.green(` +${diff.additions}`) + chalk7.red(` -${diff.deletions}`)
+  );
+  const changeIndices = /* @__PURE__ */ new Set();
+  diff.lines.forEach((line, idx) => {
+    if (line.type !== "context") {
+      for (let c = Math.max(0, idx - context); c <= Math.min(diff.lines.length - 1, idx + context); c++) {
+        changeIndices.add(c);
+      }
+    }
+  });
+  let lastPrinted = -1;
+  for (const idx of Array.from(changeIndices).sort(
+    (a, b) => a - b
+  )) {
+    if (lastPrinted !== -1 && idx > lastPrinted + 1) {
+      output.push(chalk7.dim("    ..."));
+    }
+    const line = diff.lines[idx];
+    if (line.type === "add") {
+      output.push(chalk7.green(`    + ${line.content}`));
+    } else if (line.type === "remove") {
+      output.push(chalk7.red(`    - ${line.content}`));
+    } else {
+      output.push(chalk7.dim(`      ${line.content}`));
+    }
+    lastPrinted = idx;
+  }
+  return output.join("\n");
+}
+function formatDiffSummary(diffs) {
+  const changed = diffs.filter((d) => d.hasChanges);
+  if (changed.length === 0) {
+    return chalk7.dim("  No changes detected");
+  }
+  const totalAdd = changed.reduce(
+    (sum, d) => sum + d.additions,
+    0
+  );
+  const totalDel = changed.reduce(
+    (sum, d) => sum + d.deletions,
+    0
+  );
+  return `  ${changed.length} file(s) changed: ` + chalk7.green(`+${totalAdd}`) + " " + chalk7.red(`-${totalDel}`);
+}
+
+// src/commands/update.ts
+async function updateCommand(componentNames, cwd, options) {
+  logger.break();
+  const config = await readConfig(cwd);
+  const componentsDir = resolveAliasPath(config.aliases.components, cwd);
+  const libDir = resolveAliasPath(config.aliases.lib, cwd);
+  const spinner = createSpinner("Checking installed components...");
+  spinner.start();
+  let targetNames;
+  if (options.all) {
+    const installed = await getInstalledComponents(componentsDir);
+    if (installed.length === 0) {
+      spinner.fail("No components installed");
+      return;
+    }
+    targetNames = installed;
+  } else if (componentNames.length > 0) {
+    targetNames = componentNames;
+    const missing = [];
+    for (const name of targetNames) {
+      const dir = path7.join(componentsDir, name);
+      if (!await fs7.pathExists(dir)) {
+        missing.push(name);
+      }
+    }
+    if (missing.length > 0) {
+      spinner.fail(
+        `Not installed: ${missing.join(", ")}. Use "rootnative add" instead.`
+      );
+      return;
+    }
+  } else {
+    spinner.fail("Specify component names or use --all to update everything.");
+    return;
+  }
+  spinner.succeed(`Found ${targetNames.length} component(s) to check`);
+  const resolveSpinner = createSpinner("Fetching latest from registry...");
+  resolveSpinner.start();
+  const resolution = await resolveComponents(config, targetNames);
+  const allComponentNames = getComponentNames(resolution);
+  const utilsRegistry = await fetchUtilsRegistry(config);
+  resolveSpinner.succeed("Registry fetched");
+  const componentDiffs = [];
+  for (const { entry } of resolution.components) {
+    const componentDir = path7.join(componentsDir, entry.name);
+    if (!await fs7.pathExists(componentDir)) {
+      componentDiffs.push({
+        name: entry.name,
+        diffs: [],
+        hasChanges: true
+      });
+      continue;
+    }
+    const diffs = [];
+    for (const filePath of entry.files) {
+      const fileName = path7.basename(filePath);
+      const localPath = path7.join(componentDir, fileName);
+      const remoteContent = await fetchFileContent(config, filePath);
+      const transformed = transformImports(remoteContent, {
+        config,
+        componentName: entry.name,
+        installedComponents: allComponentNames
+      });
+      let localContent = "";
+      if (await fs7.pathExists(localPath)) {
+        localContent = await fs7.readFile(localPath, "utf-8");
+      }
+      diffs.push(computeDiff(localContent, transformed, fileName));
+    }
+    const hasChanges = diffs.some((d) => d.hasChanges);
+    componentDiffs.push({ name: entry.name, diffs, hasChanges });
+  }
+  const utilDiffs = [];
+  for (const utilName of resolution.utils) {
+    const utilEntry = utilsRegistry[utilName];
+    if (!utilEntry) continue;
+    const fileName = path7.basename(utilEntry.file);
+    const localPath = path7.join(libDir, fileName);
+    const remoteContent = await fetchFileContent(config, utilEntry.file);
+    let localContent = "";
+    if (await fs7.pathExists(localPath)) {
+      localContent = await fs7.readFile(localPath, "utf-8");
+    }
+    utilDiffs.push(computeDiff(localContent, remoteContent, `lib/${fileName}`));
+  }
+  const utilExports = {};
+  for (const utilName of resolution.utils) {
+    const utilEntry = utilsRegistry[utilName];
+    if (utilEntry) {
+      utilExports[utilName] = utilEntry.exports;
+    }
+  }
+  const newBarrel = generateUtilsBarrel(resolution.utils, utilExports);
+  const barrelPath = path7.join(libDir, "rootnative-utils.ts");
+  let oldBarrel = "";
+  if (await fs7.pathExists(barrelPath)) {
+    oldBarrel = await fs7.readFile(barrelPath, "utf-8");
+  }
+  utilDiffs.push(computeDiff(oldBarrel, newBarrel, "lib/rootnative-utils.ts"));
+  const changedComponents = componentDiffs.filter((c) => c.hasChanges);
+  const changedUtils = utilDiffs.filter((d) => d.hasChanges);
+  const totalChanges = changedComponents.length + (changedUtils.length > 0 ? 1 : 0);
+  if (totalChanges === 0) {
+    logger.break();
+    logger.success("All components are up to date!");
+    logger.break();
+    return;
+  }
+  logger.break();
+  console.log(
+    chalk8.bold(`${changedComponents.length} component(s) with updates:`)
+  );
+  logger.break();
+  for (const comp of componentDiffs) {
+    if (!comp.hasChanges) {
+      console.log(chalk8.dim(`  ${comp.name}: up to date`));
+      continue;
+    }
+    if (comp.diffs.length === 0) {
+      console.log(
+        `  ${chalk8.yellow(comp.name)}: ${chalk8.yellow("new dependency (will be added)")}`
+      );
+      continue;
+    }
+    console.log(chalk8.bold.yellow(`  ${comp.name}:`));
+    console.log(formatDiffSummary(comp.diffs));
+    for (const diff of comp.diffs) {
+      if (diff.hasChanges) {
+        console.log(formatDiff(diff));
+      }
+    }
+    logger.break();
+  }
+  if (changedUtils.length > 0) {
+    console.log(chalk8.bold("Utility updates:"));
+    for (const diff of changedUtils) {
+      if (diff.hasChanges) {
+        console.log(formatDiff(diff));
+      }
+    }
+    logger.break();
+  }
+  if (options.dryRun) {
+    logger.info("Dry run complete. No files were written.");
+    return;
+  }
+  const { proceed } = await prompts4({
+    type: "confirm",
+    name: "proceed",
+    message: `Apply updates to ${changedComponents.length} component(s)?`,
+    initial: true
+  });
+  if (!proceed) {
+    logger.info("Cancelled.");
+    return;
+  }
+  const applySpinner = createSpinner("Applying updates...");
+  applySpinner.start();
+  for (const comp of changedComponents) {
+    const componentDir = path7.join(componentsDir, comp.name);
+    await fs7.ensureDir(componentDir);
+    if (comp.diffs.length === 0) {
+      const entry = resolution.components.find(
+        (c) => c.entry.name === comp.name
+      );
+      if (!entry) continue;
+      for (const filePath of entry.entry.files) {
+        const content = await fetchFileContent(config, filePath);
+        const fileName = path7.basename(filePath);
+        const transformed = transformImports(content, {
+          config,
+          componentName: comp.name,
+          installedComponents: allComponentNames
+        });
+        await fs7.writeFile(
+          path7.join(componentDir, fileName),
+          transformed,
+          "utf-8"
+        );
+      }
+      continue;
+    }
+    for (const diff of comp.diffs) {
+      if (!diff.hasChanges) continue;
+      const newContent = diff.lines.filter((l) => l.type !== "remove").map((l) => l.content).join("\n");
+      await fs7.writeFile(
+        path7.join(componentDir, diff.fileName),
+        newContent,
+        "utf-8"
+      );
+    }
+  }
+  await fs7.ensureDir(libDir);
+  for (const diff of changedUtils) {
+    if (!diff.hasChanges) continue;
+    const newContent = diff.lines.filter((l) => l.type !== "remove").map((l) => l.content).join("\n");
+    const filePath = path7.join(
+      libDir,
+      // diff.fileName is like "lib/color.ts" — strip the "lib/" prefix
+      diff.fileName.replace(/^lib\//, "")
+    );
+    await fs7.writeFile(filePath, newContent, "utf-8");
+  }
+  applySpinner.succeed("Updates applied");
+  logger.break();
+  logger.success(
+    `Updated ${changedComponents.length} component(s): ${changedComponents.map((c) => c.name).join(", ")}`
+  );
+  logger.break();
+}
+async function getInstalledComponents(componentsDir) {
+  if (!await fs7.pathExists(componentsDir)) {
+    return [];
+  }
+  const entries = await fs7.readdir(componentsDir);
+  const components = [];
+  for (const entry of entries) {
+    const fullPath = path7.join(componentsDir, entry);
+    const stat = await fs7.stat(fullPath);
+    if (stat.isDirectory()) {
+      const indexPath = path7.join(fullPath, "index.ts");
+      if (await fs7.pathExists(indexPath)) {
+        components.push(entry);
+      }
+    }
+  }
+  return components;
+}
+
+// src/commands/upgrade.ts
+import path8 from "path";
+import chalk9 from "chalk";
+import { execa as execa4 } from "execa";
+import fs8 from "fs-extra";
+import prompts5 from "prompts";
+async function fetchLatestFromNpm(packageName) {
+  const url = `https://registry.npmjs.org/${packageName}/latest`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${packageName} from npm: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+function getInstalledPackageInfo(cwd, packageName) {
+  const pkgPath = path8.resolve(
+    cwd,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  if (!fs8.pathExistsSync(pkgPath)) {
+    return null;
+  }
+  const pkg = fs8.readJSONSync(pkgPath);
+  return {
+    version: pkg.version,
+    peerDependencies: pkg.peerDependencies,
+    peerDependenciesMeta: pkg.peerDependenciesMeta
+  };
+}
+function diffPeerDeps(current, latest) {
+  const currentDeps = current ?? {};
+  const latestDeps = latest ?? {};
+  const added = {};
+  const changed = {};
+  const removed = [];
+  for (const [pkg, range] of Object.entries(latestDeps)) {
+    if (!(pkg in currentDeps)) {
+      added[pkg] = range;
+    } else if (currentDeps[pkg] !== range) {
+      changed[pkg] = {
+        from: currentDeps[pkg],
+        to: range
+      };
+    }
+  }
+  for (const pkg of Object.keys(currentDeps)) {
+    if (!(pkg in latestDeps)) {
+      removed.push(pkg);
+    }
+  }
+  return { added, changed, removed };
+}
+function getProjectDeps(cwd) {
+  const pkgPath = path8.resolve(cwd, "package.json");
+  try {
+    const pkg = fs8.readJSONSync(pkgPath);
+    return {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+  } catch {
+    return {};
+  }
+}
+function hasDiffChanges(diff) {
+  return Object.keys(diff.added).length > 0 || Object.keys(diff.changed).length > 0 || diff.removed.length > 0;
+}
+async function upgradeCommand(cwd, options = {}) {
+  logger.break();
+  await readConfig(cwd);
+  const spinner = createSpinner("Detecting project...");
+  spinner.start();
+  const project = await detectProject(cwd);
+  spinner.stop();
+  if (project.type === "unknown") {
+    logger.error("No React Native or Expo project detected.");
+    process.exit(1);
+  }
+  const installed = getInstalledPackageInfo(cwd, "@rootnative/core");
+  if (!installed) {
+    logger.error(
+      '@rootnative/core is not installed. Run "rootnative init" first.'
+    );
+    process.exit(1);
+  }
+  const fetchSpinner = createSpinner("Checking for updates...");
+  fetchSpinner.start();
+  const latest = await fetchLatestFromNpm("@rootnative/core");
+  fetchSpinner.succeed("Checked npm registry");
+  if (installed.version === latest.version) {
+    logger.break();
+    logger.success(
+      `Already on the latest version ${chalk9.bold(`v${installed.version}`)}`
+    );
+    logger.break();
+    if (options.all) {
+      logger.info("Updating installed components...");
+      await updateCommand([], cwd, { all: true, dryRun: false });
+    }
+    return;
+  }
+  logger.break();
+  logger.info(`Installed: ${chalk9.bold(`v${installed.version}`)}`);
+  logger.info(`Latest:    ${chalk9.bold(chalk9.green(`v${latest.version}`))}`);
+  const diff = diffPeerDeps(installed.peerDependencies, latest.peerDependencies);
+  if (hasDiffChanges(diff)) {
+    logger.break();
+    console.log(chalk9.bold("Peer dependency changes:"));
+    logger.break();
+    for (const [pkg, range] of Object.entries(diff.added)) {
+      console.log(`  ${chalk9.green("+")} ${pkg} ${chalk9.dim(range)}`);
+    }
+    for (const [pkg, { from, to }] of Object.entries(diff.changed)) {
+      console.log(
+        `  ${chalk9.yellow("~")} ${pkg} ${chalk9.dim(from)} \u2192 ${chalk9.dim(to)}`
+      );
+    }
+    for (const pkg of diff.removed) {
+      console.log(`  ${chalk9.red("-")} ${pkg}`);
+    }
+  }
+  const projectDeps = getProjectDeps(cwd);
+  const toInstall = ["@rootnative/core"];
+  const optionalMeta = latest.peerDependenciesMeta ?? {};
+  for (const [pkg] of Object.entries(diff.added)) {
+    const isOptional = optionalMeta[pkg]?.optional === true;
+    if (!isOptional && !projectDeps[pkg]) {
+      toInstall.push(pkg);
+    }
+  }
+  const latestPeers = latest.peerDependencies ?? {};
+  for (const [pkg] of Object.entries(latestPeers)) {
+    const isOptional = optionalMeta[pkg]?.optional === true;
+    if (!isOptional && !projectDeps[pkg] && !toInstall.includes(pkg)) {
+      toInstall.push(pkg);
+    }
+  }
+  logger.break();
+  console.log(chalk9.bold("Upgrade plan:"));
+  logger.break();
+  console.log(
+    `  ${chalk9.cyan("upgrade")} @rootnative/core ${chalk9.dim(`v${installed.version}`)} \u2192 ${chalk9.green(`v${latest.version}`)}`
+  );
+  const newDeps = toInstall.filter((p) => p !== "@rootnative/core");
+  if (newDeps.length > 0) {
+    for (const pkg of newDeps) {
+      console.log(
+        `  ${chalk9.green("install")} ${pkg} ${chalk9.dim("(new peer dependency)")}`
+      );
+    }
+  }
+  const missingOptional = [];
+  for (const [pkg] of Object.entries(latestPeers)) {
+    const isOptional = optionalMeta[pkg]?.optional === true;
+    if (isOptional && !projectDeps[pkg]) {
+      missingOptional.push(pkg);
+    }
+  }
+  if (missingOptional.length > 0) {
+    logger.break();
+    logger.info(
+      `Optional peer dependencies not installed: ${chalk9.dim(missingOptional.join(", "))}`
+    );
+  }
+  logger.break();
+  if (!options.yes) {
+    const { proceed } = await prompts5({
+      type: "confirm",
+      name: "proceed",
+      message: "Proceed with upgrade?",
+      initial: true
+    });
+    if (!proceed) {
+      logger.info("Upgrade cancelled.");
+      return;
+    }
+  }
+  const pm = options.packageManager ?? project.packageManager;
+  const command = getInstallCommand(pm, toInstall);
+  const [cmd, ...args] = command.split(" ");
+  logger.break();
+  logger.info("Upgrading @rootnative/core...");
+  logger.break();
+  try {
+    await execa4(cmd, args, { cwd, stdio: "inherit" });
+    logger.break();
+    logger.success("Upgrade complete");
+  } catch {
+    logger.break();
+    logger.error("Failed to upgrade");
+    logger.error(`Run manually: ${chalk9.bold(command)}`);
+    process.exit(1);
+  }
+  const updated = getInstalledPackageInfo(cwd, "@rootnative/core");
+  logger.break();
+  if (updated) {
+    logger.success(
+      `@rootnative/core upgraded to ${chalk9.bold(`v${updated.version}`)}`
+    );
+  }
+  if (newDeps.length > 0) {
+    logger.success(`Installed ${newDeps.length} new peer dependency(s)`);
+  }
+  if (diff.removed.length > 0) {
+    logger.break();
+    logger.info(
+      `The following peer dependencies are no longer required and can be removed:`
+    );
+    for (const pkg of diff.removed) {
+      logger.info(`  ${pkg}`);
+    }
+  }
+  logger.break();
+  if (options.all) {
+    logger.info("Updating installed components...");
+    await updateCommand([], cwd, { all: true, dryRun: false });
+  }
+}
+
+// src/lib/types.ts
+var PACKAGE_MANAGERS = ["npm", "yarn", "pnpm", "bun"];
+function isValidPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("rootnative").description("Add RootNative UI components to your React Native project").version("0.1.0");
+program.command("create").description("Create a new project with RootNative UI pre-configured").argument("[name]", "Project name").option("-y, --yes", "Skip prompts and use defaults", false).option("-t, --template <name>", "Template to use (blank, with-router)").option(
+  "--package-manager <pm>",
+  `Package manager to use (${PACKAGE_MANAGERS.join(", ")})`
+).action(async (name, options) => {
+  try {
+    if (options.packageManager) {
+      validatePackageManager(options.packageManager);
+    }
+    await createCommand(name, {
+      yes: options.yes,
+      template: options.template,
+      packageManager: options.packageManager
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("init").description("Initialize your project for RootNative UI").option("-y, --yes", "Skip prompts and use defaults", false).option("--components-alias <alias>", "Components install path alias").option("--lib-alias <alias>", "Utility files path alias").option(
+  "--package-manager <pm>",
+  `Package manager to use (${PACKAGE_MANAGERS.join(", ")})`
+).action(async (options) => {
+  try {
+    if (options.packageManager) {
+      validatePackageManager(options.packageManager);
+    }
+    await initCommand(process.cwd(), {
+      yes: options.yes,
+      componentsAlias: options.componentsAlias,
+      libAlias: options.libAlias,
+      packageManager: options.packageManager
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("add").description("Add components to your project").argument("<components...>", "Component names to add").option("-f, --force", "Overwrite existing components", false).option(
+  "-d, --dry-run",
+  "Show what would be installed without making changes",
+  false
+).option(
+  "--package-manager <pm>",
+  `Package manager to use (${PACKAGE_MANAGERS.join(", ")})`
+).action(async (components, options) => {
+  try {
+    if (options.packageManager) {
+      validatePackageManager(options.packageManager);
+    }
+    await addCommand(components, process.cwd(), {
+      force: options.force,
+      dryRun: options.dryRun,
+      packageManager: options.packageManager
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("update").description("Update installed components to the latest version").argument("[components...]", "Component names to update").option("-a, --all", "Update all installed components", false).option("-d, --dry-run", "Show diff without applying changes", false).action(async (components, options) => {
+  try {
+    await updateCommand(components, process.cwd(), {
+      all: options.all,
+      dryRun: options.dryRun
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("list").description("List available components").action(async () => {
+  try {
+    await listCommand(process.cwd());
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("doctor").description("Check your project for issues").action(async () => {
+  try {
+    await doctorCommand(process.cwd());
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("upgrade").description("Upgrade @rootnative/core and install new peer dependencies").option("-y, --yes", "Skip confirmation prompt", false).option("-a, --all", "Also update all installed component files", false).option(
+  "--package-manager <pm>",
+  `Package manager to use (${PACKAGE_MANAGERS.join(", ")})`
+).action(async (options) => {
+  try {
+    if (options.packageManager) {
+      validatePackageManager(options.packageManager);
+    }
+    await upgradeCommand(process.cwd(), {
+      yes: options.yes,
+      all: options.all,
+      packageManager: options.packageManager
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
+function validatePackageManager(value) {
+  if (!isValidPackageManager(value)) {
+    logger.error(
+      `Unknown package manager "${value}". Available: ${PACKAGE_MANAGERS.join(", ")}`
+    );
+    process.exit(1);
+  }
+}
+function handleError(error) {
+  if (error instanceof Error) {
+    logger.error(error.message);
+  } else {
+    logger.error("An unexpected error occurred.");
+  }
+  process.exit(1);
+}
+program.parse();