prjct-cli 0.45.0 → 0.45.4

package/dist/core/infrastructure/setup.js

@@ -60,7 +60,7 @@ __export(ai_provider_exports, {
 });
 function whichCommand(command) {
   try {
-    const result = (0, import_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
+    const result = (0, import_node_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
     return result.trim();
   } catch {
     return null;
@@ -68,7 +68,7 @@ function whichCommand(command) {
 }
 function getCliVersion(command) {
   try {
-    const result = (0, import_child_process.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
+    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();
   } catch {
@@ -115,7 +115,7 @@ function hasProviderConfig(provider) {
   if (!config.configDir) {
     return false;
   }
-  return import_fs2.default.existsSync(config.configDir);
+  return import_node_fs2.default.existsSync(config.configDir);
 }
 function getProviderBranding(provider) {
   const commitFooter = `Generated with [p/](https://www.prjct.app/)`;
@@ -132,11 +132,11 @@ function getProviderBranding(provider) {
   };
 }
 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);
+  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);
   return {
     detected,
     routerInstalled,
@@ -148,11 +148,11 @@ function needsCursorRouterRegeneration(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);
+  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);
   return {
     detected,
     routerInstalled,
@@ -168,9 +168,9 @@ function detectAntigravity() {
   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);
+  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);
   return {
     installed,
     skillInstalled,
@@ -182,14 +182,14 @@ function getGlobalContextPath(provider) {
   if (!config.configDir) {
     return null;
   }
-  return import_path2.default.join(config.configDir, config.contextFile);
+  return import_node_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);
+  return import_node_path2.default.join(config.configDir, config.settingsFile);
 }
 function getSkillsPath(provider) {
   return Providers[provider].skillsDir;
@@ -199,7 +199,7 @@ function getCommandsDir(provider) {
 }
 function getProjectCommandsPath(provider, projectRoot) {
   const config = Providers[provider];
-  return import_path2.default.join(projectRoot, config.commandsDir);
+  return import_node_path2.default.join(projectRoot, config.commandsDir);
 }
 function selectProvider() {
   const detection = detectAllProviders();
@@ -233,21 +233,21 @@ function selectProvider() {
     detection
   };
 }
-var import_child_process, import_fs2, import_path2, import_os, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
+var import_node_child_process, import_node_fs2, import_node_os, import_node_path2, 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"));
+    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"));
     ClaudeProvider = {
       name: "claude",
       displayName: "Claude Code",
       cliCommand: "claude",
-      configDir: import_path2.default.join(import_os.default.homedir(), ".claude"),
+      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".claude"),
       contextFile: "CLAUDE.md",
-      skillsDir: import_path2.default.join(import_os.default.homedir(), ".claude", "skills"),
+      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".claude", "skills"),
       commandsDir: ".claude/commands",
       commandFormat: "md",
       settingsFile: "settings.json",
@@ -260,9 +260,9 @@ var init_ai_provider = __esm({
       name: "gemini",
       displayName: "Gemini CLI",
       cliCommand: "gemini",
-      configDir: import_path2.default.join(import_os.default.homedir(), ".gemini"),
+      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini"),
       contextFile: "GEMINI.md",
-      skillsDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "skills"),
+      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "skills"),
       commandsDir: ".gemini/commands",
       commandFormat: "toml",
       settingsFile: "settings.json",
@@ -276,9 +276,9 @@ var init_ai_provider = __esm({
       displayName: "Google Antigravity",
       cliCommand: null,
       // Not a CLI command, but a platform/app
-      configDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "antigravity"),
+      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "antigravity"),
       contextFile: "ANTIGRAVITY.md",
-      skillsDir: import_path2.default.join(import_os.default.homedir(), ".gemini", "antigravity", "global_skills"),
+      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "antigravity", "global_skills"),
       commandsDir: ".agent/skills",
       // Antigravity uses .agent/skills in projects
       commandFormat: "md",
@@ -404,19 +404,20 @@ __export(setup_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(setup_exports);
-var import_child_process2 = require("child_process");
-var import_fs4 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
-var import_os4 = __toESM(require("os"));
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_os4 = __toESM(require("node:os"));
+var import_node_path5 = __toESM(require("node:path"));
 
-// core/infrastructure/command-installer.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_path3 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
+// core/types/fs.ts
+function isNotFoundError(error) {
+  return error?.code === "ENOENT";
+}
+__name(isNotFoundError, "isNotFoundError");
 
 // core/utils/version.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
 var cachedVersion = null;
 var cachedPackageJson = null;
 var cachedPackageRoot = null;
@@ -426,10 +427,10 @@ function getPackageRoot() {
   }
   let currentDir = __dirname;
   for (let i = 0; i < 5; i++) {
-    const packageJsonPath = import_path.default.join(currentDir, "package.json");
-    if (import_fs.default.existsSync(packageJsonPath)) {
+    const packageJsonPath = import_node_path.default.join(currentDir, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath)) {
       try {
-        const pkg = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+        const pkg = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf-8"));
         if (pkg.name === "prjct-cli") {
           cachedPackageRoot = currentDir;
           return currentDir;
@@ -437,9 +438,9 @@ function getPackageRoot() {
       } catch (_error) {
       }
     }
-    currentDir = import_path.default.dirname(currentDir);
+    currentDir = import_node_path.default.dirname(currentDir);
   }
-  cachedPackageRoot = import_path.default.join(__dirname, "..", "..", "..");
+  cachedPackageRoot = import_node_path.default.join(__dirname, "..", "..", "..");
   return cachedPackageRoot;
 }
 __name(getPackageRoot, "getPackageRoot");
@@ -448,8 +449,8 @@ function getVersion() {
     return cachedVersion;
   }
   try {
-    const packageJsonPath = import_path.default.join(getPackageRoot(), "package.json");
-    const packageJson = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = import_node_path.default.join(getPackageRoot(), "package.json");
+    const packageJson = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf-8"));
     cachedVersion = packageJson.version;
     cachedPackageJson = packageJson;
     return cachedVersion;
@@ -462,23 +463,23 @@ __name(getVersion, "getVersion");
 var VERSION = getVersion();
 var PACKAGE_ROOT = getPackageRoot();
 
-// core/types/fs.ts
-function isNotFoundError(error) {
-  return error?.code === "ENOENT";
-}
-__name(isNotFoundError, "isNotFoundError");
+// core/infrastructure/setup.ts
+init_ai_provider();
 
 // core/infrastructure/command-installer.ts
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path3 = __toESM(require("node:path"));
 async function installDocs() {
   try {
-    const docsDir = import_path3.default.join(import_os2.default.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = import_path3.default.join(getPackageRoot(), "templates/global/docs");
+    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);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
-        const srcPath = import_path3.default.join(templateDocsDir, file);
-        const destPath = import_path3.default.join(docsDir, file);
+        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");
       }
@@ -503,13 +504,18 @@ async function installGlobalConfig() {
   }
   try {
     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);
+    const globalConfigPath = import_node_path3.default.join(activeProvider.configDir, activeProvider.contextFile);
+    const templatePath = import_node_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");
+    } catch (_error) {
+      const fallbackTemplatePath = import_node_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");
@@ -539,7 +545,9 @@ async function installGlobalConfig() {
       const endMarker = "<!-- prjct:end - DO NOT REMOVE THIS MARKER -->";
       const hasMarkers = existingContent.includes(startMarker) && existingContent.includes(endMarker);
       if (!hasMarkers) {
-        const updatedContent = existingContent + "\n\n" + templateContent;
+        const updatedContent = `${existingContent}
+
+${templateContent}`;
         await import_promises.default.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
@@ -582,16 +590,16 @@ var CommandInstaller = class {
   claudeConfigPath;
   templatesDir;
   constructor() {
-    this.homeDir = import_os2.default.homedir();
+    this.homeDir = import_node_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");
+      this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands");
     } else {
-      this.claudeCommandsPath = import_path3.default.join(activeProvider.configDir, "commands", "p");
+      this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands", "p");
     }
     this.claudeConfigPath = activeProvider.configDir;
-    this.templatesDir = import_path3.default.join(getPackageRoot(), "templates", "commands");
+    this.templatesDir = import_node_path3.default.join(getPackageRoot(), "templates", "commands");
   }
   /**
    * Detect if active provider is installed
@@ -620,7 +628,7 @@ var CommandInstaller = class {
     try {
       const files = await import_promises.default.readdir(this.templatesDir);
       return files.filter((f) => f.endsWith(".md"));
-    } catch (error) {
+    } catch (_error) {
       return [
         "init.md",
         "now.md",
@@ -665,8 +673,8 @@ var CommandInstaller = class {
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const sourcePath = import_path3.default.join(this.templatesDir, file);
-          const destPath = import_path3.default.join(this.claudeCommandsPath, file);
+          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");
           installed.push(file.replace(".md", ""));
@@ -697,7 +705,7 @@ var CommandInstaller = class {
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const filePath = import_path3.default.join(this.claudeCommandsPath, file);
+          const filePath = import_node_path3.default.join(this.claudeCommandsPath, file);
           await import_promises.default.unlink(filePath);
           uninstalled.push(file.replace(".md", ""));
         } catch (error) {
@@ -708,7 +716,7 @@ var CommandInstaller = class {
       }
       try {
         await import_promises.default.rmdir(this.claudeCommandsPath);
-      } catch (error) {
+      } catch (_error) {
       }
       return {
         success: true,
@@ -782,7 +790,7 @@ var CommandInstaller = class {
    */
   async verifyTemplate(commandName) {
     try {
-      const templatePath = import_path3.default.join(this.templatesDir, `${commandName}.md`);
+      const templatePath = import_node_path3.default.join(this.templatesDir, `${commandName}.md`);
       await import_promises.default.access(templatePath);
       return true;
     } catch (error) {
@@ -801,9 +809,9 @@ var CommandInstaller = class {
     const activeProvider = aiProvider.getActiveProvider();
     const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
     try {
-      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 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");
       return true;
@@ -852,8 +860,8 @@ var CommandInstaller = class {
       };
       for (const file of templateFiles) {
         try {
-          const sourcePath = import_path3.default.join(this.templatesDir, file);
-          const destPath = import_path3.default.join(this.claudeCommandsPath, file);
+          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");
@@ -894,9 +902,9 @@ var commandInstaller = new CommandInstaller();
 var command_installer_default = commandInstaller;
 
 // core/infrastructure/editors-config.ts
-var import_promises2 = __toESM(require("fs/promises"));
-var import_path4 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_promises2 = __toESM(require("node:fs/promises"));
+var import_node_os3 = __toESM(require("node:os"));
+var import_node_path4 = __toESM(require("node:path"));
 var EditorsConfig = class {
   static {
     __name(this, "EditorsConfig");
@@ -905,9 +913,9 @@ var EditorsConfig = class {
   configDir;
   configFile;
   constructor() {
-    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");
+    this.homeDir = import_node_os3.default.homedir();
+    this.configDir = import_node_path4.default.join(this.homeDir, ".prjct-cli", "config");
+    this.configFile = import_node_path4.default.join(this.configDir, "installed-editors.json");
   }
   /**
    * Ensure config directory exists
@@ -1027,7 +1035,6 @@ var editorsConfig = new EditorsConfig();
 var editors_config_default = editorsConfig;
 
 // core/infrastructure/setup.ts
-init_ai_provider();
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
 var DIM = "\x1B[2m";
@@ -1037,13 +1044,15 @@ async function installAICLI(provider) {
   try {
     console.log(`${YELLOW}\u{1F4E6} ${provider.displayName} not found. Installing...${NC}`);
     console.log("");
-    (0, import_child_process2.execSync)(`npm install -g ${packageName}`, { stdio: "inherit" });
+    (0, import_node_child_process2.execSync)(`npm install -g ${packageName}`, { stdio: "inherit" });
     console.log("");
     console.log(`${GREEN}\u2713${NC} ${provider.displayName} installed successfully`);
     console.log("");
     return true;
   } catch (error) {
-    console.log(`${YELLOW}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${error.message}${NC}`);
+    console.log(
+      `${YELLOW}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${error.message}${NC}`
+    );
     console.log(`${DIM}Please install manually: npm install -g ${packageName}${NC}`);
     console.log("");
     return false;
@@ -1053,7 +1062,7 @@ __name(installAICLI, "installAICLI");
 async function run() {
   const detection = detectAllProviders();
   const selection = selectProvider();
-  const primaryProvider = Providers[selection.provider];
+  const _primaryProvider = Providers[selection.provider];
   const results = {
     provider: selection.provider,
     providers: [],
@@ -1137,12 +1146,12 @@ __name(run, "run");
 var setup_default = { run };
 async function installGeminiRouter() {
   try {
-    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_fs4.default.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (import_fs4.default.existsSync(routerSource)) {
-      import_fs4.default.copyFileSync(routerSource, routerDest);
+    const geminiCommandsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini", "commands");
+    const routerSource = import_node_path5.default.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = import_node_path5.default.join(geminiCommandsDir, "p.toml");
+    import_node_fs3.default.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (import_node_fs3.default.existsSync(routerSource)) {
+      import_node_fs3.default.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -1154,15 +1163,15 @@ async function installGeminiRouter() {
 __name(installGeminiRouter, "installGeminiRouter");
 async function installGeminiGlobalConfig() {
   try {
-    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_fs4.default.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = import_fs4.default.readFileSync(templatePath, "utf-8");
+    const geminiDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini");
+    const globalConfigPath = import_node_path5.default.join(geminiDir, "GEMINI.md");
+    const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    import_node_fs3.default.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = import_node_fs3.default.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists = false;
     try {
-      existingContent = import_fs4.default.readFileSync(globalConfigPath, "utf-8");
+      existingContent = import_node_fs3.default.readFileSync(globalConfigPath, "utf-8");
       fileExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1172,15 +1181,17 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists) {
-      import_fs4.default.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      import_node_fs3.default.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
     const endMarker = "<!-- prjct:end - DO NOT REMOVE THIS MARKER -->";
     const hasMarkers = existingContent.includes(startMarker) && existingContent.includes(endMarker);
     if (!hasMarkers) {
-      const updatedContent2 = existingContent + "\n\n" + templateContent;
-      import_fs4.default.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      const updatedContent2 = `${existingContent}
+
+${templateContent}`;
+      import_node_fs3.default.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -1192,7 +1203,7 @@ async function installGeminiGlobalConfig() {
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    import_fs4.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    import_node_fs3.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -1202,18 +1213,18 @@ 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)) {
+    const antigravitySkillsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = import_node_path5.default.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = import_node_path5.default.join(prjctSkillDir, "SKILL.md");
+    const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    import_node_fs3.default.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists = import_node_fs3.default.existsSync(skillMdPath);
+    if (!import_node_fs3.default.existsSync(templatePath)) {
       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");
+    const templateContent = import_node_fs3.default.readFileSync(templatePath, "utf-8");
+    import_node_fs3.default.writeFileSync(skillMdPath, templateContent, "utf-8");
     return { success: true, action: fileExists ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -1234,24 +1245,24 @@ async function installCursorProject(projectRoot) {
     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);
+    const cursorDir = import_node_path5.default.join(projectRoot, ".cursor");
+    const rulesDir = import_node_path5.default.join(cursorDir, "rules");
+    const commandsDir = import_node_path5.default.join(cursorDir, "commands");
+    const routerMdcDest = import_node_path5.default.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "commands");
+    import_node_fs3.default.mkdirSync(rulesDir, { recursive: true });
+    import_node_fs3.default.mkdirSync(commandsDir, { recursive: true });
+    if (import_node_fs3.default.existsSync(routerMdcSource)) {
+      import_node_fs3.default.copyFileSync(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (import_fs4.default.existsSync(cursorCommandsSource)) {
-      const commandFiles = import_fs4.default.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (import_node_fs3.default.existsSync(cursorCommandsSource)) {
+      const commandFiles = import_node_fs3.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);
+        const src = import_node_path5.default.join(cursorCommandsSource, file);
+        const dest = import_node_path5.default.join(commandsDir, file);
+        import_node_fs3.default.copyFileSync(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -1266,7 +1277,7 @@ async function installCursorProject(projectRoot) {
 __name(installCursorProject, "installCursorProject");
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = import_path5.default.join(projectRoot, ".gitignore");
+    const gitignorePath = import_node_path5.default.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -1281,7 +1292,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let fileExists = false;
     try {
-      content = import_fs4.default.readFileSync(gitignorePath, "utf-8");
+      content = import_node_fs3.default.readFileSync(gitignorePath, "utf-8");
       fileExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -1291,8 +1302,12 @@ async function addCursorToGitignore(projectRoot) {
     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");
+    const newContent = fileExists ? `${content.trimEnd()}
+
+${entriesToAdd.join("\n")}
+` : `${entriesToAdd.join("\n")}
+`;
+    import_node_fs3.default.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -1301,13 +1316,13 @@ async function addCursorToGitignore(projectRoot) {
 }
 __name(addCursorToGitignore, "addCursorToGitignore");
 function hasCursorProject(projectRoot) {
-  return import_fs4.default.existsSync(import_path5.default.join(projectRoot, ".cursor"));
+  return import_node_fs3.default.existsSync(import_node_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);
+  const cursorDir = import_node_path5.default.join(projectRoot, ".cursor");
+  const routerPath = import_node_path5.default.join(cursorDir, "rules", "prjct.mdc");
+  return import_node_fs3.default.existsSync(cursorDir) && !import_node_fs3.default.existsSync(routerPath);
 }
 __name(needsCursorRegeneration, "needsCursorRegeneration");
 async function installWindsurfProject(projectRoot) {
@@ -1318,24 +1333,29 @@ async function installWindsurfProject(projectRoot) {
     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);
+    const windsurfDir = import_node_path5.default.join(projectRoot, ".windsurf");
+    const rulesDir = import_node_path5.default.join(windsurfDir, "rules");
+    const workflowsDir = import_node_path5.default.join(windsurfDir, "workflows");
+    const routerDest = import_node_path5.default.join(rulesDir, "prjct.md");
+    const routerSource = import_node_path5.default.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = import_node_path5.default.join(
+      getPackageRoot(),
+      "templates",
+      "windsurf",
+      "workflows"
+    );
+    import_node_fs3.default.mkdirSync(rulesDir, { recursive: true });
+    import_node_fs3.default.mkdirSync(workflowsDir, { recursive: true });
+    if (import_node_fs3.default.existsSync(routerSource)) {
+      import_node_fs3.default.copyFileSync(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (import_fs4.default.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = import_fs4.default.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (import_node_fs3.default.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = import_node_fs3.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);
+        const src = import_node_path5.default.join(windsurfWorkflowsSource, file);
+        const dest = import_node_path5.default.join(workflowsDir, file);
+        import_node_fs3.default.copyFileSync(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -1350,7 +1370,7 @@ async function installWindsurfProject(projectRoot) {
 __name(installWindsurfProject, "installWindsurfProject");
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = import_path5.default.join(projectRoot, ".gitignore");
+    const gitignorePath = import_node_path5.default.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -1365,7 +1385,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let fileExists = false;
     try {
-      content = import_fs4.default.readFileSync(gitignorePath, "utf-8");
+      content = import_node_fs3.default.readFileSync(gitignorePath, "utf-8");
       fileExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -1375,8 +1395,12 @@ async function addWindsurfToGitignore(projectRoot) {
     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");
+    const newContent = fileExists ? `${content.trimEnd()}
+
+${entriesToAdd.join("\n")}
+` : `${entriesToAdd.join("\n")}
+`;
+    import_node_fs3.default.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -1385,34 +1409,34 @@ async function addWindsurfToGitignore(projectRoot) {
 }
 __name(addWindsurfToGitignore, "addWindsurfToGitignore");
 function hasWindsurfProject(projectRoot) {
-  return import_fs4.default.existsSync(import_path5.default.join(projectRoot, ".windsurf"));
+  return import_node_fs3.default.existsSync(import_node_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);
+  const windsurfDir = import_node_path5.default.join(projectRoot, ".windsurf");
+  const routerPath = import_node_path5.default.join(windsurfDir, "rules", "prjct.md");
+  return import_node_fs3.default.existsSync(windsurfDir) && !import_node_fs3.default.existsSync(routerPath);
 }
 __name(needsWindsurfRegeneration, "needsWindsurfRegeneration");
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = import_path5.default.join(import_os4.default.homedir(), ".prjct-cli", "projects");
-    if (!import_fs4.default.existsSync(projectsDir)) {
+    const projectsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".prjct-cli", "projects");
+    if (!import_node_fs3.default.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = import_fs4.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = import_node_fs3.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_fs4.default.existsSync(projectJsonPath)) {
+      const projectJsonPath = import_node_path5.default.join(projectsDir, projectId, "project.json");
+      if (!import_node_fs3.default.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = import_fs4.default.readFileSync(projectJsonPath, "utf8");
+        const content = import_node_fs3.default.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          import_fs4.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          import_node_fs3.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -1433,9 +1457,9 @@ async function migrateProjectsCliVersion() {
 __name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (import_fs4.default.existsSync(settingsPath)) {
+  if (import_node_fs3.default.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(import_fs4.default.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(import_node_fs3.default.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -1443,43 +1467,43 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  import_fs4.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  import_node_fs3.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 __name(ensureStatusLineSettings, "ensureStatusLineSettings");
 async function installStatusLine() {
   try {
-    const claudeDir = import_path5.default.join(import_os4.default.homedir(), ".claude");
-    const settingsPath = import_path5.default.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = import_path5.default.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = import_path5.default.join(import_os4.default.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = import_path5.default.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = import_path5.default.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = import_path5.default.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = import_path5.default.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = import_path5.default.join(prjctStatusLineDir, "config.json");
-    const assetsDir = import_path5.default.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = import_path5.default.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = import_path5.default.join(assetsDir, "themes");
-    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_fs4.default.existsSync(claudeDir)) {
-      import_fs4.default.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".claude");
+    const settingsPath = import_node_path5.default.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = import_node_path5.default.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = import_node_path5.default.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = import_node_path5.default.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = import_node_path5.default.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = import_node_path5.default.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = import_node_path5.default.join(prjctStatusLineDir, "config.json");
+    const assetsDir = import_node_path5.default.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = import_node_path5.default.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = import_node_path5.default.join(assetsDir, "themes");
+    const sourceLibDir = import_node_path5.default.join(assetsDir, "lib");
+    const sourceComponentsDir = import_node_path5.default.join(assetsDir, "components");
+    const sourceConfigPath = import_node_path5.default.join(assetsDir, "default-config.json");
+    if (!import_node_fs3.default.existsSync(claudeDir)) {
+      import_node_fs3.default.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!import_fs4.default.existsSync(prjctStatusLineDir)) {
-      import_fs4.default.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!import_node_fs3.default.existsSync(prjctStatusLineDir)) {
+      import_node_fs3.default.mkdirSync(prjctStatusLineDir, { recursive: true });
     }
-    if (!import_fs4.default.existsSync(prjctThemesDir)) {
-      import_fs4.default.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!import_node_fs3.default.existsSync(prjctThemesDir)) {
+      import_node_fs3.default.mkdirSync(prjctThemesDir, { recursive: true });
     }
-    if (!import_fs4.default.existsSync(prjctLibDir)) {
-      import_fs4.default.mkdirSync(prjctLibDir, { recursive: true });
+    if (!import_node_fs3.default.existsSync(prjctLibDir)) {
+      import_node_fs3.default.mkdirSync(prjctLibDir, { recursive: true });
     }
-    if (!import_fs4.default.existsSync(prjctComponentsDir)) {
-      import_fs4.default.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!import_node_fs3.default.existsSync(prjctComponentsDir)) {
+      import_node_fs3.default.mkdirSync(prjctComponentsDir, { recursive: true });
     }
-    if (import_fs4.default.existsSync(prjctStatusLinePath)) {
-      const existingContent = import_fs4.default.readFileSync(prjctStatusLinePath, "utf8");
+    if (import_node_fs3.default.existsSync(prjctStatusLinePath)) {
+      const existingContent = import_node_fs3.default.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -1487,7 +1511,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          import_fs4.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          import_node_fs3.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -1496,25 +1520,22 @@ async function installStatusLine() {
         return;
       }
     }
-    if (import_fs4.default.existsSync(sourceScript)) {
-      let scriptContent = import_fs4.default.readFileSync(sourceScript, "utf8");
-      scriptContent = scriptContent.replace(
-        /CLI_VERSION="[^"]*"/,
-        `CLI_VERSION="${VERSION}"`
-      );
-      import_fs4.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+    if (import_node_fs3.default.existsSync(sourceScript)) {
+      let scriptContent = import_node_fs3.default.readFileSync(sourceScript, "utf8");
+      scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
+      import_node_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (import_fs4.default.existsSync(sourceThemeDir)) {
-        const themes = import_fs4.default.readdirSync(sourceThemeDir);
+      if (import_node_fs3.default.existsSync(sourceThemeDir)) {
+        const themes = import_node_fs3.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_fs4.default.copyFileSync(src, dest);
+          const src = import_node_path5.default.join(sourceThemeDir, theme);
+          const dest = import_node_path5.default.join(prjctThemesDir, theme);
+          import_node_fs3.default.copyFileSync(src, dest);
         }
       }
-      if (!import_fs4.default.existsSync(prjctConfigPath) && import_fs4.default.existsSync(sourceConfigPath)) {
-        import_fs4.default.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!import_node_fs3.default.existsSync(prjctConfigPath) && import_node_fs3.default.existsSync(sourceConfigPath)) {
+        import_node_fs3.default.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -1549,7 +1570,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      import_fs4.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      import_node_fs3.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -1561,38 +1582,38 @@ echo "prjct"
 }
 __name(installStatusLine, "installStatusLine");
 function installStatusLineModules(sourceDir, destDir) {
-  if (!import_fs4.default.existsSync(sourceDir)) {
+  if (!import_node_fs3.default.existsSync(sourceDir)) {
     return;
   }
-  const files = import_fs4.default.readdirSync(sourceDir);
+  const files = import_node_fs3.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_fs4.default.copyFileSync(src, dest);
-      import_fs4.default.chmodSync(dest, 493);
+      const src = import_node_path5.default.join(sourceDir, file);
+      const dest = import_node_path5.default.join(destDir, file);
+      import_node_fs3.default.copyFileSync(src, dest);
+      import_node_fs3.default.chmodSync(dest, 493);
     }
   }
 }
 __name(installStatusLineModules, "installStatusLineModules");
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (import_fs4.default.existsSync(linkPath)) {
-      const stats = import_fs4.default.lstatSync(linkPath);
+    if (import_node_fs3.default.existsSync(linkPath)) {
+      const stats = import_node_fs3.default.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = import_fs4.default.readlinkSync(linkPath);
+        const existingTarget = import_node_fs3.default.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      import_fs4.default.unlinkSync(linkPath);
+      import_node_fs3.default.unlinkSync(linkPath);
     }
-    import_fs4.default.symlinkSync(targetPath, linkPath);
-  } catch (error) {
+    import_node_fs3.default.symlinkSync(targetPath, linkPath);
+  } catch (_error) {
     try {
-      if (import_fs4.default.existsSync(targetPath)) {
-        import_fs4.default.copyFileSync(targetPath, linkPath);
-        import_fs4.default.chmodSync(linkPath, 493);
+      if (import_node_fs3.default.existsSync(targetPath)) {
+        import_node_fs3.default.copyFileSync(targetPath, linkPath);
+        import_node_fs3.default.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {