prjct-cli 0.37.0 → 0.39.0

package/dist/core/infrastructure/setup.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,22 +31,410 @@ 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/setup.ts
 var setup_exports = {};
 __export(setup_exports, {
   default: () => setup_default,
+  hasCursorProject: () => hasCursorProject,
+  hasWindsurfProject: () => hasWindsurfProject,
+  installAntigravitySkill: () => installAntigravitySkill,
+  installCursorProject: () => installCursorProject,
+  installWindsurfProject: () => installWindsurfProject,
+  needsAntigravityInstallation: () => needsAntigravityInstallation,
+  needsCursorRegeneration: () => needsCursorRegeneration,
+  needsWindsurfRegeneration: () => needsWindsurfRegeneration,
   run: () => run
 });
 module.exports = __toCommonJS(setup_exports);
 var import_child_process2 = require("child_process");
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
 var import_os4 = __toESM(require("os"));
 
 // core/infrastructure/command-installer.ts
 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"));
@@ -102,14 +493,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");
       }
@@ -120,21 +511,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 {
@@ -202,15 +604,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;
@@ -221,6 +629,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
    */
@@ -253,14 +667,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 {
@@ -271,8 +687,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", ""));
@@ -303,7 +719,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) {
@@ -388,7 +804,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) {
@@ -399,14 +815,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;
@@ -421,11 +840,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
@@ -455,8 +874,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");
@@ -481,10 +900,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/
@@ -498,8 +917,8 @@ var command_installer_default = commandInstaller;
 
 // core/infrastructure/editors-config.ts
 var import_promises2 = __toESM(require("fs/promises"));
-var import_path3 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
+var import_path4 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
 var EditorsConfig = class {
   static {
     __name(this, "EditorsConfig");
@@ -508,9 +927,9 @@ var EditorsConfig = class {
   configDir;
   configFile;
   constructor() {
-    this.homeDir = import_os2.default.homedir();
-    this.configDir = import_path3.default.join(this.homeDir, ".prjct-cli", "config");
-    this.configFile = import_path3.default.join(this.configDir, "installed-editors.json");
+    this.homeDir = import_os3.default.homedir();
+    this.configDir = import_path4.default.join(this.homeDir, ".prjct-cli", "config");
+    this.configFile = import_path4.default.join(this.configDir, "installed-editors.json");
   }
   /**
    * Ensure config directory exists
@@ -629,119 +1048,8 @@ var EditorsConfig = class {
 var editorsConfig = new EditorsConfig();
 var editors_config_default = editorsConfig;
 
-// core/infrastructure/ai-provider.ts
-var import_child_process = require("child_process");
-var import_path4 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
-var ClaudeProvider = {
-  name: "claude",
-  displayName: "Claude Code",
-  cliCommand: "claude",
-  configDir: import_path4.default.join(import_os3.default.homedir(), ".claude"),
-  contextFile: "CLAUDE.md",
-  skillsDir: import_path4.default.join(import_os3.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"
-};
-var GeminiProvider = {
-  name: "gemini",
-  displayName: "Gemini CLI",
-  cliCommand: "gemini",
-  configDir: import_path4.default.join(import_os3.default.homedir(), ".gemini"),
-  contextFile: "GEMINI.md",
-  skillsDir: import_path4.default.join(import_os3.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"
-};
-var Providers = {
-  claude: ClaudeProvider,
-  gemini: GeminiProvider
-};
-function whichCommand(command) {
-  try {
-    const result = (0, import_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
-    return result.trim();
-  } catch {
-    return null;
-  }
-}
-__name(whichCommand, "whichCommand");
-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;
-  }
-}
-__name(getCliVersion, "getCliVersion");
-function detectProvider(provider) {
-  const config = Providers[provider];
-  const cliPath = whichCommand(config.cliCommand);
-  if (!cliPath) {
-    return { installed: false };
-  }
-  const version = getCliVersion(config.cliCommand);
-  return {
-    installed: true,
-    version: version || void 0,
-    path: cliPath
-  };
-}
-__name(detectProvider, "detectProvider");
-function detectAllProviders() {
-  return {
-    claude: detectProvider("claude"),
-    gemini: detectProvider("gemini")
-  };
-}
-__name(detectAllProviders, "detectAllProviders");
-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
-  };
-}
-__name(selectProvider, "selectProvider");
-
 // core/infrastructure/setup.ts
+init_ai_provider();
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
 var DIM = "\x1B[2m";
@@ -776,8 +1084,8 @@ async function run() {
     commandsUpdated: 0,
     configAction: null
   };
-  const providerNames = ["claude", "gemini"];
-  for (const providerName of providerNames) {
+  const cliProviderNames = ["claude", "gemini"];
+  for (const providerName of cliProviderNames) {
     const providerConfig = Providers[providerName];
     const providerDetection = detection[providerName];
     const providerResult = {
@@ -833,6 +1141,13 @@ async function run() {
     }
     results.providers.push(providerResult);
   }
+  const antigravityDetection = detectAntigravity();
+  if (antigravityDetection.installed) {
+    const antigravityResult = await installAntigravitySkill();
+    if (antigravityResult.success) {
+      console.log(`   ${GREEN}\u2713${NC} Antigravity skill installed`);
+    }
+  }
   await editors_config_default.saveConfig(VERSION, command_installer_default.getInstallPath(), selection.provider);
   await migrateProjectsCliVersion();
   for (const providerResult of results.providers) {
@@ -847,9 +1162,9 @@ async function installGeminiRouter() {
     const geminiCommandsDir = import_path5.default.join(import_os4.default.homedir(), ".gemini", "commands");
     const routerSource = import_path5.default.join(getPackageRoot(), "templates", "commands", "p.toml");
     const routerDest = import_path5.default.join(geminiCommandsDir, "p.toml");
-    import_fs3.default.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (import_fs3.default.existsSync(routerSource)) {
-      import_fs3.default.copyFileSync(routerSource, routerDest);
+    import_fs4.default.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (import_fs4.default.existsSync(routerSource)) {
+      import_fs4.default.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -864,12 +1179,12 @@ async function installGeminiGlobalConfig() {
     const geminiDir = import_path5.default.join(import_os4.default.homedir(), ".gemini");
     const globalConfigPath = import_path5.default.join(geminiDir, "GEMINI.md");
     const templatePath = import_path5.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    import_fs3.default.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = import_fs3.default.readFileSync(templatePath, "utf-8");
+    import_fs4.default.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = import_fs4.default.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists = false;
     try {
-      existingContent = import_fs3.default.readFileSync(globalConfigPath, "utf-8");
+      existingContent = import_fs4.default.readFileSync(globalConfigPath, "utf-8");
       fileExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -879,7 +1194,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists) {
-      import_fs3.default.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      import_fs4.default.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -887,7 +1202,7 @@ async function installGeminiGlobalConfig() {
     const hasMarkers = existingContent.includes(startMarker) && existingContent.includes(endMarker);
     if (!hasMarkers) {
       const updatedContent2 = existingContent + "\n\n" + templateContent;
-      import_fs3.default.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      import_fs4.default.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -899,7 +1214,7 @@ async function installGeminiGlobalConfig() {
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    import_fs3.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    import_fs4.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -907,25 +1222,219 @@ async function installGeminiGlobalConfig() {
   }
 }
 __name(installGeminiGlobalConfig, "installGeminiGlobalConfig");
+async function installAntigravitySkill() {
+  try {
+    const antigravitySkillsDir = import_path5.default.join(import_os4.default.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = import_path5.default.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = import_path5.default.join(prjctSkillDir, "SKILL.md");
+    const templatePath = import_path5.default.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    import_fs4.default.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists = import_fs4.default.existsSync(skillMdPath);
+    if (!import_fs4.default.existsSync(templatePath)) {
+      console.error("Antigravity SKILL.md template not found");
+      return { success: false, action: null };
+    }
+    const templateContent = import_fs4.default.readFileSync(templatePath, "utf-8");
+    import_fs4.default.writeFileSync(skillMdPath, templateContent, "utf-8");
+    return { success: true, action: fileExists ? "updated" : "created" };
+  } catch (error) {
+    console.error(`Antigravity skill warning: ${error.message}`);
+    return { success: false, action: null };
+  }
+}
+__name(installAntigravitySkill, "installAntigravitySkill");
+function needsAntigravityInstallation() {
+  const detection = detectAntigravity();
+  return detection.installed && !detection.skillInstalled;
+}
+__name(needsAntigravityInstallation, "needsAntigravityInstallation");
+async function installCursorProject(projectRoot) {
+  const result = {
+    success: false,
+    rulesCreated: false,
+    commandsCreated: false,
+    gitignoreUpdated: false
+  };
+  try {
+    const cursorDir = import_path5.default.join(projectRoot, ".cursor");
+    const rulesDir = import_path5.default.join(cursorDir, "rules");
+    const commandsDir = import_path5.default.join(cursorDir, "commands");
+    const routerMdcDest = import_path5.default.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = import_path5.default.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = import_path5.default.join(getPackageRoot(), "templates", "cursor", "commands");
+    import_fs4.default.mkdirSync(rulesDir, { recursive: true });
+    import_fs4.default.mkdirSync(commandsDir, { recursive: true });
+    if (import_fs4.default.existsSync(routerMdcSource)) {
+      import_fs4.default.copyFileSync(routerMdcSource, routerMdcDest);
+      result.rulesCreated = true;
+    }
+    if (import_fs4.default.existsSync(cursorCommandsSource)) {
+      const commandFiles = import_fs4.default.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+      for (const file of commandFiles) {
+        const src = import_path5.default.join(cursorCommandsSource, file);
+        const dest = import_path5.default.join(commandsDir, file);
+        import_fs4.default.copyFileSync(src, dest);
+      }
+      result.commandsCreated = commandFiles.length > 0;
+    }
+    result.gitignoreUpdated = await addCursorToGitignore(projectRoot);
+    result.success = result.rulesCreated || result.commandsCreated;
+    return result;
+  } catch (error) {
+    console.error(`Cursor installation warning: ${error.message}`);
+    return result;
+  }
+}
+__name(installCursorProject, "installCursorProject");
+async function addCursorToGitignore(projectRoot) {
+  try {
+    const gitignorePath = import_path5.default.join(projectRoot, ".gitignore");
+    const entriesToAdd = [
+      "# prjct Cursor routers (regenerated per-developer)",
+      ".cursor/rules/prjct.mdc",
+      ".cursor/commands/sync.md",
+      ".cursor/commands/task.md",
+      ".cursor/commands/done.md",
+      ".cursor/commands/ship.md",
+      ".cursor/commands/bug.md",
+      ".cursor/commands/pause.md",
+      ".cursor/commands/resume.md"
+    ];
+    let content = "";
+    let fileExists = false;
+    try {
+      content = import_fs4.default.readFileSync(gitignorePath, "utf-8");
+      fileExists = true;
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+    if (content.includes(".cursor/rules/prjct.mdc")) {
+      return false;
+    }
+    const newContent = fileExists ? content.trimEnd() + "\n\n" + entriesToAdd.join("\n") + "\n" : entriesToAdd.join("\n") + "\n";
+    import_fs4.default.writeFileSync(gitignorePath, newContent, "utf-8");
+    return true;
+  } catch (error) {
+    console.error(`Gitignore update warning: ${error.message}`);
+    return false;
+  }
+}
+__name(addCursorToGitignore, "addCursorToGitignore");
+function hasCursorProject(projectRoot) {
+  return import_fs4.default.existsSync(import_path5.default.join(projectRoot, ".cursor"));
+}
+__name(hasCursorProject, "hasCursorProject");
+function needsCursorRegeneration(projectRoot) {
+  const cursorDir = import_path5.default.join(projectRoot, ".cursor");
+  const routerPath = import_path5.default.join(cursorDir, "rules", "prjct.mdc");
+  return import_fs4.default.existsSync(cursorDir) && !import_fs4.default.existsSync(routerPath);
+}
+__name(needsCursorRegeneration, "needsCursorRegeneration");
+async function installWindsurfProject(projectRoot) {
+  const result = {
+    success: false,
+    rulesCreated: false,
+    workflowsCreated: false,
+    gitignoreUpdated: false
+  };
+  try {
+    const windsurfDir = import_path5.default.join(projectRoot, ".windsurf");
+    const rulesDir = import_path5.default.join(windsurfDir, "rules");
+    const workflowsDir = import_path5.default.join(windsurfDir, "workflows");
+    const routerDest = import_path5.default.join(rulesDir, "prjct.md");
+    const routerSource = import_path5.default.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = import_path5.default.join(getPackageRoot(), "templates", "windsurf", "workflows");
+    import_fs4.default.mkdirSync(rulesDir, { recursive: true });
+    import_fs4.default.mkdirSync(workflowsDir, { recursive: true });
+    if (import_fs4.default.existsSync(routerSource)) {
+      import_fs4.default.copyFileSync(routerSource, routerDest);
+      result.rulesCreated = true;
+    }
+    if (import_fs4.default.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = import_fs4.default.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+      for (const file of workflowFiles) {
+        const src = import_path5.default.join(windsurfWorkflowsSource, file);
+        const dest = import_path5.default.join(workflowsDir, file);
+        import_fs4.default.copyFileSync(src, dest);
+      }
+      result.workflowsCreated = workflowFiles.length > 0;
+    }
+    result.gitignoreUpdated = await addWindsurfToGitignore(projectRoot);
+    result.success = result.rulesCreated || result.workflowsCreated;
+    return result;
+  } catch (error) {
+    console.error(`Windsurf installation warning: ${error.message}`);
+    return result;
+  }
+}
+__name(installWindsurfProject, "installWindsurfProject");
+async function addWindsurfToGitignore(projectRoot) {
+  try {
+    const gitignorePath = import_path5.default.join(projectRoot, ".gitignore");
+    const entriesToAdd = [
+      "# prjct Windsurf routers (regenerated per-developer)",
+      ".windsurf/rules/prjct.md",
+      ".windsurf/workflows/sync.md",
+      ".windsurf/workflows/task.md",
+      ".windsurf/workflows/done.md",
+      ".windsurf/workflows/ship.md",
+      ".windsurf/workflows/bug.md",
+      ".windsurf/workflows/pause.md",
+      ".windsurf/workflows/resume.md"
+    ];
+    let content = "";
+    let fileExists = false;
+    try {
+      content = import_fs4.default.readFileSync(gitignorePath, "utf-8");
+      fileExists = true;
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+    if (content.includes(".windsurf/rules/prjct.md")) {
+      return false;
+    }
+    const newContent = fileExists ? content.trimEnd() + "\n\n" + entriesToAdd.join("\n") + "\n" : entriesToAdd.join("\n") + "\n";
+    import_fs4.default.writeFileSync(gitignorePath, newContent, "utf-8");
+    return true;
+  } catch (error) {
+    console.error(`Gitignore update warning: ${error.message}`);
+    return false;
+  }
+}
+__name(addWindsurfToGitignore, "addWindsurfToGitignore");
+function hasWindsurfProject(projectRoot) {
+  return import_fs4.default.existsSync(import_path5.default.join(projectRoot, ".windsurf"));
+}
+__name(hasWindsurfProject, "hasWindsurfProject");
+function needsWindsurfRegeneration(projectRoot) {
+  const windsurfDir = import_path5.default.join(projectRoot, ".windsurf");
+  const routerPath = import_path5.default.join(windsurfDir, "rules", "prjct.md");
+  return import_fs4.default.existsSync(windsurfDir) && !import_fs4.default.existsSync(routerPath);
+}
+__name(needsWindsurfRegeneration, "needsWindsurfRegeneration");
 async function migrateProjectsCliVersion() {
   try {
     const projectsDir = import_path5.default.join(import_os4.default.homedir(), ".prjct-cli", "projects");
-    if (!import_fs3.default.existsSync(projectsDir)) {
+    if (!import_fs4.default.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = import_fs3.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = import_fs4.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
       const projectJsonPath = import_path5.default.join(projectsDir, projectId, "project.json");
-      if (!import_fs3.default.existsSync(projectJsonPath)) {
+      if (!import_fs4.default.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = import_fs3.default.readFileSync(projectJsonPath, "utf8");
+        const content = import_fs4.default.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          import_fs3.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          import_fs4.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -946,9 +1455,9 @@ async function migrateProjectsCliVersion() {
 __name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (import_fs3.default.existsSync(settingsPath)) {
+  if (import_fs4.default.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(import_fs3.default.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(import_fs4.default.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -956,7 +1465,7 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  import_fs3.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  import_fs4.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 __name(ensureStatusLineSettings, "ensureStatusLineSettings");
 async function installStatusLine() {
@@ -976,23 +1485,23 @@ async function installStatusLine() {
     const sourceLibDir = import_path5.default.join(assetsDir, "lib");
     const sourceComponentsDir = import_path5.default.join(assetsDir, "components");
     const sourceConfigPath = import_path5.default.join(assetsDir, "default-config.json");
-    if (!import_fs3.default.existsSync(claudeDir)) {
-      import_fs3.default.mkdirSync(claudeDir, { recursive: true });
+    if (!import_fs4.default.existsSync(claudeDir)) {
+      import_fs4.default.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!import_fs3.default.existsSync(prjctStatusLineDir)) {
-      import_fs3.default.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!import_fs4.default.existsSync(prjctStatusLineDir)) {
+      import_fs4.default.mkdirSync(prjctStatusLineDir, { recursive: true });
     }
-    if (!import_fs3.default.existsSync(prjctThemesDir)) {
-      import_fs3.default.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!import_fs4.default.existsSync(prjctThemesDir)) {
+      import_fs4.default.mkdirSync(prjctThemesDir, { recursive: true });
     }
-    if (!import_fs3.default.existsSync(prjctLibDir)) {
-      import_fs3.default.mkdirSync(prjctLibDir, { recursive: true });
+    if (!import_fs4.default.existsSync(prjctLibDir)) {
+      import_fs4.default.mkdirSync(prjctLibDir, { recursive: true });
     }
-    if (!import_fs3.default.existsSync(prjctComponentsDir)) {
-      import_fs3.default.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!import_fs4.default.existsSync(prjctComponentsDir)) {
+      import_fs4.default.mkdirSync(prjctComponentsDir, { recursive: true });
     }
-    if (import_fs3.default.existsSync(prjctStatusLinePath)) {
-      const existingContent = import_fs3.default.readFileSync(prjctStatusLinePath, "utf8");
+    if (import_fs4.default.existsSync(prjctStatusLinePath)) {
+      const existingContent = import_fs4.default.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -1000,7 +1509,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          import_fs3.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          import_fs4.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -1009,25 +1518,25 @@ async function installStatusLine() {
         return;
       }
     }
-    if (import_fs3.default.existsSync(sourceScript)) {
-      let scriptContent = import_fs3.default.readFileSync(sourceScript, "utf8");
+    if (import_fs4.default.existsSync(sourceScript)) {
+      let scriptContent = import_fs4.default.readFileSync(sourceScript, "utf8");
       scriptContent = scriptContent.replace(
         /CLI_VERSION="[^"]*"/,
         `CLI_VERSION="${VERSION}"`
       );
-      import_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      import_fs4.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (import_fs3.default.existsSync(sourceThemeDir)) {
-        const themes = import_fs3.default.readdirSync(sourceThemeDir);
+      if (import_fs4.default.existsSync(sourceThemeDir)) {
+        const themes = import_fs4.default.readdirSync(sourceThemeDir);
         for (const theme of themes) {
           const src = import_path5.default.join(sourceThemeDir, theme);
           const dest = import_path5.default.join(prjctThemesDir, theme);
-          import_fs3.default.copyFileSync(src, dest);
+          import_fs4.default.copyFileSync(src, dest);
         }
       }
-      if (!import_fs3.default.existsSync(prjctConfigPath) && import_fs3.default.existsSync(sourceConfigPath)) {
-        import_fs3.default.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!import_fs4.default.existsSync(prjctConfigPath) && import_fs4.default.existsSync(sourceConfigPath)) {
+        import_fs4.default.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -1062,7 +1571,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      import_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      import_fs4.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -1074,38 +1583,38 @@ echo "prjct"
 }
 __name(installStatusLine, "installStatusLine");
 function installStatusLineModules(sourceDir, destDir) {
-  if (!import_fs3.default.existsSync(sourceDir)) {
+  if (!import_fs4.default.existsSync(sourceDir)) {
     return;
   }
-  const files = import_fs3.default.readdirSync(sourceDir);
+  const files = import_fs4.default.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
       const src = import_path5.default.join(sourceDir, file);
       const dest = import_path5.default.join(destDir, file);
-      import_fs3.default.copyFileSync(src, dest);
-      import_fs3.default.chmodSync(dest, 493);
+      import_fs4.default.copyFileSync(src, dest);
+      import_fs4.default.chmodSync(dest, 493);
     }
   }
 }
 __name(installStatusLineModules, "installStatusLineModules");
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (import_fs3.default.existsSync(linkPath)) {
-      const stats = import_fs3.default.lstatSync(linkPath);
+    if (import_fs4.default.existsSync(linkPath)) {
+      const stats = import_fs4.default.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = import_fs3.default.readlinkSync(linkPath);
+        const existingTarget = import_fs4.default.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      import_fs3.default.unlinkSync(linkPath);
+      import_fs4.default.unlinkSync(linkPath);
     }
-    import_fs3.default.symlinkSync(targetPath, linkPath);
+    import_fs4.default.symlinkSync(targetPath, linkPath);
   } catch (error) {
     try {
-      if (import_fs3.default.existsSync(targetPath)) {
-        import_fs3.default.copyFileSync(targetPath, linkPath);
-        import_fs3.default.chmodSync(linkPath, 493);
+      if (import_fs4.default.existsSync(targetPath)) {
+        import_fs4.default.copyFileSync(targetPath, linkPath);
+        import_fs4.default.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -1150,5 +1659,13 @@ if (isDirectRun) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  hasCursorProject,
+  hasWindsurfProject,
+  installAntigravitySkill,
+  installCursorProject,
+  installWindsurfProject,
+  needsAntigravityInstallation,
+  needsCursorRegeneration,
+  needsWindsurfRegeneration,
   run
 });