prjct-cli 1.5.0 → 1.6.0

package/dist/core/infrastructure/command-installer.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_process.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_process.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_process, import_node_fs2, import_node_os, import_node_path2, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
+var import_node_child_process, 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_process = 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_process.exec);
     ClaudeProvider = {
       name: "claude",
       displayName: "Claude Code",
@@ -402,7 +426,7 @@ __export(command_installer_exports, {
   isRouterInstalled: () => isRouterInstalled
 });
 module.exports = __toCommonJS(command_installer_exports);
-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"));
 
@@ -464,7 +488,7 @@ var PACKAGE_ROOT = getPackageRoot();
 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;
@@ -476,7 +500,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];
@@ -484,7 +508,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;
@@ -493,7 +517,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 {
@@ -516,14 +540,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 };
@@ -534,9 +558,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,
@@ -545,7 +569,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(),
@@ -555,37 +579,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",
@@ -599,7 +623,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",
@@ -615,7 +639,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",
@@ -637,27 +661,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)) {
@@ -677,7 +707,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 [
@@ -709,7 +739,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,
@@ -718,7 +748,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 = [];
@@ -726,8 +756,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 });
@@ -757,7 +787,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") {
@@ -766,7 +796,7 @@ var CommandInstaller = class {
         }
       }
       try {
-        await import_promises.default.rmdir(this.claudeCommandsPath);
+        await import_promises2.default.rmdir(this.claudeCommandsPath);
       } catch (_error) {
       }
       return {
@@ -793,8 +823,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,
@@ -833,7 +863,8 @@ var CommandInstaller = class {
   /**
    * Get installation path for Claude commands
    */
-  getInstallPath() {
+  async getInstallPath() {
+    await this.ensureInit();
     return this.claudeCommandsPath;
   }
   /**
@@ -842,7 +873,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)) {
@@ -857,14 +888,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)) {
@@ -879,15 +910,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 {
         }
@@ -912,11 +943,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)) {
@@ -937,8 +968,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 {
@@ -993,7 +1024,7 @@ async function isRouterInstalled(provider) {
   const paths = getProviderPaths();
   const routerPath = paths[provider].router;
   try {
-    await import_promises.default.access(routerPath);
+    await import_promises2.default.access(routerPath);
     return true;
   } catch {
     return false;