@rootnative/cli 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/index.mjs

@@ -45,15 +45,96 @@ function resolveAliasPath(alias, cwd) {
 }
 
 // src/lib/detector.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+
+// src/lib/tsconfig-paths.ts
 import path2 from "path";
 import fs2 from "fs-extra";
+function stripJsonComments(raw) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; i++) {
+    const char = raw[i];
+    if (inString) {
+      out += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      out += char;
+      continue;
+    }
+    if (char === "/" && raw[i + 1] === "*") {
+      const end = raw.indexOf("*/", i + 2);
+      i = end === -1 ? raw.length : end + 1;
+      continue;
+    }
+    if (char === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+function parseAliasPrefix(alias) {
+  const match = /^([^./\\][^/\\]*)\//.exec(alias);
+  if (!match) return null;
+  return { prefix: match[1], target: "src" };
+}
+async function ensureTsconfigPaths(cwd, alias) {
+  const parsed = parseAliasPrefix(alias);
+  if (!parsed) return { status: "not-an-alias" };
+  const { prefix, target } = parsed;
+  const tsconfigPath = path2.resolve(cwd, "tsconfig.json");
+  if (!await fs2.pathExists(tsconfigPath)) {
+    return { status: "no-tsconfig" };
+  }
+  try {
+    const raw = await fs2.readFile(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(stripJsonComments(raw));
+    const key = `${prefix}/*`;
+    const existing = tsconfig.compilerOptions?.paths;
+    if (existing && key in existing) {
+      return { status: "already-mapped", prefix };
+    }
+    const compilerOptions = tsconfig.compilerOptions ?? {};
+    tsconfig.compilerOptions = {
+      ...compilerOptions,
+      baseUrl: compilerOptions.baseUrl ?? ".",
+      paths: {
+        ...existing,
+        [key]: [`./${target}/*`]
+      }
+    };
+    await fs2.writeJSON(tsconfigPath, tsconfig, { spaces: 2 });
+    return { status: "added", prefix, target };
+  } catch (error) {
+    return {
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/lib/detector.ts
 async function detectProjectType(cwd) {
-  const pkgPath = path2.resolve(cwd, "package.json");
-  const hasPackageJson = await fs2.pathExists(pkgPath);
+  const pkgPath = path3.resolve(cwd, "package.json");
+  const hasPackageJson = await fs3.pathExists(pkgPath);
   if (!hasPackageJson) {
     return "unknown";
   }
-  const pkg = await fs2.readJSON(pkgPath);
+  const pkg = await fs3.readJSON(pkgPath);
   const allDeps = {
     ...pkg.dependencies,
     ...pkg.devDependencies
@@ -75,37 +156,33 @@ async function detectPackageManager(cwd) {
     ["package-lock.json", "npm"]
   ];
   for (const [file, manager] of lockFiles) {
-    if (await fs2.pathExists(path2.resolve(cwd, file))) {
+    if (await fs3.pathExists(path3.resolve(cwd, file))) {
       return manager;
     }
   }
   return "npm";
 }
 async function detectTypeScript(cwd) {
-  return fs2.pathExists(path2.resolve(cwd, "tsconfig.json"));
+  return fs3.pathExists(path3.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)) {
+    const dirPath = path3.resolve(cwd, dir);
+    if (await fs3.pathExists(dirPath)) {
       return dir;
     }
   }
   return null;
 }
 async function detectAliases(cwd) {
-  const tsconfigPath = path2.resolve(cwd, "tsconfig.json");
-  if (!await fs2.pathExists(tsconfigPath)) {
+  const tsconfigPath = path3.resolve(cwd, "tsconfig.json");
+  if (!await fs3.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 raw = await fs3.readFile(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(stripJsonComments(raw));
     const paths = tsconfig.compilerOptions?.paths;
     if (!paths) {
       return null;
@@ -147,9 +224,9 @@ function getInstallCommand(pm, packages) {
 }
 
 // src/lib/installer.ts
-import path3 from "path";
+import path6 from "path";
 import { execa } from "execa";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 
 // src/lib/logger.ts
 import chalk from "chalk";
@@ -212,6 +289,7 @@ async function fetchFileContent(config, filePath) {
 }
 
 // src/lib/resolver.ts
+import path4 from "path";
 async function resolveComponents(config, requestedNames) {
   const resolved = /* @__PURE__ */ new Map();
   const utilsRegistry = await fetchUtilsRegistry(config);
@@ -244,9 +322,11 @@ function buildResult(resolved, utilsRegistry) {
       optionalDeps[pkg] = version;
     }
   }
+  const utilFileNames = {};
   for (const utilName of utilSet) {
     const utilEntry = utilsRegistry[utilName];
     if (utilEntry) {
+      utilFileNames[utilName] = path4.basename(utilEntry.file);
       for (const [pkg, version] of Object.entries(utilEntry.dependencies)) {
         optionalDeps[pkg] = version;
       }
@@ -255,6 +335,7 @@ function buildResult(resolved, utilsRegistry) {
   return {
     components,
     utils: Array.from(utilSet).sort(),
+    utilFileNames,
     npmDependencies: npmDeps,
     optionalNpmDependencies: optionalDeps
   };
@@ -264,24 +345,67 @@ function getComponentNames(result) {
 }
 
 // src/lib/transform.ts
+import path5 from "path";
 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;
+var SHARED_ROOT_MODULES = /* @__PURE__ */ new Set(["safe-area"]);
+function isPrefixAlias(alias) {
+  return !alias.startsWith(".");
+}
+function buildSpecifier(alias, rest, componentsAlias, componentName) {
+  if (isPrefixAlias(alias)) {
+    return `${alias}/${rest}`;
+  }
+  const fromDir = path5.posix.join(
+    toPosix(stripRelativePrefix(componentsAlias)),
+    componentName
+  );
+  const target = path5.posix.join(toPosix(stripRelativePrefix(alias)), rest);
+  const relative = path5.posix.relative(fromDir, target);
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function stripRelativePrefix(alias) {
+  return alias.replace(/^\.\//, "");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
 function transformImports(source, options) {
-  const { config, installedComponents } = options;
+  const { config, componentName, 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}`;
+      const specifier = buildSpecifier(
+        libAlias,
+        "rootnative-utils",
+        componentsAlias,
+        componentName
+      );
+      return `${prefix}${quote}${specifier}${quote}`;
     }
     if (importPath.startsWith("@rootnative/core")) {
       return match;
     }
+    if (importPath.startsWith("../internal/")) {
+      const restOfPath = importPath.replace(/^\.\.\/internal\//, "");
+      return `${prefix}${quote}./${restOfPath}${quote}`;
+    }
+    if (SHARED_ROOT_MODULES.has(importPath.replace(/^\.\.\//, ""))) {
+      const restOfPath = importPath.replace(/^\.\.\//, "");
+      return `${prefix}${quote}./${restOfPath}${quote}`;
+    }
     if (importPath.startsWith("../")) {
       const targetComponent = extractComponentName(importPath);
       if (targetComponent && installedComponents.includes(targetComponent)) {
         const restOfPath = importPath.replace(/^\.\.\//, "");
-        return `${prefix}${quote}${componentsAlias}/${restOfPath}${quote}`;
+        const specifier = buildSpecifier(
+          componentsAlias,
+          restOfPath,
+          componentsAlias,
+          componentName
+        );
+        return `${prefix}${quote}${specifier}${quote}`;
       }
     }
     return match;
@@ -324,8 +448,8 @@ async function installComponents(options) {
   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);
+    const componentDir = path6.join(componentsDir, entry.name);
+    const exists = await fs4.pathExists(componentDir);
     if (exists && !force) {
       logger.warn(
         `${entry.name} already exists, skipping (use --force to overwrite)`
@@ -334,17 +458,17 @@ async function installComponents(options) {
     }
     const compSpinner = createSpinner(`Adding ${entry.name}...`);
     compSpinner.start();
-    await fs3.ensureDir(componentDir);
+    await fs4.ensureDir(componentDir);
     for (const filePath of entry.files) {
       const content = await fetchFileContent(config, filePath);
-      const fileName = path3.basename(filePath);
+      const fileName = path6.basename(filePath);
       const transformed = transformImports(content, {
         config,
         componentName: entry.name,
         installedComponents: allComponentNames
       });
-      await fs3.writeFile(
-        path3.join(componentDir, fileName),
+      await fs4.writeFile(
+        path6.join(componentDir, fileName),
         transformed,
         "utf-8"
       );
@@ -370,13 +494,13 @@ async function installComponents(options) {
   }
 }
 async function copyUtilFiles(config, resolution, utilsRegistry, libDir) {
-  await fs3.ensureDir(libDir);
+  await fs4.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");
+    const fileName = path6.basename(utilEntry.file);
+    await fs4.writeFile(path6.join(libDir, fileName), content, "utf-8");
   }
 }
 async function generateBarrel(resolution, utilsRegistry, libDir) {
@@ -396,18 +520,18 @@ async function generateBarrel(resolution, utilsRegistry, libDir) {
     utilExports,
     utilTypeExports
   );
-  await fs3.writeFile(
-    path3.join(libDir, "rootnative-utils.ts"),
+  await fs4.writeFile(
+    path6.join(libDir, "rootnative-utils.ts"),
     barrelContent,
     "utf-8"
   );
 }
 function collectDepsToInstall(resolution, cwd) {
   const deps = [];
-  const pkgPath = path3.resolve(cwd, "package.json");
+  const pkgPath = path6.resolve(cwd, "package.json");
   let existingDeps = {};
   try {
-    const pkg = fs3.readJSONSync(pkgPath);
+    const pkg = fs4.readJSONSync(pkgPath);
     existingDeps = {
       ...pkg.dependencies,
       ...pkg.devDependencies
@@ -455,7 +579,10 @@ async function addCommand(componentNames, cwd, options) {
   if (resolution.utils.length > 0) {
     logger.break();
     console.log(chalk2.bold("Utilities to copy:"));
-    console.log(`  ${resolution.utils.map((u) => `${u}.ts`).join(", ")}`);
+    const fileNames = resolution.utils.map(
+      (u) => resolution.utilFileNames[u] ?? u
+    );
+    console.log(`  ${fileNames.join(", ")}`);
   }
   const npmDeps = Object.keys(resolution.npmDependencies);
   const optionalDeps = Object.keys(resolution.optionalNpmDependencies);
@@ -474,15 +601,17 @@ async function addCommand(componentNames, cwd, options) {
     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;
+  if (!options.yes) {
+    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;
@@ -501,10 +630,10 @@ async function addCommand(componentNames, cwd, options) {
 }
 
 // src/commands/create.ts
-import path4 from "path";
+import path7 from "path";
 import chalk3 from "chalk";
 import { execa as execa2 } from "execa";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 import prompts2 from "prompts";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 var ROOTNATIVE_PACKAGES = ["@rootnative/core", "@rootnative/components"];
@@ -561,12 +690,53 @@ var TEMPLATE_BINARY_FILES = [
   "assets/adaptive-icon.png",
   "assets/favicon.png"
 ];
+var TEMPLATE_OPTIONAL_TEXT_FILES = ["CLAUDE.md", "README.md"];
 function isValidTemplate(value) {
   return value in TEMPLATE_CONFIGS;
 }
 function slugify(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function isCurrentDirName(input) {
+  const trimmed = input.trim();
+  return trimmed === "." || trimmed === "./" || trimmed === ".\\";
+}
+function resolveProjectTarget(input, cwd) {
+  const currentDir = path7.resolve(cwd);
+  if (isCurrentDirName(input)) {
+    const projectName2 = slugify(path7.basename(currentDir));
+    if (!projectName2) return { ok: false, reason: "invalid-folder-name" };
+    return {
+      ok: true,
+      target: { projectName: projectName2, targetDir: currentDir, useCurrentDir: true }
+    };
+  }
+  const projectName = slugify(input);
+  if (!projectName) return { ok: false, reason: "invalid-name" };
+  const targetDir = path7.resolve(currentDir, projectName);
+  return {
+    ok: true,
+    target: {
+      projectName,
+      targetDir,
+      useCurrentDir: targetDir === currentDir
+    }
+  };
+}
+function templateFiles(templateName) {
+  return [
+    ...TEMPLATE_CONFIGS[templateName].textFiles,
+    ...TEMPLATE_OPTIONAL_TEXT_FILES,
+    ...TEMPLATE_BINARY_FILES
+  ];
+}
+async function findConflicts(dir, files) {
+  const conflicts = [];
+  for (const file of files) {
+    if (await fs5.pathExists(path7.join(dir, file))) conflicts.push(file);
+  }
+  return conflicts;
+}
 function toDisplayName(slug) {
   return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
@@ -589,6 +759,11 @@ async function fetchText(url) {
   }
   return res.text();
 }
+async function fetchTextOptional(url) {
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  return res.text();
+}
 async function fetchBinary(url) {
   const res = await fetch(url);
   if (!res.ok) return null;
@@ -628,9 +803,9 @@ async function createCommand(name, options = {}) {
     }
     templateName = value;
   }
-  let projectName;
+  let nameInput;
   if (name) {
-    projectName = slugify(name);
+    nameInput = name;
   } else {
     const { value } = await prompts2({
       type: "text",
@@ -643,8 +818,26 @@ async function createCommand(name, options = {}) {
       logger.info("Create cancelled.");
       return;
     }
-    projectName = slugify(value);
+    nameInput = value;
+  }
+  const resolved = resolveProjectTarget(nameInput, process.cwd());
+  if (!resolved.ok) {
+    if (resolved.reason === "invalid-folder-name") {
+      logger.error(
+        `Cannot make a project name from the folder ${chalk3.bold(
+          path7.basename(path7.resolve(process.cwd()))
+        )}.`
+      );
+      logger.info(
+        `Give a name instead: ${chalk3.bold("npx rootnative create my-app")}`
+      );
+    } else {
+      logger.error(`${chalk3.bold(nameInput)} is not a usable project name.`);
+      logger.info("Use letters and numbers, for example my-app.");
+    }
+    process.exit(1);
   }
+  const { projectName, targetDir, useCurrentDir } = resolved.target;
   let displayName;
   if (options.yes) {
     displayName = toDisplayName(projectName);
@@ -685,8 +878,34 @@ async function createCommand(name, options = {}) {
     }
     packageManager = value;
   }
-  const targetDir = path4.resolve(process.cwd(), projectName);
-  if (await fs4.pathExists(targetDir)) {
+  if (useCurrentDir) {
+    const conflicts = await findConflicts(
+      targetDir,
+      templateFiles(templateName)
+    );
+    if (conflicts.length > 0) {
+      logger.warn("These files in the current directory will be overwritten:");
+      for (const file of conflicts) {
+        logger.info(`  ${file}`);
+      }
+      logger.break();
+      if (options.yes) {
+        logger.error("Nothing was changed.");
+        logger.info("Move or delete these files, then run create again.");
+        process.exit(1);
+      }
+      const { overwrite } = await prompts2({
+        type: "confirm",
+        name: "overwrite",
+        message: "Overwrite them?",
+        initial: false
+      });
+      if (!overwrite) {
+        logger.info("Create cancelled.");
+        return;
+      }
+    }
+  } else if (await fs5.pathExists(targetDir)) {
     if (options.yes) {
       logger.warn(`Directory ${chalk3.bold(projectName)} already exists.`);
       process.exit(1);
@@ -694,14 +913,14 @@ async function createCommand(name, options = {}) {
     const { overwrite } = await prompts2({
       type: "confirm",
       name: "overwrite",
-      message: `Directory ${chalk3.bold(projectName)} already exists. Overwrite?`,
+      message: `Directory ${chalk3.bold(projectName)} already exists. Delete it and all of its contents?`,
       initial: false
     });
     if (!overwrite) {
       logger.info("Create cancelled.");
       return;
     }
-    await fs4.remove(targetDir);
+    await fs5.remove(targetDir);
   }
   const templateConfig = TEMPLATE_CONFIGS[templateName];
   const { baseUrl, pinnedVersion } = await resolveTemplateSource();
@@ -710,7 +929,7 @@ async function createCommand(name, options = {}) {
   spinner.start();
   try {
     for (const dir of templateConfig.dirs) {
-      await fs4.ensureDir(path4.join(targetDir, dir));
+      await fs5.ensureDir(path7.join(targetDir, dir));
     }
     for (const file of templateConfig.textFiles) {
       let content = await fetchText(`${templateBaseUrl}/${file}`);
@@ -735,12 +954,18 @@ async function createCommand(name, options = {}) {
         }
         content = JSON.stringify(appJson, null, 2) + "\n";
       }
-      await fs4.outputFile(path4.join(targetDir, file), content);
+      await fs5.outputFile(path7.join(targetDir, file), content);
+    }
+    for (const file of TEMPLATE_OPTIONAL_TEXT_FILES) {
+      const content = await fetchTextOptional(`${templateBaseUrl}/${file}`);
+      if (content !== null) {
+        await fs5.outputFile(path7.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);
+        await fs5.outputFile(path7.join(targetDir, file), buffer);
       }
     }
     spinner.succeed("Project created");
@@ -772,7 +997,9 @@ async function createCommand(name, options = {}) {
       logger.break();
       logger.error("Failed to install dependencies");
       logger.info(
-        `Run manually: ${chalk3.bold(`cd ${projectName} && ${installCmd}`)}`
+        `Run manually: ${chalk3.bold(
+          useCurrentDir ? installCmd : `cd ${projectName} && ${installCmd}`
+        )}`
       );
     }
   }
@@ -780,7 +1007,9 @@ async function createCommand(name, options = {}) {
   logger.success(`Project ${chalk3.bold(displayName)} is ready!`);
   logger.break();
   logger.info("Next steps:");
-  logger.info(`  cd ${projectName}`);
+  if (!useCurrentDir) {
+    logger.info(`  cd ${projectName}`);
+  }
   if (!shouldInstall) {
     logger.info(`  ${getInstallCommand2(packageManager)}`);
   }
@@ -789,28 +1018,34 @@ async function createCommand(name, options = {}) {
 }
 
 // src/commands/doctor.ts
-import path5 from "path";
+import path8 from "path";
 import chalk4 from "chalk";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 function logCheck(status, message) {
-  const icon = status === "pass" ? chalk4.green("[pass]") : status === "warn" ? chalk4.yellow("[warn]") : chalk4.red("[fail]");
+  const icon = status === "pass" ? chalk4.green("[pass]") : status === "warn" ? chalk4.yellow("[warn]") : status === "info" ? chalk4.cyan("[info]") : chalk4.red("[fail]");
   console.log(`  ${icon} ${message}`);
 }
+var REQUIRED_BARREL_PEERS = [
+  {
+    name: "react-native-svg",
+    reason: "the @rootnative/components barrel requires it at load time (circular-progress, loading-indicator)"
+  }
+];
 async function doctorCommand(cwd) {
   logger.break();
   console.log(chalk4.bold("RootNative Doctor"));
   logger.break();
   let issues = 0;
-  if (await configExists(cwd)) {
+  const initialized = await configExists(cwd);
+  if (initialized) {
     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;
+    logCheck(
+      "info",
+      'Not initialized for the CLI workflow (no rootnative.json). Run "rootnative init" to copy component source.'
+    );
   }
-  const config = await readConfig(cwd);
+  const config = initialized ? await readConfig(cwd) : null;
   const project = await detectProject(cwd);
   if (project.type !== "unknown") {
     logCheck(
@@ -821,9 +1056,9 @@ async function doctorCommand(cwd) {
     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 pkgPath = path8.resolve(cwd, "package.json");
+  if (await fs6.pathExists(pkgPath)) {
+    const pkg = await fs6.readJSON(pkgPath);
     const allDeps = {
       ...pkg.dependencies,
       ...pkg.devDependencies
@@ -836,15 +1071,15 @@ async function doctorCommand(cwd) {
       issues++;
     }
   }
-  const corePkgPath = path5.resolve(
+  const corePkgPath = path8.resolve(
     cwd,
     "node_modules",
     "@rootnative",
     "core",
     "package.json"
   );
-  if (await fs5.pathExists(corePkgPath)) {
-    const corePkg = await fs5.readJSON(corePkgPath);
+  if (await fs6.pathExists(corePkgPath)) {
+    const corePkg = await fs6.readJSON(corePkgPath);
     logCheck("pass", `@rootnative/core@${corePkg.version} installed`);
   } else {
     logCheck(
@@ -861,70 +1096,97 @@ async function doctorCommand(cwd) {
       "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 (config) {
+    const componentsDir = resolveAliasPath(config.aliases.components, cwd);
+    if (await fs6.pathExists(componentsDir)) {
+      const dirs = await fs6.readdir(componentsDir);
+      const componentDirs = [];
+      for (const dir of dirs) {
+        const fullPath = path8.join(componentsDir, dir);
+        const stat = await fs6.stat(fullPath);
+        if (stat.isDirectory()) {
+          componentDirs.push(dir);
         }
       }
-      if (integrityOk) {
+      if (componentDirs.length > 0) {
+        let integrityOk = true;
+        for (const dir of componentDirs) {
+          const indexPath = path8.join(componentsDir, dir, "index.ts");
+          if (!await fs6.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(
-          "pass",
-          `${componentDirs.length} component(s) installed, all files present`
+          "warn",
+          'No components installed yet. Run "rootnative add <component>".'
         );
       }
     } else {
       logCheck(
         "warn",
-        'No components installed yet. Run "rootnative add <component>".'
+        `Components directory not found at ${config.aliases.components}`
       );
     }
+    const libDir = resolveAliasPath(config.aliases.lib, cwd);
+    const barrelPath = path8.join(libDir, "rootnative-utils.ts");
+    if (await fs6.pathExists(barrelPath)) {
+      logCheck("pass", "Utility barrel file present");
+    } else {
+      if (await fs6.pathExists(componentsDir)) {
+        const dirs = await fs6.readdir(componentsDir);
+        if (dirs.length > 0) {
+          logCheck("warn", "Utility barrel file (rootnative-utils.ts) missing");
+        }
+      }
+    }
+  }
+  const nodeModules = path8.resolve(cwd, "node_modules");
+  const inertiaPkgPath = path8.join(
+    nodeModules,
+    "@rootnative",
+    "inertia",
+    "package.json"
+  );
+  if (await fs6.pathExists(inertiaPkgPath)) {
+    const inertiaPkg = await fs6.readJSON(inertiaPkgPath);
+    logCheck("pass", `@rootnative/inertia@${inertiaPkg.version} installed`);
   } else {
     logCheck(
-      "warn",
-      `Components directory not found at ${config.aliases.components}`
+      "fail",
+      '@rootnative/inertia not installed (required by all animated components). Run "rootnative upgrade" or install it with react-native-reanimated and react-native-worklets.'
     );
+    issues++;
   }
-  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");
-      }
+  for (const peer of REQUIRED_BARREL_PEERS) {
+    if (await fs6.pathExists(path8.join(nodeModules, peer.name))) {
+      logCheck("pass", `${peer.name} installed`);
+      continue;
     }
+    logCheck("fail", `${peer.name} is not installed \u2014 ${peer.reason}.`);
+    console.log(`         Run: ${chalk4.bold(`npx expo install ${peer.name}`)}`);
+    issues++;
   }
-  const nodeModules = path5.resolve(cwd, "node_modules");
-  const safeAreaInstalled = await fs5.pathExists(
-    path5.join(nodeModules, "react-native-safe-area-context")
+  const safeAreaInstalled = await fs6.pathExists(
+    path8.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)"
+      "react-native-safe-area-context not installed (needed by: appbar, layout, bottom-sheet, navigation-bar, snackbar)"
     );
   }
-  const vectorIconsInstalled = await fs5.pathExists(
-    path5.join(nodeModules, "@expo", "vector-icons")
+  const vectorIconsInstalled = await fs6.pathExists(
+    path8.join(nodeModules, "@expo", "vector-icons")
   );
   if (vectorIconsInstalled) {
     logCheck("pass", "@expo/vector-icons installed");
@@ -937,6 +1199,7 @@ async function doctorCommand(cwd) {
   logger.break();
   if (issues > 0) {
     logger.error(`${issues} issue(s) found.`);
+    process.exitCode = 1;
   } else {
     logger.success("All checks passed!");
   }
@@ -947,6 +1210,68 @@ async function doctorCommand(cwd) {
 import chalk5 from "chalk";
 import { execa as execa3 } from "execa";
 import prompts3 from "prompts";
+
+// src/lib/llm-docs.ts
+import path9 from "path";
+import fs7 from "fs-extra";
+var CLAUDE_MD = "CLAUDE.md";
+var POINTER_MARKER = "@rootnative/components/llms.txt";
+var LLM_DOCS_POINTER = `## RootNative UI docs for AI agents
+
+This project uses RootNative UI (\`@rootnative/*\`). LLM-optimized docs:
+
+- \`node_modules/@rootnative/components/llms.txt\` \u2014 all component props for the exact installed version (works offline)
+- \`node_modules/@rootnative/core/llms.txt\` \u2014 theme system API (\`ThemeProvider\`, \`useTheme\`, \`defineTheme\`)
+- https://rootnative.github.io/ui/llms.txt \u2014 hosted overview (latest release)
+- https://rootnative.github.io/ui/llms-full.txt \u2014 hosted complete API reference (latest release)
+
+Prefer the \`node_modules\` copies \u2014 they match the installed version exactly.
+`;
+async function ensureLlmDocsPointer(cwd) {
+  const filePath = path9.join(cwd, CLAUDE_MD);
+  if (!await fs7.pathExists(filePath)) {
+    await fs7.outputFile(filePath, `# CLAUDE.md
+
+${LLM_DOCS_POINTER}`);
+    return "created";
+  }
+  const existing = await fs7.readFile(filePath, "utf8");
+  if (existing.includes(POINTER_MARKER)) {
+    return "already-present";
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  await fs7.outputFile(filePath, `${existing}${separator}${LLM_DOCS_POINTER}`);
+  return "appended";
+}
+
+// src/lib/registry-version.ts
+var NPM_REGISTRY2 = "https://registry.npmjs.org";
+async function resolveRegistryVersion() {
+  const fallback = "main";
+  try {
+    const res = await fetch(`${NPM_REGISTRY2}/@rootnative/core`);
+    if (!res.ok) {
+      return { version: fallback, fallback: { reason: "npm-unreachable" } };
+    }
+    const data = await res.json();
+    const version = data["dist-tags"]?.latest;
+    if (!version) {
+      return { version: fallback, fallback: { reason: "no-latest-tag" } };
+    }
+    const ref = `v${version}`;
+    const probe = await fetch(
+      `${DEFAULT_CONFIG.registryUrl}/${ref}/registry/index.json`
+    );
+    if (!probe.ok) {
+      return { version: fallback, fallback: { reason: "tag-missing", version } };
+    }
+    return { version: ref };
+  } catch {
+    return { version: fallback, fallback: { reason: "npm-unreachable" } };
+  }
+}
+
+// src/commands/init.ts
 async function initCommand(cwd, options = {}) {
   logger.break();
   if (await configExists(cwd)) {
@@ -1020,8 +1345,10 @@ async function initCommand(cwd, options = {}) {
     componentsAlias = answers.componentsAlias;
     libAlias = answers.libAlias;
   }
+  const registry = await resolveRegistryVersion();
   const config = {
     ...DEFAULT_CONFIG,
+    registryVersion: registry.version,
     aliases: {
       components: componentsAlias,
       lib: libAlias
@@ -1029,6 +1356,54 @@ async function initCommand(cwd, options = {}) {
   };
   await writeConfig(cwd, config);
   logger.success("Created rootnative.json");
+  if (registry.fallback) {
+    logger.break();
+    if (registry.fallback.reason === "tag-missing") {
+      logger.warn(
+        `Could not pin the registry to v${registry.fallback.version}; using "main".`
+      );
+      logger.warn(
+        "Copied component source may not match your installed packages."
+      );
+    } else {
+      logger.warn('Could not reach npm to pin the registry; using "main".');
+      logger.warn(
+        "Copied component source will come from the development branch."
+      );
+    }
+    logger.break();
+  }
+  const tsconfigPatch = await ensureTsconfigPaths(cwd, componentsAlias);
+  if (tsconfigPatch.status === "added") {
+    logger.success(
+      `Added "${tsconfigPatch.prefix}/*" path alias to tsconfig.json`
+    );
+  } else if (tsconfigPatch.status === "failed") {
+    logger.warn(`Could not update tsconfig.json: ${tsconfigPatch.error}`);
+    logger.info(
+      `Add a "paths" mapping for "${componentsAlias.split("/")[0]}/*" by hand.`
+    );
+  }
+  let addLlmDocs = options.yes;
+  if (!options.yes) {
+    const answer = await prompts3({
+      type: "confirm",
+      name: "addLlmDocs",
+      message: "Add RootNative LLM docs pointer to CLAUDE.md (for AI agents)?",
+      initial: true
+    });
+    addLlmDocs = answer.addLlmDocs;
+  }
+  if (addLlmDocs) {
+    const result = await ensureLlmDocsPointer(cwd);
+    if (result === "created") {
+      logger.success("Created CLAUDE.md with LLM docs pointer");
+    } else if (result === "appended") {
+      logger.success("Added LLM docs pointer to CLAUDE.md");
+    } else {
+      logger.info("CLAUDE.md already points to the RootNative LLM docs");
+    }
+  }
   let installCore = options.yes;
   if (!options.yes) {
     const answer = await prompts3({
@@ -1065,9 +1440,9 @@ async function initCommand(cwd, options = {}) {
 }
 
 // src/commands/list.ts
-import path6 from "path";
+import path10 from "path";
 import chalk6 from "chalk";
-import fs6 from "fs-extra";
+import fs8 from "fs-extra";
 async function listCommand(cwd) {
   logger.break();
   const config = await readConfig(cwd);
@@ -1093,8 +1468,8 @@ async function listCommand(cwd) {
     `  ${chalk6.dim("-".repeat(70))}`
   );
   for (const component of registryIndex.components) {
-    const componentDir = path6.join(componentsDir, component.name);
-    const installed = await fs6.pathExists(componentDir);
+    const componentDir = path10.join(componentsDir, component.name);
+    const installed = await fs8.pathExists(componentDir);
     const status = installed ? chalk6.green("installed") : chalk6.dim("-");
     const nameDisplay = installed ? chalk6.green(component.name) : component.name;
     console.log(
@@ -1114,9 +1489,9 @@ function padEnd(str, length) {
 }
 
 // src/commands/update.ts
-import path7 from "path";
+import path11 from "path";
 import chalk8 from "chalk";
-import fs7 from "fs-extra";
+import fs9 from "fs-extra";
 import prompts4 from "prompts";
 
 // src/lib/diff.ts
@@ -1266,8 +1641,8 @@ async function updateCommand(componentNames, cwd, options) {
     targetNames = componentNames;
     const missing = [];
     for (const name of targetNames) {
-      const dir = path7.join(componentsDir, name);
-      if (!await fs7.pathExists(dir)) {
+      const dir = path11.join(componentsDir, name);
+      if (!await fs9.pathExists(dir)) {
         missing.push(name);
       }
     }
@@ -1290,8 +1665,8 @@ async function updateCommand(componentNames, cwd, options) {
   resolveSpinner.succeed("Registry fetched");
   const componentDiffs = [];
   for (const { entry } of resolution.components) {
-    const componentDir = path7.join(componentsDir, entry.name);
-    if (!await fs7.pathExists(componentDir)) {
+    const componentDir = path11.join(componentsDir, entry.name);
+    if (!await fs9.pathExists(componentDir)) {
       componentDiffs.push({
         name: entry.name,
         diffs: [],
@@ -1301,8 +1676,8 @@ async function updateCommand(componentNames, cwd, options) {
     }
     const diffs = [];
     for (const filePath of entry.files) {
-      const fileName = path7.basename(filePath);
-      const localPath = path7.join(componentDir, fileName);
+      const fileName = path11.basename(filePath);
+      const localPath = path11.join(componentDir, fileName);
       const remoteContent = await fetchFileContent(config, filePath);
       const transformed = transformImports(remoteContent, {
         config,
@@ -1310,8 +1685,8 @@ async function updateCommand(componentNames, cwd, options) {
         installedComponents: allComponentNames
       });
       let localContent = "";
-      if (await fs7.pathExists(localPath)) {
-        localContent = await fs7.readFile(localPath, "utf-8");
+      if (await fs9.pathExists(localPath)) {
+        localContent = await fs9.readFile(localPath, "utf-8");
       }
       diffs.push(computeDiff(localContent, transformed, fileName));
     }
@@ -1322,12 +1697,12 @@ async function updateCommand(componentNames, cwd, options) {
   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 fileName = path11.basename(utilEntry.file);
+    const localPath = path11.join(libDir, fileName);
     const remoteContent = await fetchFileContent(config, utilEntry.file);
     let localContent = "";
-    if (await fs7.pathExists(localPath)) {
-      localContent = await fs7.readFile(localPath, "utf-8");
+    if (await fs9.pathExists(localPath)) {
+      localContent = await fs9.readFile(localPath, "utf-8");
     }
     utilDiffs.push(computeDiff(localContent, remoteContent, `lib/${fileName}`));
   }
@@ -1339,10 +1714,10 @@ async function updateCommand(componentNames, cwd, options) {
     }
   }
   const newBarrel = generateUtilsBarrel(resolution.utils, utilExports);
-  const barrelPath = path7.join(libDir, "rootnative-utils.ts");
+  const barrelPath = path11.join(libDir, "rootnative-utils.ts");
   let oldBarrel = "";
-  if (await fs7.pathExists(barrelPath)) {
-    oldBarrel = await fs7.readFile(barrelPath, "utf-8");
+  if (await fs9.pathExists(barrelPath)) {
+    oldBarrel = await fs9.readFile(barrelPath, "utf-8");
   }
   utilDiffs.push(computeDiff(oldBarrel, newBarrel, "lib/rootnative-utils.ts"));
   const changedComponents = componentDiffs.filter((c) => c.hasChanges);
@@ -1405,8 +1780,8 @@ async function updateCommand(componentNames, cwd, options) {
   const applySpinner = createSpinner("Applying updates...");
   applySpinner.start();
   for (const comp of changedComponents) {
-    const componentDir = path7.join(componentsDir, comp.name);
-    await fs7.ensureDir(componentDir);
+    const componentDir = path11.join(componentsDir, comp.name);
+    await fs9.ensureDir(componentDir);
     if (comp.diffs.length === 0) {
       const entry = resolution.components.find(
         (c) => c.entry.name === comp.name
@@ -1414,14 +1789,14 @@ async function updateCommand(componentNames, cwd, options) {
       if (!entry) continue;
       for (const filePath of entry.entry.files) {
         const content = await fetchFileContent(config, filePath);
-        const fileName = path7.basename(filePath);
+        const fileName = path11.basename(filePath);
         const transformed = transformImports(content, {
           config,
           componentName: comp.name,
           installedComponents: allComponentNames
         });
-        await fs7.writeFile(
-          path7.join(componentDir, fileName),
+        await fs9.writeFile(
+          path11.join(componentDir, fileName),
           transformed,
           "utf-8"
         );
@@ -1431,23 +1806,23 @@ async function updateCommand(componentNames, cwd, options) {
     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),
+      await fs9.writeFile(
+        path11.join(componentDir, diff.fileName),
         newContent,
         "utf-8"
       );
     }
   }
-  await fs7.ensureDir(libDir);
+  await fs9.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(
+    const filePath = path11.join(
       libDir,
       // diff.fileName is like "lib/color.ts" — strip the "lib/" prefix
       diff.fileName.replace(/^lib\//, "")
     );
-    await fs7.writeFile(filePath, newContent, "utf-8");
+    await fs9.writeFile(filePath, newContent, "utf-8");
   }
   applySpinner.succeed("Updates applied");
   logger.break();
@@ -1457,17 +1832,17 @@ async function updateCommand(componentNames, cwd, options) {
   logger.break();
 }
 async function getInstalledComponents(componentsDir) {
-  if (!await fs7.pathExists(componentsDir)) {
+  if (!await fs9.pathExists(componentsDir)) {
     return [];
   }
-  const entries = await fs7.readdir(componentsDir);
+  const entries = await fs9.readdir(componentsDir);
   const components = [];
   for (const entry of entries) {
-    const fullPath = path7.join(componentsDir, entry);
-    const stat = await fs7.stat(fullPath);
+    const fullPath = path11.join(componentsDir, entry);
+    const stat = await fs9.stat(fullPath);
     if (stat.isDirectory()) {
-      const indexPath = path7.join(fullPath, "index.ts");
-      if (await fs7.pathExists(indexPath)) {
+      const indexPath = path11.join(fullPath, "index.ts");
+      if (await fs9.pathExists(indexPath)) {
         components.push(entry);
       }
     }
@@ -1476,10 +1851,10 @@ async function getInstalledComponents(componentsDir) {
 }
 
 // src/commands/upgrade.ts
-import path8 from "path";
+import path12 from "path";
 import chalk9 from "chalk";
 import { execa as execa4 } from "execa";
-import fs8 from "fs-extra";
+import fs10 from "fs-extra";
 import prompts5 from "prompts";
 async function fetchLatestFromNpm(packageName) {
   const url = `https://registry.npmjs.org/${packageName}/latest`;
@@ -1492,16 +1867,16 @@ async function fetchLatestFromNpm(packageName) {
   return response.json();
 }
 function getInstalledPackageInfo(cwd, packageName) {
-  const pkgPath = path8.resolve(
+  const pkgPath = path12.resolve(
     cwd,
     "node_modules",
     ...packageName.split("/"),
     "package.json"
   );
-  if (!fs8.pathExistsSync(pkgPath)) {
+  if (!fs10.pathExistsSync(pkgPath)) {
     return null;
   }
-  const pkg = fs8.readJSONSync(pkgPath);
+  const pkg = fs10.readJSONSync(pkgPath);
   return {
     version: pkg.version,
     peerDependencies: pkg.peerDependencies,
@@ -1532,9 +1907,9 @@ function diffPeerDeps(current, latest) {
   return { added, changed, removed };
 }
 function getProjectDeps(cwd) {
-  const pkgPath = path8.resolve(cwd, "package.json");
+  const pkgPath = path12.resolve(cwd, "package.json");
   try {
-    const pkg = fs8.readJSONSync(pkgPath);
+    const pkg = fs10.readJSONSync(pkgPath);
     return {
       ...pkg.dependencies,
       ...pkg.devDependencies
@@ -1546,6 +1921,19 @@ function getProjectDeps(cwd) {
 function hasDiffChanges(diff) {
   return Object.keys(diff.added).length > 0 || Object.keys(diff.changed).length > 0 || diff.removed.length > 0;
 }
+async function repinRegistryVersion(cwd) {
+  const config = await readConfig(cwd);
+  const next = await resolveRegistryVersion();
+  if (next.fallback && config.registryVersion !== "main") {
+    logger.warn(
+      `Kept the registry pinned to ${chalk9.bold(config.registryVersion)} \u2014 could not resolve a newer release tag.`
+    );
+    return;
+  }
+  if (config.registryVersion === next.version) return;
+  await writeConfig(cwd, { ...config, registryVersion: next.version });
+  logger.success(`Registry pinned to ${chalk9.bold(next.version)}`);
+}
 async function upgradeCommand(cwd, options = {}) {
   logger.break();
   await readConfig(cwd);
@@ -1574,6 +1962,7 @@ async function upgradeCommand(cwd, options = {}) {
       `Already on the latest version ${chalk9.bold(`v${installed.version}`)}`
     );
     logger.break();
+    await repinRegistryVersion(cwd);
     if (options.all) {
       logger.info("Updating installed components...");
       await updateCommand([], cwd, { all: true, dryRun: false });
@@ -1691,6 +2080,7 @@ async function upgradeCommand(cwd, options = {}) {
       logger.info(`  ${pkg}`);
     }
   }
+  await repinRegistryVersion(cwd);
   logger.break();
   if (options.all) {
     logger.info("Updating installed components...");
@@ -1704,10 +2094,26 @@ function isValidPackageManager(value) {
   return PACKAGE_MANAGERS.includes(value);
 }
 
+// src/lib/version.ts
+import { createRequire } from "module";
+var UNKNOWN_VERSION = "0.0.0-unknown";
+var PACKAGE_JSON_CANDIDATES = ["../package.json", "../../package.json"];
+function getCliVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const candidate of PACKAGE_JSON_CANDIDATES) {
+    try {
+      const pkg = require2(candidate);
+      if (pkg.name === "@rootnative/cli" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return UNKNOWN_VERSION;
+}
+
 // 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(
+program.name("rootnative").description("Add RootNative UI components to your React Native project").version(getCliVersion());
+program.command("create").description("Create a new project with RootNative UI pre-configured").argument("[name]", 'Project name, or "." to use the current directory').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) => {
@@ -1742,7 +2148,7 @@ program.command("init").description("Initialize your project for RootNative UI")
     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(
+program.command("add").description("Add components to your project").argument("<components...>", "Component names to add").option("-y, --yes", "Skip prompts and use defaults", false).option("-f, --force", "Overwrite existing components", false).option(
   "-d, --dry-run",
   "Show what would be installed without making changes",
   false
@@ -1757,6 +2163,7 @@ program.command("add").description("Add components to your project").argument("<
     await addCommand(components, process.cwd(), {
       force: options.force,
       dryRun: options.dryRun,
+      yes: options.yes,
       packageManager: options.packageManager
     });
   } catch (error) {