prjct-cli 0.37.0 → 0.39.0

package/dist/core/infrastructure/command-installer.js

@@ -6,6 +6,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,386 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// core/infrastructure/ai-provider.ts
+var ai_provider_exports = {};
+__export(ai_provider_exports, {
+  AntigravityProvider: () => AntigravityProvider,
+  ClaudeProvider: () => ClaudeProvider,
+  CursorProvider: () => CursorProvider,
+  GeminiProvider: () => GeminiProvider,
+  Providers: () => Providers,
+  WindsurfProvider: () => WindsurfProvider,
+  default: () => ai_provider_default,
+  detectAllProviders: () => detectAllProviders,
+  detectAntigravity: () => detectAntigravity,
+  detectCursorProject: () => detectCursorProject,
+  detectProvider: () => detectProvider,
+  detectWindsurfProject: () => detectWindsurfProject,
+  getActiveProvider: () => getActiveProvider,
+  getCommandsDir: () => getCommandsDir,
+  getGlobalContextPath: () => getGlobalContextPath,
+  getGlobalSettingsPath: () => getGlobalSettingsPath,
+  getProjectCommandsPath: () => getProjectCommandsPath,
+  getProviderBranding: () => getProviderBranding,
+  getSkillsPath: () => getSkillsPath,
+  hasProviderConfig: () => hasProviderConfig,
+  needsCursorRouterRegeneration: () => needsCursorRouterRegeneration,
+  needsWindsurfRouterRegeneration: () => needsWindsurfRouterRegeneration,
+  selectProvider: () => selectProvider
+});
+function whichCommand(command) {
+  try {
+    const result = (0, import_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function getCliVersion(command) {
+  try {
+    const result = (0, import_child_process.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
+    const match = result.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : result.trim();
+  } catch {
+    return null;
+  }
+}
+function detectProvider(provider) {
+  const config = Providers[provider];
+  if (!config.cliCommand) {
+    return { installed: false };
+  }
+  const cliPath = whichCommand(config.cliCommand);
+  if (!cliPath) {
+    return { installed: false };
+  }
+  const version = getCliVersion(config.cliCommand);
+  return {
+    installed: true,
+    version: version || void 0,
+    path: cliPath
+  };
+}
+function detectAllProviders() {
+  return {
+    claude: detectProvider("claude"),
+    gemini: detectProvider("gemini")
+  };
+}
+function getActiveProvider(projectProvider) {
+  if (projectProvider && Providers[projectProvider]) {
+    return Providers[projectProvider];
+  }
+  const detection = detectAllProviders();
+  if (detection.claude.installed && !detection.gemini.installed) {
+    return ClaudeProvider;
+  }
+  if (detection.gemini.installed && !detection.claude.installed) {
+    return GeminiProvider;
+  }
+  return ClaudeProvider;
+}
+function hasProviderConfig(provider) {
+  const config = Providers[provider];
+  if (!config.configDir) {
+    return false;
+  }
+  return import_fs2.default.existsSync(config.configDir);
+}
+function getProviderBranding(provider) {
+  const config = Providers[provider];
+  if (provider === "gemini") {
+    return {
+      commitFooter: `\u{1F916} Generated with [p/](https://www.prjct.app/)
+Designed for [Gemini](${config.websiteUrl})`,
+      signature: "\u26A1 prjct + Gemini"
+    };
+  }
+  if (provider === "cursor") {
+    return {
+      commitFooter: `\u{1F916} Generated with [p/](https://www.prjct.app/)
+Built with [Cursor](${config.websiteUrl})`,
+      signature: "\u26A1 prjct + Cursor"
+    };
+  }
+  if (provider === "antigravity") {
+    return {
+      commitFooter: `\u{1F916} Generated with [p/](https://www.prjct.app/)
+Powered by [Antigravity](${config.websiteUrl})`,
+      signature: "\u26A1 prjct + Antigravity"
+    };
+  }
+  if (provider === "windsurf") {
+    return {
+      commitFooter: `\u{1F916} Generated with [p/](https://www.prjct.app/)
+Built with [Windsurf](${config.websiteUrl})`,
+      signature: "\u26A1 prjct + Windsurf"
+    };
+  }
+  return {
+    commitFooter: `\u{1F916} Generated with [p/](https://www.prjct.app/)
+Designed for [Claude](${config.websiteUrl})`,
+    signature: "\u26A1 prjct + Claude"
+  };
+}
+function detectCursorProject(projectRoot) {
+  const cursorDir = import_path2.default.join(projectRoot, ".cursor");
+  const rulesDir = import_path2.default.join(cursorDir, "rules");
+  const routerPath = import_path2.default.join(rulesDir, "prjct.mdc");
+  const detected = import_fs2.default.existsSync(cursorDir);
+  const routerInstalled = import_fs2.default.existsSync(routerPath);
+  return {
+    detected,
+    routerInstalled,
+    projectRoot: detected ? projectRoot : void 0
+  };
+}
+function needsCursorRouterRegeneration(projectRoot) {
+  const detection = detectCursorProject(projectRoot);
+  return detection.detected && !detection.routerInstalled;
+}
+function detectWindsurfProject(projectRoot) {
+  const windsurfDir = import_path2.default.join(projectRoot, ".windsurf");
+  const rulesDir = import_path2.default.join(windsurfDir, "rules");
+  const routerPath = import_path2.default.join(rulesDir, "prjct.md");
+  const detected = import_fs2.default.existsSync(windsurfDir);
+  const routerInstalled = import_fs2.default.existsSync(routerPath);
+  return {
+    detected,
+    routerInstalled,
+    projectRoot: detected ? projectRoot : void 0
+  };
+}
+function needsWindsurfRouterRegeneration(projectRoot) {
+  const detection = detectWindsurfProject(projectRoot);
+  return detection.detected && !detection.routerInstalled;
+}
+function detectAntigravity() {
+  const configPath = AntigravityProvider.configDir;
+  if (!configPath) {
+    return { installed: false, skillInstalled: false };
+  }
+  const installed = import_fs2.default.existsSync(configPath);
+  const skillPath = import_path2.default.join(configPath, "skills", "prjct", "SKILL.md");
+  const skillInstalled = import_fs2.default.existsSync(skillPath);
+  return {
+    installed,
+    skillInstalled,
+    configPath: installed ? configPath : void 0
+  };
+}
+function getGlobalContextPath(provider) {
+  const config = Providers[provider];
+  if (!config.configDir) {
+    return null;
+  }
+  return import_path2.default.join(config.configDir, config.contextFile);
+}
+function getGlobalSettingsPath(provider) {
+  const config = Providers[provider];
+  if (!config.configDir || !config.settingsFile) {
+    return null;
+  }
+  return import_path2.default.join(config.configDir, config.settingsFile);
+}
+function getSkillsPath(provider) {
+  return Providers[provider].skillsDir;
+}
+function getCommandsDir(provider) {
+  return Providers[provider].commandsDir;
+}
+function getProjectCommandsPath(provider, projectRoot) {
+  const config = Providers[provider];
+  return import_path2.default.join(projectRoot, config.commandsDir);
+}
+function selectProvider() {
+  const detection = detectAllProviders();
+  const claudeInstalled = detection.claude.installed;
+  const geminiInstalled = detection.gemini.installed;
+  if (!claudeInstalled && !geminiInstalled) {
+    return {
+      provider: "claude",
+      userSelected: false,
+      detection
+    };
+  }
+  if (claudeInstalled && !geminiInstalled) {
+    return {
+      provider: "claude",
+      userSelected: false,
+      detection
+    };
+  }
+  if (geminiInstalled && !claudeInstalled) {
+    return {
+      provider: "gemini",
+      userSelected: false,
+      detection
+    };
+  }
+  return {
+    provider: "claude",
+    userSelected: true,
+    // Indicates user should be prompted
+    detection
+  };
+}
+var import_child_process, import_fs2, import_path2, import_os, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
+var init_ai_provider = __esm({
+  "core/infrastructure/ai-provider.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_fs2 = __toESM(require("fs"));
+    import_path2 = __toESM(require("path"));
+    import_os = __toESM(require("os"));
+    ClaudeProvider = {
+      name: "claude",
+      displayName: "Claude Code",
+      cliCommand: "claude",
+      configDir: import_path2.default.join(import_os.default.homedir(), ".claude"),
+      contextFile: "CLAUDE.md",
+      skillsDir: import_path2.default.join(import_os.default.homedir(), ".claude", "skills"),
+      commandsDir: ".claude/commands",
+      commandFormat: "md",
+      settingsFile: "settings.json",
+      projectSettingsFile: "settings.local.json",
+      ignoreFile: ".claudeignore",
+      websiteUrl: "https://www.anthropic.com/claude",
+      docsUrl: "https://docs.anthropic.com/claude-code"
+    };
+    GeminiProvider = {
+      name: "gemini",
+      displayName: "Gemini CLI",
+      cliCommand: "gemini",
+      configDir: import_path2.default.join(import_os.default.homedir(), ".gemini"),
+      contextFile: "GEMINI.md",
+      skillsDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "skills"),
+      commandsDir: ".gemini/commands",
+      commandFormat: "toml",
+      settingsFile: "settings.json",
+      projectSettingsFile: "settings.json",
+      ignoreFile: ".geminiignore",
+      websiteUrl: "https://geminicli.com",
+      docsUrl: "https://geminicli.com/docs"
+    };
+    AntigravityProvider = {
+      name: "antigravity",
+      displayName: "Google Antigravity",
+      cliCommand: null,
+      // Not a CLI command, but a platform/app
+      configDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "antigravity"),
+      contextFile: "ANTIGRAVITY.md",
+      skillsDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "antigravity", "global_skills"),
+      commandsDir: ".agent/skills",
+      // Antigravity uses .agent/skills in projects
+      commandFormat: "md",
+      // Uses SKILL.md
+      settingsFile: "mcp_config.json",
+      // Uses MCP config
+      projectSettingsFile: null,
+      ignoreFile: ".agentignore",
+      // Assumed
+      websiteUrl: "https://gemini.google.com/app/antigravity",
+      docsUrl: "https://gemini.google.com/app/antigravity"
+    };
+    CursorProvider = {
+      name: "cursor",
+      displayName: "Cursor IDE",
+      cliCommand: null,
+      // Not a CLI - GUI app
+      configDir: null,
+      // No global config directory
+      contextFile: "prjct.mdc",
+      // Uses .mdc format with frontmatter
+      skillsDir: null,
+      // No skills directory
+      commandsDir: ".cursor/commands",
+      rulesDir: ".cursor/rules",
+      // Cursor-specific: rules directory
+      commandFormat: "md",
+      settingsFile: null,
+      projectSettingsFile: null,
+      ignoreFile: ".cursorignore",
+      isProjectLevel: true,
+      // Config is project-level only
+      websiteUrl: "https://cursor.com",
+      docsUrl: "https://cursor.com/docs"
+    };
+    WindsurfProvider = {
+      name: "windsurf",
+      displayName: "Windsurf IDE",
+      cliCommand: null,
+      // Not a CLI - GUI app
+      configDir: null,
+      // No global config directory
+      contextFile: "prjct.md",
+      // Uses .md format (not .mdc)
+      skillsDir: null,
+      // No skills directory
+      commandsDir: ".windsurf/workflows",
+      // Windsurf uses "workflows" not "commands"
+      rulesDir: ".windsurf/rules",
+      commandFormat: "md",
+      settingsFile: null,
+      projectSettingsFile: null,
+      ignoreFile: ".windsurfignore",
+      isProjectLevel: true,
+      // Config is project-level only
+      websiteUrl: "https://windsurf.com",
+      docsUrl: "https://docs.windsurf.com"
+    };
+    Providers = {
+      claude: ClaudeProvider,
+      gemini: GeminiProvider,
+      cursor: CursorProvider,
+      antigravity: AntigravityProvider,
+      windsurf: WindsurfProvider
+    };
+    __name(whichCommand, "whichCommand");
+    __name(getCliVersion, "getCliVersion");
+    __name(detectProvider, "detectProvider");
+    __name(detectAllProviders, "detectAllProviders");
+    __name(getActiveProvider, "getActiveProvider");
+    __name(hasProviderConfig, "hasProviderConfig");
+    __name(getProviderBranding, "getProviderBranding");
+    __name(detectCursorProject, "detectCursorProject");
+    __name(needsCursorRouterRegeneration, "needsCursorRouterRegeneration");
+    __name(detectWindsurfProject, "detectWindsurfProject");
+    __name(needsWindsurfRouterRegeneration, "needsWindsurfRouterRegeneration");
+    __name(detectAntigravity, "detectAntigravity");
+    __name(getGlobalContextPath, "getGlobalContextPath");
+    __name(getGlobalSettingsPath, "getGlobalSettingsPath");
+    __name(getSkillsPath, "getSkillsPath");
+    __name(getCommandsDir, "getCommandsDir");
+    __name(getProjectCommandsPath, "getProjectCommandsPath");
+    __name(selectProvider, "selectProvider");
+    ai_provider_default = {
+      Providers,
+      ClaudeProvider,
+      GeminiProvider,
+      CursorProvider,
+      AntigravityProvider,
+      WindsurfProvider,
+      detectProvider,
+      detectAllProviders,
+      detectAntigravity,
+      getActiveProvider,
+      hasProviderConfig,
+      getProviderBranding,
+      getGlobalContextPath,
+      getGlobalSettingsPath,
+      getSkillsPath,
+      getCommandsDir,
+      getProjectCommandsPath,
+      selectProvider,
+      detectCursorProject,
+      needsCursorRouterRegeneration,
+      detectWindsurfProject,
+      needsWindsurfRouterRegeneration
+    };
+  }
+});
+
 // core/infrastructure/command-installer.ts
 var command_installer_exports = {};
 __export(command_installer_exports, {
@@ -40,8 +423,8 @@ __export(command_installer_exports, {
 });
 module.exports = __toCommonJS(command_installer_exports);
 var import_promises = __toESM(require("fs/promises"));
-var import_path2 = __toESM(require("path"));
-var import_os = __toESM(require("os"));
+var import_path3 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
 
 // core/utils/version.ts
 var import_fs = __toESM(require("fs"));
@@ -100,14 +483,14 @@ __name(isNotFoundError, "isNotFoundError");
 // core/infrastructure/command-installer.ts
 async function installDocs() {
   try {
-    const docsDir = import_path2.default.join(import_os.default.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = import_path2.default.join(getPackageRoot(), "templates/global/docs");
+    const docsDir = import_path3.default.join(import_os2.default.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = import_path3.default.join(getPackageRoot(), "templates/global/docs");
     await import_promises.default.mkdir(docsDir, { recursive: true });
     const docFiles = await import_promises.default.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
-        const srcPath = import_path2.default.join(templateDocsDir, file);
-        const destPath = import_path2.default.join(docsDir, file);
+        const srcPath = import_path3.default.join(templateDocsDir, file);
+        const destPath = import_path3.default.join(docsDir, file);
         const content = await import_promises.default.readFile(srcPath, "utf-8");
         await import_promises.default.writeFile(destPath, content, "utf-8");
       }
@@ -118,21 +501,32 @@ async function installDocs() {
   }
 }
 __name(installDocs, "installDocs");
-async function installGlobalConfig(claudeConfigPath, detectClaude) {
-  const claudeDetected = await detectClaude();
-  if (!claudeDetected) {
+async function installGlobalConfig() {
+  const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
+  const activeProvider = aiProvider.getActiveProvider();
+  const providerName = activeProvider.name;
+  const detection = aiProvider.detectProvider(providerName);
+  if (!detection.installed && !activeProvider.configDir) {
     return {
       success: false,
-      error: "Claude not detected",
+      error: `${activeProvider.displayName} not detected`,
       action: "skipped"
     };
   }
   try {
-    const claudeDir = import_path2.default.join(import_os.default.homedir(), ".claude");
-    await import_promises.default.mkdir(claudeDir, { recursive: true });
-    const globalConfigPath = import_path2.default.join(claudeDir, "CLAUDE.md");
-    const templatePath = import_path2.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-    const templateContent = await import_promises.default.readFile(templatePath, "utf-8");
+    await import_promises.default.mkdir(activeProvider.configDir, { recursive: true });
+    const globalConfigPath = import_path3.default.join(activeProvider.configDir, activeProvider.contextFile);
+    const templatePath = import_path3.default.join(getPackageRoot(), "templates", "global", activeProvider.contextFile);
+    let templateContent = "";
+    try {
+      templateContent = await import_promises.default.readFile(templatePath, "utf-8");
+    } catch (error) {
+      const fallbackTemplatePath = import_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
+      templateContent = await import_promises.default.readFile(fallbackTemplatePath, "utf-8");
+      if (providerName === "gemini") {
+        templateContent = templateContent.replace(/Claude/g, "Gemini");
+      }
+    }
     let existingContent = "";
     let fileExists = false;
     try {
@@ -200,15 +594,21 @@ var CommandInstaller = class {
   claudeConfigPath;
   templatesDir;
   constructor() {
-    this.homeDir = import_os.default.homedir();
-    this.claudeCommandsPath = import_path2.default.join(this.homeDir, ".claude", "commands", "p");
-    this.claudeConfigPath = import_path2.default.join(this.homeDir, ".claude");
-    this.templatesDir = import_path2.default.join(getPackageRoot(), "templates", "commands");
+    this.homeDir = import_os2.default.homedir();
+    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
+    const activeProvider = aiProvider.getActiveProvider();
+    if (activeProvider.name === "gemini") {
+      this.claudeCommandsPath = import_path3.default.join(activeProvider.configDir, "commands");
+    } else {
+      this.claudeCommandsPath = import_path3.default.join(activeProvider.configDir, "commands", "p");
+    }
+    this.claudeConfigPath = activeProvider.configDir;
+    this.templatesDir = import_path3.default.join(getPackageRoot(), "templates", "commands");
   }
   /**
-   * Detect if Claude is installed
+   * Detect if active provider is installed
    */
-  async detectClaude() {
+  async detectActiveProvider() {
     try {
       await import_promises.default.access(this.claudeConfigPath);
       return true;
@@ -219,6 +619,12 @@ var CommandInstaller = class {
       throw error;
     }
   }
+  /**
+   * Detect if Claude is installed (legacy support)
+   */
+  async detectClaude() {
+    return this.detectActiveProvider();
+  }
   /**
    * Get list of command files to install
    */
@@ -251,14 +657,16 @@ var CommandInstaller = class {
     }
   }
   /**
-   * Install commands to Claude
+   * Install commands to active AI agent
    */
   async installCommands() {
-    const claudeDetected = await this.detectClaude();
-    if (!claudeDetected) {
+    const providerDetected = await this.detectActiveProvider();
+    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
+    const activeProvider = aiProvider.getActiveProvider();
+    if (!providerDetected) {
       return {
         success: false,
-        error: "Claude not detected. Please install Claude Code or Claude Desktop first."
+        error: `${activeProvider.displayName} not detected. Please install it first.`
       };
     }
     try {
@@ -269,8 +677,8 @@ var CommandInstaller = class {
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const sourcePath = import_path2.default.join(this.templatesDir, file);
-          const destPath = import_path2.default.join(this.claudeCommandsPath, file);
+          const sourcePath = import_path3.default.join(this.templatesDir, file);
+          const destPath = import_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");
           installed.push(file.replace(".md", ""));
@@ -301,7 +709,7 @@ var CommandInstaller = class {
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const filePath = import_path2.default.join(this.claudeCommandsPath, file);
+          const filePath = import_path3.default.join(this.claudeCommandsPath, file);
           await import_promises.default.unlink(filePath);
           uninstalled.push(file.replace(".md", ""));
         } catch (error) {
@@ -386,7 +794,7 @@ var CommandInstaller = class {
    */
   async verifyTemplate(commandName) {
     try {
-      const templatePath = import_path2.default.join(this.templatesDir, `${commandName}.md`);
+      const templatePath = import_path3.default.join(this.templatesDir, `${commandName}.md`);
       await import_promises.default.access(templatePath);
       return true;
     } catch (error) {
@@ -397,14 +805,17 @@ var CommandInstaller = class {
     }
   }
   /**
-   * Install the p.md router to ~/.claude/commands/
+   * Install the router (p.md for Claude, p.toml for Gemini) to commands directory
    * This enables the "p. task" natural language trigger
-   * Claude Code bug #2422 prevents subdirectory slash command discovery
    */
   async installRouter() {
+    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
+    const activeProvider = aiProvider.getActiveProvider();
+    const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
     try {
-      const routerSource = import_path2.default.join(this.templatesDir, "p.md");
-      const routerDest = import_path2.default.join(this.homeDir, ".claude", "commands", "p.md");
+      const routerSource = import_path3.default.join(this.templatesDir, routerFile);
+      const routerDest = import_path3.default.join(activeProvider.configDir, "commands", routerFile);
+      await import_promises.default.mkdir(import_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");
       return true;
@@ -419,11 +830,11 @@ var CommandInstaller = class {
    * Sync commands - intelligent update that detects and removes orphans
    */
   async syncCommands() {
-    const claudeDetected = await this.detectClaude();
-    if (!claudeDetected) {
+    const providerDetected = await this.detectActiveProvider();
+    if (!providerDetected) {
       return {
         success: false,
-        error: "Claude not detected",
+        error: "AI agent not detected",
         added: 0,
         updated: 0,
         removed: 0
@@ -453,8 +864,8 @@ var CommandInstaller = class {
       };
       for (const file of templateFiles) {
         try {
-          const sourcePath = import_path2.default.join(this.templatesDir, file);
-          const destPath = import_path2.default.join(this.claudeCommandsPath, file);
+          const sourcePath = import_path3.default.join(this.templatesDir, file);
+          const destPath = import_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");
@@ -479,10 +890,10 @@ var CommandInstaller = class {
     }
   }
   /**
-   * Install or update global CLAUDE.md configuration
+   * Install or update global AI agent configuration (CLAUDE.md / GEMINI.md)
    */
   async installGlobalConfig() {
-    return installGlobalConfig(this.claudeConfigPath, () => this.detectClaude());
+    return installGlobalConfig();
   }
   /**
    * Install documentation files to ~/.prjct-cli/docs/
@@ -492,17 +903,17 @@ var CommandInstaller = class {
   }
 };
 function getProviderPaths() {
-  const homeDir = import_os.default.homedir();
+  const homeDir = import_os2.default.homedir();
   return {
     claude: {
-      commands: import_path2.default.join(homeDir, ".claude", "commands", "p"),
-      config: import_path2.default.join(homeDir, ".claude"),
-      router: import_path2.default.join(homeDir, ".claude", "commands", "p.md")
+      commands: import_path3.default.join(homeDir, ".claude", "commands", "p"),
+      config: import_path3.default.join(homeDir, ".claude"),
+      router: import_path3.default.join(homeDir, ".claude", "commands", "p.md")
     },
     gemini: {
-      commands: import_path2.default.join(homeDir, ".gemini", "commands"),
-      config: import_path2.default.join(homeDir, ".gemini"),
-      router: import_path2.default.join(homeDir, ".gemini", "commands", "p.toml")
+      commands: import_path3.default.join(homeDir, ".gemini", "commands"),
+      config: import_path3.default.join(homeDir, ".gemini"),
+      router: import_path3.default.join(homeDir, ".gemini", "commands", "p.toml")
     }
   };
 }