prjct-cli 1.5.0 → 1.5.1

package/dist/core/infrastructure/setup.js

@@ -31,6 +31,24 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// core/utils/fs-helpers.ts
+async function fileExists(filePath) {
+  try {
+    await import_promises.default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var import_promises;
+var init_fs_helpers = __esm({
+  "core/utils/fs-helpers.ts"() {
+    "use strict";
+    import_promises = __toESM(require("node:fs/promises"));
+    __name(fileExists, "fileExists");
+  }
+});
+
 // core/infrastructure/ai-provider.ts
 var ai_provider_exports = {};
 __export(ai_provider_exports, {
@@ -58,50 +76,48 @@ __export(ai_provider_exports, {
   needsWindsurfRouterRegeneration: () => needsWindsurfRouterRegeneration,
   selectProvider: () => selectProvider
 });
-function whichCommand(command) {
+async function whichCommand(command) {
   try {
-    const result = (0, import_node_child_process2.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
-    return result.trim();
+    const { stdout } = await execAsync(`which ${command}`);
+    return stdout.trim();
   } catch {
     return null;
   }
 }
-function getCliVersion(command) {
+async function getCliVersion(command) {
   try {
-    const result = (0, import_node_child_process2.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
-    const match = result.match(/\d+\.\d+\.\d+/);
-    return match ? match[0] : result.trim();
+    const { stdout } = await execAsync(`${command} --version`);
+    const match = stdout.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : stdout.trim();
   } catch {
     return null;
   }
 }
-function detectProvider(provider) {
+async function detectProvider(provider) {
   const config = Providers[provider];
   if (!config.cliCommand) {
     return { installed: false };
   }
-  const cliPath = whichCommand(config.cliCommand);
+  const cliPath = await whichCommand(config.cliCommand);
   if (!cliPath) {
     return { installed: false };
   }
-  const version = getCliVersion(config.cliCommand);
+  const version = await getCliVersion(config.cliCommand);
   return {
     installed: true,
     version: version || void 0,
     path: cliPath
   };
 }
-function detectAllProviders() {
-  return {
-    claude: detectProvider("claude"),
-    gemini: detectProvider("gemini")
-  };
+async function detectAllProviders() {
+  const [claude, gemini] = await Promise.all([detectProvider("claude"), detectProvider("gemini")]);
+  return { claude, gemini };
 }
-function getActiveProvider(projectProvider) {
+async function getActiveProvider(projectProvider) {
   if (projectProvider && Providers[projectProvider]) {
     return Providers[projectProvider];
   }
-  const detection = detectAllProviders();
+  const detection = await detectAllProviders();
   if (detection.claude.installed && !detection.gemini.installed) {
     return ClaudeProvider;
   }
@@ -110,12 +126,12 @@ function getActiveProvider(projectProvider) {
   }
   return ClaudeProvider;
 }
-function hasProviderConfig(provider) {
+async function hasProviderConfig(provider) {
   const config = Providers[provider];
   if (!config.configDir) {
     return false;
   }
-  return import_node_fs2.default.existsSync(config.configDir);
+  return fileExists(config.configDir);
 }
 function getProviderBranding(provider) {
   const commitFooter = `Generated with [p/](https://www.prjct.app/)`;
@@ -131,46 +147,52 @@ function getProviderBranding(provider) {
     signature: signatures[provider] || "\u26A1 prjct"
   };
 }
-function detectCursorProject(projectRoot) {
+async function detectCursorProject(projectRoot) {
   const cursorDir = import_node_path2.default.join(projectRoot, ".cursor");
   const rulesDir = import_node_path2.default.join(cursorDir, "rules");
   const routerPath = import_node_path2.default.join(rulesDir, "prjct.mdc");
-  const detected = import_node_fs2.default.existsSync(cursorDir);
-  const routerInstalled = import_node_fs2.default.existsSync(routerPath);
+  const [detected, routerInstalled] = await Promise.all([
+    fileExists(cursorDir),
+    fileExists(routerPath)
+  ]);
   return {
     detected,
     routerInstalled,
     projectRoot: detected ? projectRoot : void 0
   };
 }
-function needsCursorRouterRegeneration(projectRoot) {
-  const detection = detectCursorProject(projectRoot);
+async function needsCursorRouterRegeneration(projectRoot) {
+  const detection = await detectCursorProject(projectRoot);
   return detection.detected && !detection.routerInstalled;
 }
-function detectWindsurfProject(projectRoot) {
+async function detectWindsurfProject(projectRoot) {
   const windsurfDir = import_node_path2.default.join(projectRoot, ".windsurf");
   const rulesDir = import_node_path2.default.join(windsurfDir, "rules");
   const routerPath = import_node_path2.default.join(rulesDir, "prjct.md");
-  const detected = import_node_fs2.default.existsSync(windsurfDir);
-  const routerInstalled = import_node_fs2.default.existsSync(routerPath);
+  const [detected, routerInstalled] = await Promise.all([
+    fileExists(windsurfDir),
+    fileExists(routerPath)
+  ]);
   return {
     detected,
     routerInstalled,
     projectRoot: detected ? projectRoot : void 0
   };
 }
-function needsWindsurfRouterRegeneration(projectRoot) {
-  const detection = detectWindsurfProject(projectRoot);
+async function needsWindsurfRouterRegeneration(projectRoot) {
+  const detection = await detectWindsurfProject(projectRoot);
   return detection.detected && !detection.routerInstalled;
 }
-function detectAntigravity() {
+async function detectAntigravity() {
   const configPath = AntigravityProvider.configDir;
   if (!configPath) {
     return { installed: false, skillInstalled: false };
   }
-  const installed = import_node_fs2.default.existsSync(configPath);
   const skillPath = import_node_path2.default.join(configPath, "skills", "prjct", "SKILL.md");
-  const skillInstalled = import_node_fs2.default.existsSync(skillPath);
+  const [installed, skillInstalled] = await Promise.all([
+    fileExists(configPath),
+    fileExists(skillPath)
+  ]);
   return {
     installed,
     skillInstalled,
@@ -201,8 +223,8 @@ function getProjectCommandsPath(provider, projectRoot) {
   const config = Providers[provider];
   return import_node_path2.default.join(projectRoot, config.commandsDir);
 }
-function selectProvider() {
-  const detection = detectAllProviders();
+async function selectProvider() {
+  const detection = await detectAllProviders();
   const claudeInstalled = detection.claude.installed;
   const geminiInstalled = detection.gemini.installed;
   if (!claudeInstalled && !geminiInstalled) {
@@ -233,14 +255,16 @@ function selectProvider() {
     detection
   };
 }
-var import_node_child_process2, import_node_fs2, import_node_os, import_node_path2, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
+var import_node_child_process2, import_node_os, import_node_path2, import_node_util, execAsync, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
 var init_ai_provider = __esm({
   "core/infrastructure/ai-provider.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
-    import_node_fs2 = __toESM(require("node:fs"));
     import_node_os = __toESM(require("node:os"));
     import_node_path2 = __toESM(require("node:path"));
+    import_node_util = require("node:util");
+    init_fs_helpers();
+    execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
     ClaudeProvider = {
       name: "claude",
       displayName: "Claude Code",
@@ -405,7 +429,7 @@ __export(setup_exports, {
 });
 module.exports = __toCommonJS(setup_exports);
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs3 = __toESM(require("node:fs"));
+var import_promises4 = __toESM(require("node:fs/promises"));
 var import_node_os4 = __toESM(require("node:os"));
 var import_node_path5 = __toESM(require("node:path"));
 var import_chalk = __toESM(require("chalk"));
@@ -692,6 +716,9 @@ function isNotFoundError(error) {
 }
 __name(isNotFoundError, "isNotFoundError");
 
+// core/infrastructure/setup.ts
+init_fs_helpers();
+
 // core/utils/version.ts
 var import_node_fs = __toESM(require("node:fs"));
 var import_node_path = __toESM(require("node:path"));
@@ -744,13 +771,13 @@ var PACKAGE_ROOT = getPackageRoot();
 init_ai_provider();
 
 // core/infrastructure/command-installer.ts
-var import_promises = __toESM(require("node:fs/promises"));
+var import_promises2 = __toESM(require("node:fs/promises"));
 var import_node_os2 = __toESM(require("node:os"));
 var import_node_path3 = __toESM(require("node:path"));
 async function loadModuleConfig() {
   try {
     const configPath = import_node_path3.default.join(getPackageRoot(), "templates/global/modules/module-config.json");
-    const content = await import_promises.default.readFile(configPath, "utf-8");
+    const content = await import_promises2.default.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -762,7 +789,7 @@ async function composeGlobalTemplate(profile) {
   const modulesDir = import_node_path3.default.join(getPackageRoot(), "templates/global/modules");
   if (!config) {
     const legacyPath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-    return import_promises.default.readFile(legacyPath, "utf-8");
+    return import_promises2.default.readFile(legacyPath, "utf-8");
   }
   const profileName = profile || config.default;
   const selectedProfile = config.profiles[profileName];
@@ -770,7 +797,7 @@ async function composeGlobalTemplate(profile) {
     const defaultProfile = config.profiles[config.default];
     if (!defaultProfile) {
       const legacyPath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-      return import_promises.default.readFile(legacyPath, "utf-8");
+      return import_promises2.default.readFile(legacyPath, "utf-8");
     }
   }
   const modules = (selectedProfile || config.profiles[config.default]).modules;
@@ -779,7 +806,7 @@ async function composeGlobalTemplate(profile) {
   for (const moduleName of modules) {
     try {
       const modulePath = import_node_path3.default.join(modulesDir, moduleName);
-      const content = await import_promises.default.readFile(modulePath, "utf-8");
+      const content = await import_promises2.default.readFile(modulePath, "utf-8");
       parts.push("");
       parts.push(content);
     } catch {
@@ -796,14 +823,14 @@ async function installDocs() {
   try {
     const docsDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".prjct-cli", "docs");
     const templateDocsDir = import_node_path3.default.join(getPackageRoot(), "templates/global/docs");
-    await import_promises.default.mkdir(docsDir, { recursive: true });
-    const docFiles = await import_promises.default.readdir(templateDocsDir);
+    await import_promises2.default.mkdir(docsDir, { recursive: true });
+    const docFiles = await import_promises2.default.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
         const srcPath = import_node_path3.default.join(templateDocsDir, file);
         const destPath = import_node_path3.default.join(docsDir, file);
-        const content = await import_promises.default.readFile(srcPath, "utf-8");
-        await import_promises.default.writeFile(destPath, content, "utf-8");
+        const content = await import_promises2.default.readFile(srcPath, "utf-8");
+        await import_promises2.default.writeFile(destPath, content, "utf-8");
       }
     }
     return { success: true };
@@ -814,9 +841,9 @@ async function installDocs() {
 __name(installDocs, "installDocs");
 async function installGlobalConfig() {
   const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-  const activeProvider = aiProvider.getActiveProvider();
+  const activeProvider = await aiProvider.getActiveProvider();
   const providerName = activeProvider.name;
-  const detection = aiProvider.detectProvider(providerName);
+  const detection = await aiProvider.detectProvider(providerName);
   if (!detection.installed && !activeProvider.configDir) {
     return {
       success: false,
@@ -825,7 +852,7 @@ async function installGlobalConfig() {
     };
   }
   try {
-    await import_promises.default.mkdir(activeProvider.configDir, { recursive: true });
+    await import_promises2.default.mkdir(activeProvider.configDir, { recursive: true });
     const globalConfigPath = import_node_path3.default.join(activeProvider.configDir, activeProvider.contextFile);
     const templatePath = import_node_path3.default.join(
       getPackageRoot(),
@@ -835,37 +862,37 @@ async function installGlobalConfig() {
     );
     let templateContent = "";
     try {
-      templateContent = await import_promises.default.readFile(templatePath, "utf-8");
+      templateContent = await import_promises2.default.readFile(templatePath, "utf-8");
     } catch (_error) {
       if (providerName === "claude") {
         try {
           templateContent = await composeGlobalTemplate("standard");
         } catch {
           const fallbackTemplatePath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-          templateContent = await import_promises.default.readFile(fallbackTemplatePath, "utf-8");
+          templateContent = await import_promises2.default.readFile(fallbackTemplatePath, "utf-8");
         }
       } else {
         const fallbackTemplatePath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-        templateContent = await import_promises.default.readFile(fallbackTemplatePath, "utf-8");
+        templateContent = await import_promises2.default.readFile(fallbackTemplatePath, "utf-8");
         if (providerName === "gemini") {
           templateContent = templateContent.replace(/Claude/g, "Gemini");
         }
       }
     }
     let existingContent = "";
-    let fileExists = false;
+    let fileExists2 = false;
     try {
-      existingContent = await import_promises.default.readFile(globalConfigPath, "utf-8");
-      fileExists = true;
+      existingContent = await import_promises2.default.readFile(globalConfigPath, "utf-8");
+      fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
-        fileExists = false;
+        fileExists2 = false;
       } else {
         throw error;
       }
     }
-    if (!fileExists) {
-      await import_promises.default.writeFile(globalConfigPath, templateContent, "utf-8");
+    if (!fileExists2) {
+      await import_promises2.default.writeFile(globalConfigPath, templateContent, "utf-8");
       return {
         success: true,
         action: "created",
@@ -879,7 +906,7 @@ async function installGlobalConfig() {
         const updatedContent = `${existingContent}
 
 ${templateContent}`;
-        await import_promises.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await import_promises2.default.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "appended",
@@ -895,7 +922,7 @@ ${templateContent}`;
           templateContent.indexOf(endMarker) + endMarker.length
         );
         const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await import_promises.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await import_promises2.default.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "updated",
@@ -917,27 +944,33 @@ var CommandInstaller = class {
     __name(this, "CommandInstaller");
   }
   homeDir;
-  claudeCommandsPath;
-  claudeConfigPath;
+  claudeCommandsPath = "";
+  claudeConfigPath = "";
   templatesDir;
+  _initialized = false;
   constructor() {
     this.homeDir = import_node_os2.default.homedir();
+    this.templatesDir = import_node_path3.default.join(getPackageRoot(), "templates", "commands");
+  }
+  async ensureInit() {
+    if (this._initialized) return;
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = aiProvider.getActiveProvider();
+    const activeProvider = await aiProvider.getActiveProvider();
     if (activeProvider.name === "gemini") {
       this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands");
     } else {
       this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands", "p");
     }
     this.claudeConfigPath = activeProvider.configDir;
-    this.templatesDir = import_node_path3.default.join(getPackageRoot(), "templates", "commands");
+    this._initialized = true;
   }
   /**
    * Detect if active provider is installed
    */
   async detectActiveProvider() {
+    await this.ensureInit();
     try {
-      await import_promises.default.access(this.claudeConfigPath);
+      await import_promises2.default.access(this.claudeConfigPath);
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -957,7 +990,7 @@ var CommandInstaller = class {
    */
   async getCommandFiles() {
     try {
-      const files = await import_promises.default.readdir(this.templatesDir);
+      const files = await import_promises2.default.readdir(this.templatesDir);
       return files.filter((f) => f.endsWith(".md"));
     } catch (_error) {
       return [
@@ -989,7 +1022,7 @@ var CommandInstaller = class {
   async installCommands() {
     const providerDetected = await this.detectActiveProvider();
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = aiProvider.getActiveProvider();
+    const activeProvider = await aiProvider.getActiveProvider();
     if (!providerDetected) {
       return {
         success: false,
@@ -998,7 +1031,7 @@ var CommandInstaller = class {
     }
     try {
       await this.installRouter();
-      await import_promises.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      await import_promises2.default.mkdir(this.claudeCommandsPath, { recursive: true });
       const commandFiles = await this.getCommandFiles();
       const installed = [];
       const errors = [];
@@ -1006,8 +1039,8 @@ var CommandInstaller = class {
         try {
           const sourcePath = import_node_path3.default.join(this.templatesDir, file);
           const destPath = import_node_path3.default.join(this.claudeCommandsPath, file);
-          const content = await import_promises.default.readFile(sourcePath, "utf-8");
-          await import_promises.default.writeFile(destPath, content, "utf-8");
+          const content = await import_promises2.default.readFile(sourcePath, "utf-8");
+          await import_promises2.default.writeFile(destPath, content, "utf-8");
           installed.push(file.replace(".md", ""));
         } catch (error) {
           errors.push({ file, error: error.message });
@@ -1037,7 +1070,7 @@ var CommandInstaller = class {
       for (const file of commandFiles) {
         try {
           const filePath = import_node_path3.default.join(this.claudeCommandsPath, file);
-          await import_promises.default.unlink(filePath);
+          await import_promises2.default.unlink(filePath);
           uninstalled.push(file.replace(".md", ""));
         } catch (error) {
           if (error.code !== "ENOENT") {
@@ -1046,7 +1079,7 @@ var CommandInstaller = class {
         }
       }
       try {
-        await import_promises.default.rmdir(this.claudeCommandsPath);
+        await import_promises2.default.rmdir(this.claudeCommandsPath);
       } catch (_error) {
       }
       return {
@@ -1073,8 +1106,8 @@ var CommandInstaller = class {
       };
     }
     try {
-      await import_promises.default.access(this.claudeCommandsPath);
-      const files = await import_promises.default.readdir(this.claudeCommandsPath);
+      await import_promises2.default.access(this.claudeCommandsPath);
+      const files = await import_promises2.default.readdir(this.claudeCommandsPath);
       const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
       return {
         installed: installedCommands.length > 0,
@@ -1113,7 +1146,8 @@ var CommandInstaller = class {
   /**
    * Get installation path for Claude commands
    */
-  getInstallPath() {
+  async getInstallPath() {
+    await this.ensureInit();
     return this.claudeCommandsPath;
   }
   /**
@@ -1122,7 +1156,7 @@ var CommandInstaller = class {
   async verifyTemplate(commandName) {
     try {
       const templatePath = import_node_path3.default.join(this.templatesDir, `${commandName}.md`);
-      await import_promises.default.access(templatePath);
+      await import_promises2.default.access(templatePath);
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1137,14 +1171,14 @@ var CommandInstaller = class {
    */
   async installRouter() {
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = aiProvider.getActiveProvider();
+    const activeProvider = await aiProvider.getActiveProvider();
     const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
     try {
       const routerSource = import_node_path3.default.join(this.templatesDir, routerFile);
       const routerDest = import_node_path3.default.join(activeProvider.configDir, "commands", routerFile);
-      await import_promises.default.mkdir(import_node_path3.default.dirname(routerDest), { recursive: true });
-      const content = await import_promises.default.readFile(routerSource, "utf-8");
-      await import_promises.default.writeFile(routerDest, content, "utf-8");
+      await import_promises2.default.mkdir(import_node_path3.default.dirname(routerDest), { recursive: true });
+      const content = await import_promises2.default.readFile(routerSource, "utf-8");
+      await import_promises2.default.writeFile(routerDest, content, "utf-8");
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1159,15 +1193,15 @@ var CommandInstaller = class {
    */
   async removeLegacyCommands() {
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = aiProvider.getActiveProvider();
+    const activeProvider = await aiProvider.getActiveProvider();
     const commandsRoot = import_node_path3.default.join(activeProvider.configDir, "commands");
     let removed = 0;
     try {
-      const files = await import_promises.default.readdir(commandsRoot);
+      const files = await import_promises2.default.readdir(commandsRoot);
       const legacyFiles = files.filter((f) => f.startsWith("p.") && f.endsWith(".md"));
       for (const file of legacyFiles) {
         try {
-          await import_promises.default.unlink(import_node_path3.default.join(commandsRoot, file));
+          await import_promises2.default.unlink(import_node_path3.default.join(commandsRoot, file));
           removed++;
         } catch {
         }
@@ -1192,11 +1226,11 @@ var CommandInstaller = class {
     }
     try {
       await this.installRouter();
-      await import_promises.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      await import_promises2.default.mkdir(this.claudeCommandsPath, { recursive: true });
       const templateFiles = await this.getCommandFiles();
       let installedFiles = [];
       try {
-        installedFiles = await import_promises.default.readdir(this.claudeCommandsPath);
+        installedFiles = await import_promises2.default.readdir(this.claudeCommandsPath);
         installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
       } catch (error) {
         if (isNotFoundError(error)) {
@@ -1217,8 +1251,8 @@ var CommandInstaller = class {
           const sourcePath = import_node_path3.default.join(this.templatesDir, file);
           const destPath = import_node_path3.default.join(this.claudeCommandsPath, file);
           const exists = installedFiles.includes(file);
-          const content = await import_promises.default.readFile(sourcePath, "utf-8");
-          await import_promises.default.writeFile(destPath, content, "utf-8");
+          const content = await import_promises2.default.readFile(sourcePath, "utf-8");
+          await import_promises2.default.writeFile(destPath, content, "utf-8");
           if (!exists) {
             results.added++;
           } else {
@@ -1257,7 +1291,7 @@ var commandInstaller = new CommandInstaller();
 var command_installer_default = commandInstaller;
 
 // core/infrastructure/editors-config.ts
-var import_promises2 = __toESM(require("node:fs/promises"));
+var import_promises3 = __toESM(require("node:fs/promises"));
 var import_node_os3 = __toESM(require("node:os"));
 var import_node_path4 = __toESM(require("node:path"));
 var EditorsConfig = class {
@@ -1277,7 +1311,7 @@ var EditorsConfig = class {
    */
   async ensureConfigDir() {
     try {
-      await import_promises2.default.mkdir(this.configDir, { recursive: true });
+      await import_promises3.default.mkdir(this.configDir, { recursive: true });
     } catch (error) {
       console.error("[editors-config] Error creating config directory:", error.message);
     }
@@ -1287,7 +1321,7 @@ var EditorsConfig = class {
    */
   async loadConfig() {
     try {
-      const content = await import_promises2.default.readFile(this.configFile, "utf-8");
+      const content = await import_promises3.default.readFile(this.configFile, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1311,7 +1345,7 @@ var EditorsConfig = class {
         lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
         path: installPath
       };
-      await import_promises2.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      await import_promises3.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
     } catch (error) {
       console.error("[editors-config] Error saving config:", error.message);
@@ -1351,7 +1385,7 @@ var EditorsConfig = class {
       }
       config.version = version;
       config.lastInstall = (/* @__PURE__ */ new Date()).toISOString();
-      await import_promises2.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      await import_promises3.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
     } catch (error) {
       console.error("[editors-config] Error updating version:", error.message);
@@ -1363,7 +1397,7 @@ var EditorsConfig = class {
    */
   async configExists() {
     try {
-      await import_promises2.default.access(this.configFile);
+      await import_promises3.default.access(this.configFile);
       return true;
     } catch (_error) {
       return false;
@@ -1377,7 +1411,7 @@ var EditorsConfig = class {
     try {
       const exists = await this.configExists();
       if (exists) {
-        await import_promises2.default.unlink(this.configFile);
+        await import_promises3.default.unlink(this.configFile);
       }
       return true;
     } catch (error) {
@@ -1443,8 +1477,8 @@ async function installAICLI(provider) {
 }
 __name(installAICLI, "installAICLI");
 async function run() {
-  const detection = detectAllProviders();
-  const selection = selectProvider();
+  const detection = await detectAllProviders();
+  const selection = await selectProvider();
   const _primaryProvider = Providers[selection.provider];
   const results = {
     provider: selection.provider,
@@ -1512,14 +1546,14 @@ async function run() {
     }
     results.providers.push(providerResult);
   }
-  const antigravityDetection = detectAntigravity();
+  const antigravityDetection = await detectAntigravity();
   if (antigravityDetection.installed) {
     const antigravityResult = await installAntigravitySkill();
     if (antigravityResult.success) {
       console.log(`   ${import_chalk.default.green("\u2713")} Antigravity skill installed`);
     }
   }
-  await editors_config_default.saveConfig(VERSION, command_installer_default.getInstallPath(), selection.provider);
+  await editors_config_default.saveConfig(VERSION, await command_installer_default.getInstallPath(), selection.provider);
   await migrateProjectsCliVersion();
   for (const providerResult of results.providers) {
     showResults(providerResult, Providers[providerResult.provider]);
@@ -1533,9 +1567,9 @@ async function installGeminiRouter() {
     const geminiCommandsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini", "commands");
     const routerSource = import_node_path5.default.join(getPackageRoot(), "templates", "commands", "p.toml");
     const routerDest = import_node_path5.default.join(geminiCommandsDir, "p.toml");
-    import_node_fs3.default.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (import_node_fs3.default.existsSync(routerSource)) {
-      import_node_fs3.default.copyFileSync(routerSource, routerDest);
+    await import_promises4.default.mkdir(geminiCommandsDir, { recursive: true });
+    if (await fileExists(routerSource)) {
+      await import_promises4.default.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -1550,22 +1584,22 @@ async function installGeminiGlobalConfig() {
     const geminiDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini");
     const globalConfigPath = import_node_path5.default.join(geminiDir, "GEMINI.md");
     const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    import_node_fs3.default.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = import_node_fs3.default.readFileSync(templatePath, "utf-8");
+    await import_promises4.default.mkdir(geminiDir, { recursive: true });
+    const templateContent = await import_promises4.default.readFile(templatePath, "utf-8");
     let existingContent = "";
-    let fileExists = false;
+    let configExists = false;
     try {
-      existingContent = import_node_fs3.default.readFileSync(globalConfigPath, "utf-8");
-      fileExists = true;
+      existingContent = await import_promises4.default.readFile(globalConfigPath, "utf-8");
+      configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
-        fileExists = false;
+        configExists = false;
       } else {
         throw error;
       }
     }
-    if (!fileExists) {
-      import_node_fs3.default.writeFileSync(globalConfigPath, templateContent, "utf-8");
+    if (!configExists) {
+      await import_promises4.default.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -1575,7 +1609,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      import_node_fs3.default.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      await import_promises4.default.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -1587,7 +1621,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    import_node_fs3.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    await import_promises4.default.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -1601,23 +1635,23 @@ async function installAntigravitySkill() {
     const prjctSkillDir = import_node_path5.default.join(antigravitySkillsDir, "prjct");
     const skillMdPath = import_node_path5.default.join(prjctSkillDir, "SKILL.md");
     const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    import_node_fs3.default.mkdirSync(prjctSkillDir, { recursive: true });
-    const fileExists = import_node_fs3.default.existsSync(skillMdPath);
-    if (!import_node_fs3.default.existsSync(templatePath)) {
+    await import_promises4.default.mkdir(prjctSkillDir, { recursive: true });
+    const skillExists = await fileExists(skillMdPath);
+    if (!await fileExists(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = import_node_fs3.default.readFileSync(templatePath, "utf-8");
-    import_node_fs3.default.writeFileSync(skillMdPath, templateContent, "utf-8");
-    return { success: true, action: fileExists ? "updated" : "created" };
+    const templateContent = await import_promises4.default.readFile(templatePath, "utf-8");
+    await import_promises4.default.writeFile(skillMdPath, templateContent, "utf-8");
+    return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
     return { success: false, action: null };
   }
 }
 __name(installAntigravitySkill, "installAntigravitySkill");
-function needsAntigravityInstallation() {
-  const detection = detectAntigravity();
+async function needsAntigravityInstallation() {
+  const detection = await detectAntigravity();
   return detection.installed && !detection.skillInstalled;
 }
 __name(needsAntigravityInstallation, "needsAntigravityInstallation");
@@ -1635,18 +1669,18 @@ async function installCursorProject(projectRoot) {
     const routerMdcDest = import_node_path5.default.join(rulesDir, "prjct.mdc");
     const routerMdcSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "router.mdc");
     const cursorCommandsSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "commands");
-    import_node_fs3.default.mkdirSync(rulesDir, { recursive: true });
-    import_node_fs3.default.mkdirSync(commandsDir, { recursive: true });
-    if (import_node_fs3.default.existsSync(routerMdcSource)) {
-      import_node_fs3.default.copyFileSync(routerMdcSource, routerMdcDest);
+    await import_promises4.default.mkdir(rulesDir, { recursive: true });
+    await import_promises4.default.mkdir(commandsDir, { recursive: true });
+    if (await fileExists(routerMdcSource)) {
+      await import_promises4.default.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (import_node_fs3.default.existsSync(cursorCommandsSource)) {
-      const commandFiles = import_node_fs3.default.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (await fileExists(cursorCommandsSource)) {
+      const commandFiles = (await import_promises4.default.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
         const src = import_node_path5.default.join(cursorCommandsSource, file);
         const dest = import_node_path5.default.join(commandsDir, file);
-        import_node_fs3.default.copyFileSync(src, dest);
+        await import_promises4.default.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -1674,10 +1708,10 @@ async function addCursorToGitignore(projectRoot) {
       ".cursor/commands/resume.md"
     ];
     let content = "";
-    let fileExists = false;
+    let configExists = false;
     try {
-      content = import_node_fs3.default.readFileSync(gitignorePath, "utf-8");
-      fileExists = true;
+      content = await import_promises4.default.readFile(gitignorePath, "utf-8");
+      configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
         throw error;
@@ -1686,12 +1720,12 @@ async function addCursorToGitignore(projectRoot) {
     if (content.includes(".cursor/rules/prjct.mdc")) {
       return false;
     }
-    const newContent = fileExists ? `${content.trimEnd()}
+    const newContent = configExists ? `${content.trimEnd()}
 
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    import_node_fs3.default.writeFileSync(gitignorePath, newContent, "utf-8");
+    await import_promises4.default.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -1699,14 +1733,14 @@ ${entriesToAdd.join("\n")}
   }
 }
 __name(addCursorToGitignore, "addCursorToGitignore");
-function hasCursorProject(projectRoot) {
-  return import_node_fs3.default.existsSync(import_node_path5.default.join(projectRoot, ".cursor"));
+async function hasCursorProject(projectRoot) {
+  return await fileExists(import_node_path5.default.join(projectRoot, ".cursor"));
 }
 __name(hasCursorProject, "hasCursorProject");
-function needsCursorRegeneration(projectRoot) {
+async function needsCursorRegeneration(projectRoot) {
   const cursorDir = import_node_path5.default.join(projectRoot, ".cursor");
   const routerPath = import_node_path5.default.join(cursorDir, "rules", "prjct.mdc");
-  return import_node_fs3.default.existsSync(cursorDir) && !import_node_fs3.default.existsSync(routerPath);
+  return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 __name(needsCursorRegeneration, "needsCursorRegeneration");
 async function installWindsurfProject(projectRoot) {
@@ -1728,18 +1762,20 @@ async function installWindsurfProject(projectRoot) {
       "windsurf",
       "workflows"
     );
-    import_node_fs3.default.mkdirSync(rulesDir, { recursive: true });
-    import_node_fs3.default.mkdirSync(workflowsDir, { recursive: true });
-    if (import_node_fs3.default.existsSync(routerSource)) {
-      import_node_fs3.default.copyFileSync(routerSource, routerDest);
+    await import_promises4.default.mkdir(rulesDir, { recursive: true });
+    await import_promises4.default.mkdir(workflowsDir, { recursive: true });
+    if (await fileExists(routerSource)) {
+      await import_promises4.default.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (import_node_fs3.default.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = import_node_fs3.default.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (await fileExists(windsurfWorkflowsSource)) {
+      const workflowFiles = (await import_promises4.default.readdir(windsurfWorkflowsSource)).filter(
+        (f) => f.endsWith(".md")
+      );
       for (const file of workflowFiles) {
         const src = import_node_path5.default.join(windsurfWorkflowsSource, file);
         const dest = import_node_path5.default.join(workflowsDir, file);
-        import_node_fs3.default.copyFileSync(src, dest);
+        await import_promises4.default.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -1767,10 +1803,10 @@ async function addWindsurfToGitignore(projectRoot) {
       ".windsurf/workflows/resume.md"
     ];
     let content = "";
-    let fileExists = false;
+    let configExists = false;
     try {
-      content = import_node_fs3.default.readFileSync(gitignorePath, "utf-8");
-      fileExists = true;
+      content = await import_promises4.default.readFile(gitignorePath, "utf-8");
+      configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
         throw error;
@@ -1779,12 +1815,12 @@ async function addWindsurfToGitignore(projectRoot) {
     if (content.includes(".windsurf/rules/prjct.md")) {
       return false;
     }
-    const newContent = fileExists ? `${content.trimEnd()}
+    const newContent = configExists ? `${content.trimEnd()}
 
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    import_node_fs3.default.writeFileSync(gitignorePath, newContent, "utf-8");
+    await import_promises4.default.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -1792,35 +1828,35 @@ ${entriesToAdd.join("\n")}
   }
 }
 __name(addWindsurfToGitignore, "addWindsurfToGitignore");
-function hasWindsurfProject(projectRoot) {
-  return import_node_fs3.default.existsSync(import_node_path5.default.join(projectRoot, ".windsurf"));
+async function hasWindsurfProject(projectRoot) {
+  return await fileExists(import_node_path5.default.join(projectRoot, ".windsurf"));
 }
 __name(hasWindsurfProject, "hasWindsurfProject");
-function needsWindsurfRegeneration(projectRoot) {
+async function needsWindsurfRegeneration(projectRoot) {
   const windsurfDir = import_node_path5.default.join(projectRoot, ".windsurf");
   const routerPath = import_node_path5.default.join(windsurfDir, "rules", "prjct.md");
-  return import_node_fs3.default.existsSync(windsurfDir) && !import_node_fs3.default.existsSync(routerPath);
+  return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 __name(needsWindsurfRegeneration, "needsWindsurfRegeneration");
 async function migrateProjectsCliVersion() {
   try {
     const projectsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".prjct-cli", "projects");
-    if (!import_node_fs3.default.existsSync(projectsDir)) {
+    if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = import_node_fs3.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await import_promises4.default.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
       const projectJsonPath = import_node_path5.default.join(projectsDir, projectId, "project.json");
-      if (!import_node_fs3.default.existsSync(projectJsonPath)) {
+      if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = import_node_fs3.default.readFileSync(projectJsonPath, "utf8");
+        const content = await import_promises4.default.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          import_node_fs3.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          await import_promises4.default.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -1839,11 +1875,11 @@ async function migrateProjectsCliVersion() {
   }
 }
 __name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
-function ensureStatusLineSettings(settingsPath, statusLinePath) {
+async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (import_node_fs3.default.existsSync(settingsPath)) {
+  if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(import_node_fs3.default.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(await import_promises4.default.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -1851,7 +1887,7 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  import_node_fs3.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  await import_promises4.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 __name(ensureStatusLineSettings, "ensureStatusLineSettings");
 async function installStatusLine() {
@@ -1871,23 +1907,23 @@ async function installStatusLine() {
     const sourceLibDir = import_node_path5.default.join(assetsDir, "lib");
     const sourceComponentsDir = import_node_path5.default.join(assetsDir, "components");
     const sourceConfigPath = import_node_path5.default.join(assetsDir, "default-config.json");
-    if (!import_node_fs3.default.existsSync(claudeDir)) {
-      import_node_fs3.default.mkdirSync(claudeDir, { recursive: true });
+    if (!await fileExists(claudeDir)) {
+      await import_promises4.default.mkdir(claudeDir, { recursive: true });
     }
-    if (!import_node_fs3.default.existsSync(prjctStatusLineDir)) {
-      import_node_fs3.default.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!await fileExists(prjctStatusLineDir)) {
+      await import_promises4.default.mkdir(prjctStatusLineDir, { recursive: true });
     }
-    if (!import_node_fs3.default.existsSync(prjctThemesDir)) {
-      import_node_fs3.default.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!await fileExists(prjctThemesDir)) {
+      await import_promises4.default.mkdir(prjctThemesDir, { recursive: true });
     }
-    if (!import_node_fs3.default.existsSync(prjctLibDir)) {
-      import_node_fs3.default.mkdirSync(prjctLibDir, { recursive: true });
+    if (!await fileExists(prjctLibDir)) {
+      await import_promises4.default.mkdir(prjctLibDir, { recursive: true });
     }
-    if (!import_node_fs3.default.existsSync(prjctComponentsDir)) {
-      import_node_fs3.default.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!await fileExists(prjctComponentsDir)) {
+      await import_promises4.default.mkdir(prjctComponentsDir, { recursive: true });
     }
-    if (import_node_fs3.default.existsSync(prjctStatusLinePath)) {
-      const existingContent = import_node_fs3.default.readFileSync(prjctStatusLinePath, "utf8");
+    if (await fileExists(prjctStatusLinePath)) {
+      const existingContent = await import_promises4.default.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -1895,31 +1931,31 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          import_node_fs3.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await import_promises4.default.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
-        installStatusLineModules(sourceLibDir, prjctLibDir);
-        installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-        ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
-        ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+        await installStatusLineModules(sourceLibDir, prjctLibDir);
+        await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+        await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+        await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
         return;
       }
     }
-    if (import_node_fs3.default.existsSync(sourceScript)) {
-      let scriptContent = import_node_fs3.default.readFileSync(sourceScript, "utf8");
+    if (await fileExists(sourceScript)) {
+      let scriptContent = await import_promises4.default.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      import_node_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
-      installStatusLineModules(sourceLibDir, prjctLibDir);
-      installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (import_node_fs3.default.existsSync(sourceThemeDir)) {
-        const themes = import_node_fs3.default.readdirSync(sourceThemeDir);
+      await import_promises4.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await installStatusLineModules(sourceLibDir, prjctLibDir);
+      await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+      if (await fileExists(sourceThemeDir)) {
+        const themes = await import_promises4.default.readdir(sourceThemeDir);
         for (const theme of themes) {
           const src = import_node_path5.default.join(sourceThemeDir, theme);
           const dest = import_node_path5.default.join(prjctThemesDir, theme);
-          import_node_fs3.default.copyFileSync(src, dest);
+          await import_promises4.default.copyFile(src, dest);
         }
       }
-      if (!import_node_fs3.default.existsSync(prjctConfigPath) && import_node_fs3.default.existsSync(sourceConfigPath)) {
-        import_node_fs3.default.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
+        await import_promises4.default.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -1954,10 +1990,10 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      import_node_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await import_promises4.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
-    ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
-    ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+    await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+    await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
   } catch (error) {
     if (!isNotFoundError(error)) {
       console.error(`Status line warning: ${error.message}`);
@@ -1969,8 +2005,8 @@ async function installContext7MCP() {
   try {
     const claudeDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".claude");
     const mcpConfigPath = import_node_path5.default.join(claudeDir, "mcp.json");
-    if (!import_node_fs3.default.existsSync(claudeDir)) {
-      import_node_fs3.default.mkdirSync(claudeDir, { recursive: true });
+    if (!await fileExists(claudeDir)) {
+      await import_promises4.default.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -1980,56 +2016,56 @@ async function installContext7MCP() {
         }
       }
     };
-    if (import_node_fs3.default.existsSync(mcpConfigPath)) {
-      const existingContent = import_node_fs3.default.readFileSync(mcpConfigPath, "utf-8");
+    if (await fileExists(mcpConfigPath)) {
+      const existingContent = await import_promises4.default.readFile(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      import_node_fs3.default.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await import_promises4.default.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      import_node_fs3.default.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await import_promises4.default.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
   }
 }
 __name(installContext7MCP, "installContext7MCP");
-function installStatusLineModules(sourceDir, destDir) {
-  if (!import_node_fs3.default.existsSync(sourceDir)) {
+async function installStatusLineModules(sourceDir, destDir) {
+  if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = import_node_fs3.default.readdirSync(sourceDir);
+  const files = await import_promises4.default.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
       const src = import_node_path5.default.join(sourceDir, file);
       const dest = import_node_path5.default.join(destDir, file);
-      import_node_fs3.default.copyFileSync(src, dest);
-      import_node_fs3.default.chmodSync(dest, 493);
+      await import_promises4.default.copyFile(src, dest);
+      await import_promises4.default.chmod(dest, 493);
     }
   }
 }
 __name(installStatusLineModules, "installStatusLineModules");
-function ensureStatusLineSymlink(linkPath, targetPath) {
+async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (import_node_fs3.default.existsSync(linkPath)) {
-      const stats = import_node_fs3.default.lstatSync(linkPath);
+    if (await fileExists(linkPath)) {
+      const stats = await import_promises4.default.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = import_node_fs3.default.readlinkSync(linkPath);
+        const existingTarget = await import_promises4.default.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      import_node_fs3.default.unlinkSync(linkPath);
+      await import_promises4.default.unlink(linkPath);
     }
-    import_node_fs3.default.symlinkSync(targetPath, linkPath);
+    await import_promises4.default.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
-      if (import_node_fs3.default.existsSync(targetPath)) {
-        import_node_fs3.default.copyFileSync(targetPath, linkPath);
-        import_node_fs3.default.chmodSync(linkPath, 493);
+      if (await fileExists(targetPath)) {
+        await import_promises4.default.copyFile(targetPath, linkPath);
+        await import_promises4.default.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {