aiblueprint-cli 1.1.4 → 1.1.7

package/dist/cli.js

@@ -32360,10 +32360,9 @@ var inquirer = {
 var lib_default = inquirer;
 
 // src/commands/setup.ts
-var import_fs_extra = __toESM(require_lib4(), 1);
-import path2 from "path";
-import os3 from "os";
-import { execSync } from "child_process";
+var import_fs_extra5 = __toESM(require_lib4(), 1);
+import path6 from "path";
+import os5 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -32858,8 +32857,278 @@ var source_default = chalk;
 // src/commands/setup.ts
 import { fileURLToPath } from "url";
 import { dirname } from "path";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
+
+// src/commands/setup/shell-shortcuts.ts
+var import_fs_extra = __toESM(require_lib4(), 1);
+import path2 from "path";
+import os3 from "os";
+async function setupShellShortcuts() {
+  try {
+    const platform = os3.platform();
+    let shellConfigFile;
+    if (platform === "darwin") {
+      shellConfigFile = path2.join(os3.homedir(), ".zshenv");
+    } else if (platform === "linux") {
+      const shell = process.env.SHELL || "";
+      if (shell.includes("zsh")) {
+        shellConfigFile = path2.join(os3.homedir(), ".zshrc");
+      } else {
+        shellConfigFile = path2.join(os3.homedir(), ".bashrc");
+      }
+    } else {
+      console.log(source_default.yellow("Shell shortcuts are only supported on macOS and Linux"));
+      return;
+    }
+    const aliases = `
+# AIBlueprint Claude Code aliases
+alias cc="claude --dangerously-skip-permissions"
+alias ccc="claude --dangerously-skip-permissions -c"
+`;
+    const existingContent = await import_fs_extra.default.readFile(shellConfigFile, "utf-8").catch(() => "");
+    if (!existingContent.includes("AIBlueprint Claude Code aliases")) {
+      await import_fs_extra.default.appendFile(shellConfigFile, aliases);
+    }
+  } catch (error) {
+    console.error(source_default.red("Error setting up shell shortcuts:"), error);
+    throw error;
+  }
+}
+
+// src/commands/setup/symlinks.ts
+var import_fs_extra2 = __toESM(require_lib4(), 1);
+import path3 from "path";
+import os4 from "os";
+async function getToolPaths(tool, customFolder) {
+  let baseDir;
+  switch (tool) {
+    case "claude-code":
+      baseDir = customFolder ? path3.resolve(customFolder) : path3.join(os4.homedir(), ".claude");
+      return {
+        baseDir,
+        commandsPath: path3.join(baseDir, "commands"),
+        agentsPath: path3.join(baseDir, "agents")
+      };
+    case "codex":
+      baseDir = customFolder ? path3.resolve(customFolder) : path3.join(os4.homedir(), ".codex");
+      return {
+        baseDir,
+        commandsPath: path3.join(baseDir, "prompts")
+      };
+    case "opencode":
+      baseDir = customFolder ? path3.resolve(customFolder) : path3.join(os4.homedir(), ".config", "opencode");
+      return {
+        baseDir,
+        commandsPath: path3.join(baseDir, "command")
+      };
+    case "factoryai":
+      baseDir = customFolder ? path3.resolve(customFolder) : path3.join(os4.homedir(), ".factory");
+      return {
+        baseDir,
+        commandsPath: path3.join(baseDir, "commands"),
+        agentsPath: path3.join(baseDir, "droids")
+      };
+    default:
+      throw new Error(`Unknown tool type: ${tool}`);
+  }
+}
+async function createSymlink(sourcePath, targetPath, options = {}) {
+  try {
+    const sourceExists = await import_fs_extra2.default.pathExists(sourcePath);
+    if (!sourceExists) {
+      console.log(source_default.yellow(`  Source path ${sourcePath} does not exist. Skipping symlink creation...`));
+      return false;
+    }
+    const targetDir = path3.dirname(targetPath);
+    await import_fs_extra2.default.ensureDir(targetDir);
+    const targetExists = await import_fs_extra2.default.pathExists(targetPath);
+    if (targetExists) {
+      const stat = await import_fs_extra2.default.lstat(targetPath);
+      if (stat.isSymbolicLink()) {
+        await import_fs_extra2.default.remove(targetPath);
+      } else {
+        console.log(source_default.yellow(options.skipMessage || `  ${targetPath} already exists and is not a symlink. Skipping...`));
+        return false;
+      }
+    }
+    await import_fs_extra2.default.symlink(sourcePath, targetPath);
+    return true;
+  } catch (error) {
+    console.error(source_default.red(options.errorPrefix || "Error creating symlink:"), error);
+    throw error;
+  }
+}
+async function setupCodexSymlink(claudeDir, customCodexFolder, customClaudeCodeFolder) {
+  try {
+    let codexDir;
+    if (customCodexFolder) {
+      codexDir = path3.resolve(customCodexFolder);
+    } else if (customClaudeCodeFolder) {
+      const parentDir = path3.dirname(claudeDir);
+      codexDir = path3.join(parentDir, "codex");
+    } else {
+      codexDir = path3.join(os4.homedir(), ".codex");
+    }
+    const promptsPath = path3.join(codexDir, "prompts");
+    const commandsPath = path3.join(claudeDir, "commands");
+    await createSymlink(commandsPath, promptsPath, {
+      skipMessage: "  ~/.codex/prompts already exists and is not a symlink. Skipping...",
+      errorPrefix: "Error setting up Codex symlink:"
+    });
+  } catch (error) {
+    console.error(source_default.red("Error setting up Codex symlink:"), error);
+  }
+}
+async function setupOpenCodeSymlink(claudeDir, customOpenCodeFolder, customClaudeCodeFolder) {
+  try {
+    let openCodeDir;
+    if (customOpenCodeFolder) {
+      openCodeDir = path3.resolve(customOpenCodeFolder);
+    } else if (customClaudeCodeFolder) {
+      const parentDir = path3.dirname(claudeDir);
+      openCodeDir = path3.join(parentDir, ".opencode");
+    } else {
+      openCodeDir = path3.join(os4.homedir(), ".config", "opencode");
+    }
+    const commandPath = path3.join(openCodeDir, "command");
+    const commandsPath = path3.join(claudeDir, "commands");
+    await createSymlink(commandsPath, commandPath, {
+      skipMessage: "  ~/.config/opencode/command already exists and is not a symlink. Skipping...",
+      errorPrefix: "Error setting up OpenCode symlink:"
+    });
+  } catch (error) {
+    console.error(source_default.red("Error setting up OpenCode symlink:"), error);
+  }
+}
+
+// src/commands/setup/dependencies.ts
+import { execSync } from "child_process";
+async function checkAndInstallDependencies() {
+  const checkCommand = (cmd) => {
+    try {
+      execSync(`which ${cmd}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!checkCommand("bun")) {
+    console.log(source_default.yellow(`
+  Installing bun...`));
+    try {
+      execSync("npm install -g bun", { stdio: "inherit" });
+    } catch (error) {
+      console.log(source_default.red("  Failed to install bun. Please install it manually: npm install -g bun"));
+    }
+  }
+  if (!checkCommand("ccusage")) {
+    console.log(source_default.yellow(`
+  Installing ccusage...`));
+    try {
+      execSync("npm install -g ccusage", { stdio: "inherit" });
+    } catch (error) {
+      console.log(source_default.red("  Failed to install ccusage. Please install it manually: npm install -g ccusage"));
+    }
+  }
+}
+
+// src/commands/setup/settings.ts
+var import_fs_extra3 = __toESM(require_lib4(), 1);
+import path4 from "path";
+async function updateSettings(options, claudeDir) {
+  const settingsPath = path4.join(claudeDir, "settings.json");
+  let settings = {};
+  try {
+    const existingSettings = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+    settings = JSON.parse(existingSettings);
+  } catch {
+  }
+  if (options.customStatusline) {
+    if (settings.statusLine) {
+      const confirmAnswer = await lib_default.prompt([
+        {
+          type: "confirm",
+          name: "replace",
+          message: "You already have a statusLine configuration. Replace it?"
+        }
+      ]);
+      if (!confirmAnswer.replace) {
+        console.log(source_default.yellow("  Keeping existing statusLine configuration"));
+      } else {
+        settings.statusLine = {
+          type: "command",
+          command: `bash ${path4.join(claudeDir, "scripts/statusline-ccusage.sh")}`,
+          padding: 0
+        };
+      }
+    } else {
+      settings.statusLine = {
+        type: "command",
+        command: `bash ${path4.join(claudeDir, "scripts/statusline-ccusage.sh")}`,
+        padding: 0
+      };
+    }
+  }
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (options.commandValidation) {
+    if (!settings.hooks.PreToolUse) {
+      settings.hooks.PreToolUse = [];
+    }
+    const bashHook = {
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: `bun ${path4.join(claudeDir, "scripts/validate-command.js")}`
+        }
+      ]
+    };
+    const existingBashHook = settings.hooks.PreToolUse.find((h) => h.matcher === "Bash");
+    if (!existingBashHook) {
+      settings.hooks.PreToolUse.push(bashHook);
+    }
+  }
+  if (options.notificationSounds) {
+    if (!settings.hooks.Stop) {
+      settings.hooks.Stop = [];
+    }
+    const stopHook = {
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: `afplay -v 0.1 ${path4.join(claudeDir, "song/finish.mp3")}`
+        }
+      ]
+    };
+    const existingStopHook = settings.hooks.Stop.find((h) => h.hooks?.some((hook) => hook.command?.includes("finish.mp3")));
+    if (!existingStopHook) {
+      settings.hooks.Stop.push(stopHook);
+    }
+    if (!settings.hooks.Notification) {
+      settings.hooks.Notification = [];
+    }
+    const notificationHook = {
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: `afplay -v 0.1 ${path4.join(claudeDir, "song/need-human.mp3")}`
+        }
+      ]
+    };
+    const existingNotificationHook = settings.hooks.Notification.find((h) => h.hooks?.some((hook) => hook.command?.includes("need-human.mp3")));
+    if (!existingNotificationHook) {
+      settings.hooks.Notification.push(notificationHook);
+    }
+  }
+  await import_fs_extra3.default.writeJson(settingsPath, settings, { spaces: 2 });
+}
+
+// src/commands/setup/utils.ts
+var import_fs_extra4 = __toESM(require_lib4(), 1);
+import path5 from "path";
 
 class SimpleSpinner {
   message = "";
@@ -32880,8 +33149,8 @@ async function downloadFromGitHub(relativePath, targetPath) {
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra.default.ensureDir(path2.dirname(targetPath));
-    await import_fs_extra.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra4.default.ensureDir(path5.dirname(targetPath));
+    await import_fs_extra4.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     return false;
@@ -32898,10 +33167,10 @@ async function downloadDirectoryFromGitHub(dirPath, targetDir) {
     if (!Array.isArray(files)) {
       return false;
     }
-    await import_fs_extra.default.ensureDir(targetDir);
+    await import_fs_extra4.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = `${dirPath}/${file.name}`;
-      const targetPath = path2.join(targetDir, file.name);
+      const targetPath = path5.join(targetDir, file.name);
       if (file.type === "file") {
         await downloadFromGitHub(relativePath, targetPath);
       } else if (file.type === "dir") {
@@ -32913,7 +33182,18 @@ async function downloadDirectoryFromGitHub(dirPath, targetDir) {
     return false;
   }
 }
-async function setupCommand(customFolder, skipInteractive) {
+
+// src/commands/setup.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var GITHUB_RAW_BASE2 = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
+async function setupCommand(params = {}) {
+  const {
+    claudeCodeFolder: customClaudeCodeFolder,
+    codexFolder: customCodexFolder,
+    openCodeFolder: customOpenCodeFolder,
+    skipInteractive
+  } = params;
   try {
     console.log(source_default.blue.bold(`
 \uD83D\uDE80 AIBlueprint Claude Code Setup
@@ -32921,23 +33201,73 @@ async function setupCommand(customFolder, skipInteractive) {
     console.log(source_default.bgBlue(" Setting up your Claude Code environment "));
     let features;
     if (skipInteractive) {
-      features = ["shellShortcuts", "commandValidation", "customStatusline", "aiblueprintCommands", "aiblueprintAgents", "outputStyles", "notificationSounds"];
+      features = [
+        "shellShortcuts",
+        "commandValidation",
+        "customStatusline",
+        "aiblueprintCommands",
+        "aiblueprintAgents",
+        "outputStyles",
+        "notificationSounds",
+        "codexSymlink",
+        "openCodeSymlink"
+      ];
       console.log(source_default.green("✓ Installing all features (--skip mode)"));
     } else {
-      const answers = await lib_default.prompt([{
-        type: "checkbox",
-        name: "features",
-        message: "Which features would you like to install?",
-        choices: [
-          { value: "shellShortcuts", name: "Shell shortcuts (cc, ccc aliases) - Quick access to Claude Code", checked: true },
-          { value: "commandValidation", name: "Command validation - Security hook for bash commands", checked: true },
-          { value: "customStatusline", name: "Custom statusline - Shows git, costs, tokens info", checked: true },
-          { value: "aiblueprintCommands", name: "AIBlueprint commands - Pre-configured command templates", checked: true },
-          { value: "aiblueprintAgents", name: "AIBlueprint agents - Specialized AI agents", checked: true },
-          { value: "outputStyles", name: "Output styles - Custom output formatting", checked: true },
-          { value: "notificationSounds", name: "Notification sounds - Audio alerts for events", checked: true }
-        ]
-      }]);
+      const answers = await lib_default.prompt([
+        {
+          type: "checkbox",
+          name: "features",
+          message: "Which features would you like to install?",
+          choices: [
+            {
+              value: "shellShortcuts",
+              name: "Shell shortcuts (cc, ccc aliases) - Quick access to Claude Code",
+              checked: true
+            },
+            {
+              value: "commandValidation",
+              name: "Command validation - Security hook for bash commands",
+              checked: true
+            },
+            {
+              value: "customStatusline",
+              name: "Custom statusline - Shows git, costs, tokens info",
+              checked: true
+            },
+            {
+              value: "aiblueprintCommands",
+              name: "AIBlueprint commands - Pre-configured command templates",
+              checked: true
+            },
+            {
+              value: "aiblueprintAgents",
+              name: "AIBlueprint agents - Specialized AI agents",
+              checked: true
+            },
+            {
+              value: "outputStyles",
+              name: "Output styles - Custom output formatting",
+              checked: true
+            },
+            {
+              value: "notificationSounds",
+              name: "Notification sounds - Audio alerts for events",
+              checked: true
+            },
+            {
+              value: "codexSymlink",
+              name: "Codex symlink - Link commands to ~/.codex/prompts",
+              checked: false
+            },
+            {
+              value: "openCodeSymlink",
+              name: "OpenCode symlink - Link commands to ~/.config/opencode/command",
+              checked: false
+            }
+          ]
+        }
+      ]);
       features = answers.features;
       if (!features || features.length === 0) {
         console.log(source_default.yellow("Setup cancelled - no features selected"));
@@ -32951,15 +33281,17 @@ async function setupCommand(customFolder, skipInteractive) {
       aiblueprintCommands: features.includes("aiblueprintCommands"),
       aiblueprintAgents: features.includes("aiblueprintAgents"),
       outputStyles: features.includes("outputStyles"),
-      notificationSounds: features.includes("notificationSounds")
+      notificationSounds: features.includes("notificationSounds"),
+      codexSymlink: features.includes("codexSymlink"),
+      openCodeSymlink: features.includes("openCodeSymlink")
     };
     const s = new SimpleSpinner;
-    const claudeDir = customFolder ? path2.resolve(customFolder) : path2.join(os3.homedir(), ".claude");
+    const claudeDir = customClaudeCodeFolder ? path6.resolve(customClaudeCodeFolder) : path6.join(os5.homedir(), ".claude");
     console.log(source_default.gray(`Installing to: ${claudeDir}`));
-    await import_fs_extra.default.ensureDir(claudeDir);
+    await import_fs_extra5.default.ensureDir(claudeDir);
     let useGitHub = true;
     let sourceDir;
-    const testUrl = `${GITHUB_RAW_BASE}/scripts/validate-command.js`;
+    const testUrl = `${GITHUB_RAW_BASE2}/scripts/validate-command.js`;
     try {
       const testResponse = await fetch(testUrl);
       useGitHub = testResponse.ok;
@@ -32969,14 +33301,14 @@ async function setupCommand(customFolder, skipInteractive) {
     if (!useGitHub) {
       const currentDir = process.cwd();
       const possiblePaths = [
-        path2.join(currentDir, "claude-code-config"),
-        path2.join(__dirname2, "../../claude-code-config"),
-        path2.join(__dirname2, "../claude-code-config"),
-        path2.join(path2.dirname(process.argv[1]), "../claude-code-config")
+        path6.join(currentDir, "claude-code-config"),
+        path6.join(__dirname2, "../../claude-code-config"),
+        path6.join(__dirname2, "../claude-code-config"),
+        path6.join(path6.dirname(process.argv[1]), "../claude-code-config")
       ];
       sourceDir = possiblePaths.find((p) => {
         try {
-          return import_fs_extra.default.existsSync(p);
+          return import_fs_extra5.default.existsSync(p);
         } catch {
           return false;
         }
@@ -32996,53 +33328,68 @@ async function setupCommand(customFolder, skipInteractive) {
     if (options.commandValidation || options.customStatusline || options.notificationSounds) {
       s.start("Setting up scripts");
       if (useGitHub) {
-        const scriptsDir = path2.join(claudeDir, "scripts");
-        await import_fs_extra.default.ensureDir(scriptsDir);
-        const scriptFiles = ["validate-command.js", "statusline-ccusage.sh", "validate-command.readme.md", "statusline.readme.md"];
+        const scriptsDir = path6.join(claudeDir, "scripts");
+        await import_fs_extra5.default.ensureDir(scriptsDir);
+        const scriptFiles = [
+          "validate-command.js",
+          "statusline-ccusage.sh",
+          "validate-command.readme.md",
+          "statusline.readme.md"
+        ];
         for (const file of scriptFiles) {
-          await downloadFromGitHub(`scripts/${file}`, path2.join(scriptsDir, file));
+          await downloadFromGitHub(`scripts/${file}`, path6.join(scriptsDir, file));
         }
       } else {
-        await import_fs_extra.default.copy(path2.join(sourceDir, "scripts"), path2.join(claudeDir, "scripts"), { overwrite: true });
+        await import_fs_extra5.default.copy(path6.join(sourceDir, "scripts"), path6.join(claudeDir, "scripts"), { overwrite: true });
       }
       s.stop("Scripts installed");
     }
     if (options.aiblueprintCommands) {
       s.start("Setting up AIBlueprint commands");
       if (useGitHub) {
-        await downloadDirectoryFromGitHub("commands", path2.join(claudeDir, "commands"));
+        await downloadDirectoryFromGitHub("commands", path6.join(claudeDir, "commands"));
       } else {
-        await import_fs_extra.default.copy(path2.join(sourceDir, "commands"), path2.join(claudeDir, "commands"), { overwrite: true });
+        await import_fs_extra5.default.copy(path6.join(sourceDir, "commands"), path6.join(claudeDir, "commands"), { overwrite: true });
       }
       s.stop("Commands installed");
     }
+    if (options.codexSymlink && options.aiblueprintCommands) {
+      s.start("Setting up Codex symlink");
+      await setupCodexSymlink(claudeDir, customCodexFolder, customClaudeCodeFolder);
+      s.stop("Codex symlink configured");
+    }
+    if (options.openCodeSymlink && options.aiblueprintCommands) {
+      s.start("Setting up OpenCode symlink");
+      await setupOpenCodeSymlink(claudeDir, customOpenCodeFolder, customClaudeCodeFolder);
+      s.stop("OpenCode symlink configured");
+    }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
       if (useGitHub) {
-        await downloadDirectoryFromGitHub("agents", path2.join(claudeDir, "agents"));
+        await downloadDirectoryFromGitHub("agents", path6.join(claudeDir, "agents"));
       } else {
-        await import_fs_extra.default.copy(path2.join(sourceDir, "agents"), path2.join(claudeDir, "agents"), { overwrite: true });
+        await import_fs_extra5.default.copy(path6.join(sourceDir, "agents"), path6.join(claudeDir, "agents"), { overwrite: true });
       }
       s.stop("Agents installed");
     }
     if (options.outputStyles) {
       s.start("Setting up output styles");
       if (useGitHub) {
-        await downloadDirectoryFromGitHub("output-styles", path2.join(claudeDir, "output-styles"));
+        await downloadDirectoryFromGitHub("output-styles", path6.join(claudeDir, "output-styles"));
       } else {
-        await import_fs_extra.default.copy(path2.join(sourceDir, "output-styles"), path2.join(claudeDir, "output-styles"), { overwrite: true });
+        await import_fs_extra5.default.copy(path6.join(sourceDir, "output-styles"), path6.join(claudeDir, "output-styles"), { overwrite: true });
       }
       s.stop("Output styles installed");
     }
     if (options.notificationSounds) {
       s.start("Setting up notification sounds");
       if (useGitHub) {
-        const songDir = path2.join(claudeDir, "song");
-        await import_fs_extra.default.ensureDir(songDir);
-        await downloadFromGitHub("song/finish.mp3", path2.join(songDir, "finish.mp3"));
-        await downloadFromGitHub("song/need-human.mp3", path2.join(songDir, "need-human.mp3"));
+        const songDir = path6.join(claudeDir, "song");
+        await import_fs_extra5.default.ensureDir(songDir);
+        await downloadFromGitHub("song/finish.mp3", path6.join(songDir, "finish.mp3"));
+        await downloadFromGitHub("song/need-human.mp3", path6.join(songDir, "need-human.mp3"));
       } else {
-        await import_fs_extra.default.copy(path2.join(sourceDir, "song"), path2.join(claudeDir, "song"), { overwrite: true });
+        await import_fs_extra5.default.copy(path6.join(sourceDir, "song"), path6.join(claudeDir, "song"), { overwrite: true });
       }
       s.stop("Notification sounds installed");
     }
@@ -33070,164 +33417,16 @@ Next steps:`));
     process.exit(1);
   }
 }
-async function setupShellShortcuts() {
-  try {
-    const platform = os3.platform();
-    let shellConfigFile;
-    if (platform === "darwin") {
-      shellConfigFile = path2.join(os3.homedir(), ".zshenv");
-    } else if (platform === "linux") {
-      const shell = process.env.SHELL || "";
-      if (shell.includes("zsh")) {
-        shellConfigFile = path2.join(os3.homedir(), ".zshrc");
-      } else {
-        shellConfigFile = path2.join(os3.homedir(), ".bashrc");
-      }
-    } else {
-      console.log(source_default.yellow("Shell shortcuts are only supported on macOS and Linux"));
-      return;
-    }
-    const aliases = `
-# AIBlueprint Claude Code aliases
-alias cc="claude --dangerously-skip-permissions"
-alias ccc="claude --dangerously-skip-permissions -c"
-`;
-    const existingContent = await import_fs_extra.default.readFile(shellConfigFile, "utf-8").catch(() => "");
-    if (!existingContent.includes("AIBlueprint Claude Code aliases")) {
-      await import_fs_extra.default.appendFile(shellConfigFile, aliases);
-    }
-  } catch (error) {
-    console.error(source_default.red("Error setting up shell shortcuts:"), error);
-    throw error;
-  }
-}
-async function checkAndInstallDependencies() {
-  const checkCommand = (cmd) => {
-    try {
-      execSync(`which ${cmd}`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  if (!checkCommand("bun")) {
-    console.log(source_default.yellow(`
-  Installing bun...`));
-    try {
-      execSync("npm install -g bun", { stdio: "inherit" });
-    } catch (error) {
-      console.log(source_default.red("  Failed to install bun. Please install it manually: npm install -g bun"));
-    }
-  }
-  if (!checkCommand("ccusage")) {
-    console.log(source_default.yellow(`
-  Installing ccusage...`));
-    try {
-      execSync("npm install -g ccusage", { stdio: "inherit" });
-    } catch (error) {
-      console.log(source_default.red("  Failed to install ccusage. Please install it manually: npm install -g ccusage"));
-    }
-  }
-}
-async function updateSettings(options, claudeDir) {
-  const settingsPath = path2.join(claudeDir, "settings.json");
-  let settings = {};
-  try {
-    const existingSettings = await import_fs_extra.default.readFile(settingsPath, "utf-8");
-    settings = JSON.parse(existingSettings);
-  } catch {
-  }
-  if (options.customStatusline) {
-    if (settings.statusLine) {
-      const confirmAnswer = await lib_default.prompt([{
-        type: "confirm",
-        name: "replace",
-        message: "You already have a statusLine configuration. Replace it?"
-      }]);
-      if (!confirmAnswer.replace) {
-        console.log(source_default.yellow("  Keeping existing statusLine configuration"));
-      } else {
-        settings.statusLine = {
-          type: "command",
-          command: `bash ${path2.join(claudeDir, "scripts/statusline-ccusage.sh")}`,
-          padding: 0
-        };
-      }
-    } else {
-      settings.statusLine = {
-        type: "command",
-        command: `bash ${path2.join(claudeDir, "scripts/statusline-ccusage.sh")}`,
-        padding: 0
-      };
-    }
-  }
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (options.commandValidation) {
-    if (!settings.hooks.PreToolUse) {
-      settings.hooks.PreToolUse = [];
-    }
-    const bashHook = {
-      matcher: "Bash",
-      hooks: [
-        {
-          type: "command",
-          command: `bun ${path2.join(claudeDir, "scripts/validate-command.js")}`
-        }
-      ]
-    };
-    const existingBashHook = settings.hooks.PreToolUse.find((h) => h.matcher === "Bash");
-    if (!existingBashHook) {
-      settings.hooks.PreToolUse.push(bashHook);
-    }
-  }
-  if (options.notificationSounds) {
-    if (!settings.hooks.Stop) {
-      settings.hooks.Stop = [];
-    }
-    const stopHook = {
-      matcher: "",
-      hooks: [
-        {
-          type: "command",
-          command: `afplay -v 0.1 ${path2.join(claudeDir, "song/finish.mp3")}`
-        }
-      ]
-    };
-    const existingStopHook = settings.hooks.Stop.find((h) => h.hooks?.some((hook) => hook.command?.includes("finish.mp3")));
-    if (!existingStopHook) {
-      settings.hooks.Stop.push(stopHook);
-    }
-    if (!settings.hooks.Notification) {
-      settings.hooks.Notification = [];
-    }
-    const notificationHook = {
-      matcher: "",
-      hooks: [
-        {
-          type: "command",
-          command: `afplay -v 0.1 ${path2.join(claudeDir, "song/need-human.mp3")}`
-        }
-      ]
-    };
-    const existingNotificationHook = settings.hooks.Notification.find((h) => h.hooks?.some((hook) => hook.command?.includes("need-human.mp3")));
-    if (!existingNotificationHook) {
-      settings.hooks.Notification.push(notificationHook);
-    }
-  }
-  await import_fs_extra.default.writeJson(settingsPath, settings, { spaces: 2 });
-}
 
 // src/commands/addHook.ts
-var import_fs_extra5 = __toESM(require_lib4(), 1);
-import path6 from "path";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import path10 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname3 } from "path";
 
 // src/utils/claude-config.ts
-var import_fs_extra2 = __toESM(require_lib4(), 1);
-import path3 from "path";
+var import_fs_extra6 = __toESM(require_lib4(), 1);
+import path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2 } from "path";
 var __filename3 = fileURLToPath2(import.meta.url);
@@ -33258,14 +33457,14 @@ function parseYamlFrontmatter(content) {
 }
 function getLocalConfigPaths(subDir) {
   return [
-    path3.join(__dirname3, `../claude-code-config/${subDir}`),
-    path3.join(__dirname3, `../../claude-code-config/${subDir}`)
+    path7.join(__dirname3, `../claude-code-config/${subDir}`),
+    path7.join(__dirname3, `../../claude-code-config/${subDir}`)
   ];
 }
 async function findLocalConfigDir(subDir) {
   const possiblePaths = getLocalConfigPaths(subDir);
   for (const testPath of possiblePaths) {
-    if (await import_fs_extra2.default.pathExists(testPath)) {
+    if (await import_fs_extra6.default.pathExists(testPath)) {
       return testPath;
     }
   }
@@ -33276,26 +33475,26 @@ async function getTargetDirectory(options) {
     return options.folder;
   }
   const cwd = process.cwd();
-  const localClaudeDir = path3.join(cwd, ".claude");
-  const isGitRepo = await import_fs_extra2.default.pathExists(path3.join(cwd, ".git"));
-  const hasClaudeConfig = await import_fs_extra2.default.pathExists(localClaudeDir);
+  const localClaudeDir = path7.join(cwd, ".claude");
+  const isGitRepo = await import_fs_extra6.default.pathExists(path7.join(cwd, ".git"));
+  const hasClaudeConfig = await import_fs_extra6.default.pathExists(localClaudeDir);
   if (isGitRepo || hasClaudeConfig) {
     return localClaudeDir;
   }
-  return path3.join(process.env.HOME || process.env.USERPROFILE || "~", ".claude");
+  return path7.join(process.env.HOME || process.env.USERPROFILE || "~", ".claude");
 }
 
 // src/utils/file-installer.ts
-var import_fs_extra4 = __toESM(require_lib4(), 1);
-import path5 from "path";
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import path9 from "path";
 
 // src/utils/github.ts
-var import_fs_extra3 = __toESM(require_lib4(), 1);
-import path4 from "path";
-var GITHUB_RAW_BASE2 = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
+var import_fs_extra7 = __toESM(require_lib4(), 1);
+import path8 from "path";
+var GITHUB_RAW_BASE3 = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
 async function downloadFromGitHub2(relativePath) {
   try {
-    const url = `${GITHUB_RAW_BASE2}/${relativePath}`;
+    const url = `${GITHUB_RAW_BASE3}/${relativePath}`;
     const response = await fetch(url);
     if (!response.ok) {
       return null;
@@ -33320,7 +33519,7 @@ async function listFilesFromGitHub(dirPath) {
 }
 async function isGitHubAvailable() {
   try {
-    const testUrl = `${GITHUB_RAW_BASE2}/commands/commit.md`;
+    const testUrl = `${GITHUB_RAW_BASE3}/commands/commit.md`;
     const testResponse = await fetch(testUrl);
     return testResponse.ok;
   } catch {
@@ -33330,8 +33529,8 @@ async function isGitHubAvailable() {
 async function downloadAndWriteFile(relativePath, targetPath) {
   const content = await downloadFromGitHub2(relativePath);
   if (content) {
-    await import_fs_extra3.default.ensureDir(path4.dirname(targetPath));
-    await import_fs_extra3.default.writeFile(targetPath, content);
+    await import_fs_extra7.default.ensureDir(path8.dirname(targetPath));
+    await import_fs_extra7.default.writeFile(targetPath, content);
     return true;
   }
   return false;
@@ -33340,7 +33539,7 @@ async function downloadAndWriteFile(relativePath, targetPath) {
 // src/utils/file-installer.ts
 async function installFileWithGitHubFallback(options) {
   const { sourceDir, targetPath, fileName } = options;
-  await import_fs_extra4.default.ensureDir(path5.dirname(targetPath));
+  await import_fs_extra8.default.ensureDir(path9.dirname(targetPath));
   const useGitHub = options.useGitHub ?? await isGitHubAvailable();
   if (useGitHub) {
     const relativePath = `${sourceDir}/${fileName}`;
@@ -33354,11 +33553,11 @@ async function installFileWithGitHubFallback(options) {
   if (!localConfigDir) {
     throw new Error(`Neither GitHub nor local ${sourceDir} directory found`);
   }
-  const localFilePath = path5.join(localConfigDir, fileName);
-  if (!await import_fs_extra4.default.pathExists(localFilePath)) {
+  const localFilePath = path9.join(localConfigDir, fileName);
+  if (!await import_fs_extra8.default.pathExists(localFilePath)) {
     throw new Error(`File not found: ${fileName}`);
   }
-  await import_fs_extra4.default.copy(localFilePath, targetPath);
+  await import_fs_extra8.default.copy(localFilePath, targetPath);
 }
 async function getFileContentWithGitHubFallback(sourceDir, fileName) {
   const useGitHub = await isGitHubAvailable();
@@ -33373,11 +33572,11 @@ async function getFileContentWithGitHubFallback(sourceDir, fileName) {
   if (!localConfigDir) {
     throw new Error(`Neither GitHub nor local ${sourceDir} directory found`);
   }
-  const localFilePath = path5.join(localConfigDir, fileName);
-  if (!await import_fs_extra4.default.pathExists(localFilePath)) {
+  const localFilePath = path9.join(localConfigDir, fileName);
+  if (!await import_fs_extra8.default.pathExists(localFilePath)) {
     throw new Error(`File not found: ${fileName}`);
   }
-  return await import_fs_extra4.default.readFile(localFilePath, "utf-8");
+  return await import_fs_extra8.default.readFile(localFilePath, "utf-8");
 }
 
 // src/commands/addHook.ts
@@ -33417,10 +33616,10 @@ async function addHookCommand(hookType, options) {
   const s = new SimpleSpinner2;
   const targetDir = await getTargetDirectory(options);
   const claudeDir = targetDir;
-  const hooksDir = path6.join(claudeDir, "hooks");
-  const hookFilePath = path6.join(hooksDir, hook.hookFile);
-  const settingsPath = path6.join(claudeDir, "settings.json");
-  if (await import_fs_extra5.default.pathExists(hookFilePath)) {
+  const hooksDir = path10.join(claudeDir, "hooks");
+  const hookFilePath = path10.join(hooksDir, hook.hookFile);
+  const settingsPath = path10.join(claudeDir, "settings.json");
+  if (await import_fs_extra9.default.pathExists(hookFilePath)) {
     const overwriteAnswer = await lib_default.prompt([{
       type: "confirm",
       name: "overwrite",
@@ -33433,18 +33632,18 @@ async function addHookCommand(hookType, options) {
   }
   try {
     s.start("Installing hook...");
-    await import_fs_extra5.default.ensureDir(hooksDir);
+    await import_fs_extra9.default.ensureDir(hooksDir);
     await installFileWithGitHubFallback({
       sourceDir: "hooks",
       targetPath: hookFilePath,
       fileName: hook.hookFile
     });
-    await import_fs_extra5.default.chmod(hookFilePath, 493);
+    await import_fs_extra9.default.chmod(hookFilePath, 493);
     s.stop("Hook file installed");
     s.start("Updating settings.json...");
     let settings = {};
     try {
-      const existingSettings = await import_fs_extra5.default.readFile(settingsPath, "utf-8");
+      const existingSettings = await import_fs_extra9.default.readFile(settingsPath, "utf-8");
       settings = JSON.parse(existingSettings);
     } catch {
       settings = {};
@@ -33481,7 +33680,7 @@ async function addHookCommand(hookType, options) {
     } else {
       settings.hooks[hook.event].push(newHook);
     }
-    await import_fs_extra5.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+    await import_fs_extra9.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
     s.stop("Settings updated");
     console.log(source_default.green("✨ Hook installed successfully!"));
     console.log(source_default.gray(`
@@ -33500,8 +33699,8 @@ The hook will run automatically when you edit TypeScript files with Claude Code.
 }
 
 // src/commands/addCommand.ts
-var import_fs_extra6 = __toESM(require_lib4(), 1);
-import path7 from "path";
+var import_fs_extra10 = __toESM(require_lib4(), 1);
+import path11 from "path";
 class SimpleSpinner3 {
   message = "";
   start(message) {
@@ -33518,12 +33717,13 @@ async function discoverAvailableCommands() {
   let mdFiles = [];
   if (useGitHub) {
     mdFiles = (await listFilesFromGitHub("commands")).filter((file) => file.endsWith(".md"));
-  } else {
+  }
+  if (mdFiles.length === 0) {
     const commandsDir = await findLocalConfigDir("commands");
     if (!commandsDir) {
       throw new Error("Commands directory not found");
     }
-    const files = await import_fs_extra6.default.readdir(commandsDir);
+    const files = await import_fs_extra10.default.readdir(commandsDir);
     mdFiles = files.filter((file) => file.endsWith(".md"));
   }
   for (const file of mdFiles) {
@@ -33584,9 +33784,9 @@ async function addCommandCommand(commandName, options = {}) {
   if (options.folder) {
     console.log(source_default.gray(`Using custom folder: ${targetDir}`));
   }
-  const commandsDir = path7.join(targetDir, "commands");
-  const commandFilePath = path7.join(commandsDir, command.commandFile);
-  if (await import_fs_extra6.default.pathExists(commandFilePath)) {
+  const commandsDir = path11.join(targetDir, "commands");
+  const commandFilePath = path11.join(commandsDir, command.commandFile);
+  if (await import_fs_extra10.default.pathExists(commandFilePath)) {
     const overwriteAnswer = await lib_default.prompt([{
       type: "confirm",
       name: "overwrite",
@@ -33626,6 +33826,172 @@ The command will be available immediately in Claude Code.`));
   }
 }
 
+// src/commands/symlink.ts
+var TOOLS = [
+  {
+    name: "Claude Code",
+    value: "claude-code",
+    supportsCommands: true,
+    supportsAgents: true
+  },
+  {
+    name: "Codex",
+    value: "codex",
+    supportsCommands: true,
+    supportsAgents: false
+  },
+  {
+    name: "OpenCode",
+    value: "opencode",
+    supportsCommands: true,
+    supportsAgents: false
+  },
+  {
+    name: "FactoryAI",
+    value: "factoryai",
+    supportsCommands: true,
+    supportsAgents: true
+  }
+];
+async function symlinkCommand(params = {}) {
+  try {
+    console.log(source_default.blue.bold(`
+\uD83D\uDD17 Symlink Manager
+`));
+    console.log(source_default.gray("Create symlinks between different CLI tool configurations"));
+    const sourceAnswer = await lib_default.prompt([
+      {
+        type: "list",
+        name: "source",
+        message: "Select source tool:",
+        choices: TOOLS.map((tool) => ({
+          name: tool.name,
+          value: tool.value
+        }))
+      }
+    ]);
+    const sourceTool = sourceAnswer.source;
+    const sourceConfig = TOOLS.find((t) => t.value === sourceTool);
+    const contentTypeChoices = [];
+    if (sourceConfig.supportsCommands) {
+      contentTypeChoices.push({ name: "Commands only", value: "commands" });
+    }
+    if (sourceConfig.supportsAgents) {
+      contentTypeChoices.push({ name: "Agents only", value: "agents" });
+    }
+    if (sourceConfig.supportsCommands && sourceConfig.supportsAgents) {
+      contentTypeChoices.push({ name: "Both", value: "both" });
+    }
+    if (contentTypeChoices.length === 0) {
+      console.log(source_default.red(`
+❌ Error: ${sourceConfig.name} doesn't support any syncable content`));
+      process.exit(1);
+    }
+    const contentAnswer = await lib_default.prompt([
+      {
+        type: "list",
+        name: "contentType",
+        message: "What would you like to sync?",
+        choices: contentTypeChoices
+      }
+    ]);
+    const syncType = contentAnswer.contentType;
+    const syncCommands = syncType === "commands" || syncType === "both";
+    const syncAgents = syncType === "agents" || syncType === "both";
+    const destinationChoices = [];
+    for (const tool of TOOLS) {
+      if (tool.value === sourceTool)
+        continue;
+      if (syncCommands && tool.supportsCommands) {
+        destinationChoices.push({
+          name: syncAgents ? `${tool.name} (commands)` : tool.name,
+          value: `${tool.value}-commands`,
+          tool: tool.value,
+          contentType: "commands"
+        });
+      }
+      if (syncAgents && tool.supportsAgents) {
+        destinationChoices.push({
+          name: syncCommands ? `${tool.name} (agents)` : tool.name,
+          value: `${tool.value}-agents`,
+          tool: tool.value,
+          contentType: "agents"
+        });
+      }
+    }
+    if (destinationChoices.length === 0) {
+      console.log(source_default.yellow(`
+⚠️  No compatible destination tools found for the selected sync type`));
+      process.exit(0);
+    }
+    const destinationAnswer = await lib_default.prompt([
+      {
+        type: "checkbox",
+        name: "destinations",
+        message: "Select destination tools (multi-select):",
+        choices: destinationChoices.map((choice) => ({
+          name: choice.name,
+          value: choice.value,
+          checked: false
+        })),
+        validate: (answer) => {
+          if (answer.length === 0) {
+            return "Please select at least one destination";
+          }
+          return true;
+        }
+      }
+    ]);
+    const selectedDestinations = destinationAnswer.destinations;
+    const customFolders = {
+      "claude-code": params.claudeCodeFolder,
+      codex: params.codexFolder,
+      opencode: params.openCodeFolder,
+      factoryai: params.factoryAiFolder
+    };
+    const sourcePaths = await getToolPaths(sourceTool, customFolders[sourceTool]);
+    console.log(source_default.blue(`
+\uD83D\uDCE6 Creating symlinks...
+`));
+    let successCount = 0;
+    let skipCount = 0;
+    for (const destValue of selectedDestinations) {
+      const destChoice = destinationChoices.find((c) => c.value === destValue);
+      const destPaths = await getToolPaths(destChoice.tool, customFolders[destChoice.tool]);
+      let sourcePath;
+      let targetPath;
+      if (destChoice.contentType === "commands") {
+        sourcePath = sourcePaths.commandsPath;
+        targetPath = destPaths.commandsPath;
+      } else {
+        sourcePath = sourcePaths.agentsPath;
+        targetPath = destPaths.agentsPath;
+      }
+      const toolName = TOOLS.find((t) => t.value === destChoice.tool)?.name || destChoice.tool;
+      const contentLabel = destChoice.contentType === "commands" ? "commands" : "agents";
+      try {
+        const success = await createSymlink(sourcePath, targetPath, {
+          skipMessage: source_default.yellow(`  ⚠️  ${toolName} ${contentLabel} path already exists and is not a symlink. Skipping...`)
+        });
+        if (success) {
+          console.log(source_default.green(`  ✓ ${toolName} (${contentLabel}) symlink created`));
+          successCount++;
+        } else {
+          skipCount++;
+        }
+      } catch (error) {
+        console.error(source_default.red(`  ✗ Failed to create ${toolName} (${contentLabel}) symlink:`), error);
+      }
+    }
+    console.log(source_default.green(`
+✨ Symlink setup complete! ${successCount} created, ${skipCount} skipped`));
+  } catch (error) {
+    console.error(source_default.red(`
+❌ Symlink setup failed:`), error);
+    process.exit(1);
+  }
+}
+
 // src/cli.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname4, join } from "path";
@@ -33634,10 +34000,15 @@ var __dirname5 = dirname4(fileURLToPath4(import.meta.url));
 var packageJson = JSON.parse(readFileSync2(join(__dirname5, "../package.json"), "utf8"));
 var program2 = new Command;
 program2.name("aiblueprint").description("AIBlueprint CLI for setting up Claude Code configurations").version(packageJson.version);
-var claudeCodeCmd = program2.command("claude-code").description("Claude Code configuration commands").option("-f, --folder <path>", "Specify custom folder path (default: ~/.claude)").option("-s, --skip", "Skip interactive prompts and install all features");
+var claudeCodeCmd = program2.command("claude-code").description("Claude Code configuration commands").option("-f, --folder <path>", "Specify custom Claude Code folder path (default: ~/.claude) - alias for --claudeCodeFolder").option("--claudeCodeFolder <path>", "Specify custom Claude Code folder path (default: ~/.claude)").option("--codexFolder <path>", "Specify custom Codex folder path (default: ~/.codex)").option("--openCodeFolder <path>", "Specify custom OpenCode folder path (default: ~/.config/opencode)").option("--factoryAiFolder <path>", "Specify custom FactoryAI folder path (default: ~/.factory)").option("-s, --skip", "Skip interactive prompts and install all features");
 claudeCodeCmd.command("setup").description("Setup Claude Code configuration with AIBlueprint defaults").action((options, command) => {
   const parentOptions = command.parent.opts();
-  setupCommand(parentOptions.folder, parentOptions.skip);
+  setupCommand({
+    claudeCodeFolder: parentOptions.claudeCodeFolder || parentOptions.folder,
+    codexFolder: parentOptions.codexFolder,
+    openCodeFolder: parentOptions.openCodeFolder,
+    skipInteractive: parentOptions.skip
+  });
 });
 var addCmd = claudeCodeCmd.command("add").description(`Add components to your Claude Code configuration
 ` + `Examples:
@@ -33646,11 +34017,22 @@ var addCmd = claudeCodeCmd.command("add").description(`Add components to your Cl
 ` + "  aiblueprint claude-code add commands commit");
 addCmd.command("hook <type>").description("Add a hook to your Claude Code configuration. Available types: post-edit-typescript").action((type, options, command) => {
   const parentOptions = command.parent.parent.opts();
-  addHookCommand(type, { folder: parentOptions.folder });
+  const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
+  addHookCommand(type, { folder: claudeCodeFolder });
 });
 addCmd.command("commands [command-name]").description("Install a Claude Code command or list all available commands (use without argument to list)").action((commandName, options, command) => {
   const parentOptions = command.parent.parent.opts();
-  addCommandCommand(commandName, { folder: parentOptions.folder });
+  const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
+  addCommandCommand(commandName, { folder: claudeCodeFolder });
+});
+claudeCodeCmd.command("symlink").description("Create symlinks between different CLI tools (Claude Code, Codex, OpenCode, FactoryAI)").action((options, command) => {
+  const parentOptions = command.parent.opts();
+  symlinkCommand({
+    claudeCodeFolder: parentOptions.claudeCodeFolder || parentOptions.folder,
+    codexFolder: parentOptions.codexFolder,
+    openCodeFolder: parentOptions.openCodeFolder,
+    factoryAiFolder: parentOptions.factoryAiFolder
+  });
 });
 program2.parse(process.argv);
 if (!process.argv.slice(2).length) {