aiblueprint-cli 1.4.0 → 1.4.2

package/dist/cli.js

@@ -33212,16 +33212,116 @@ async function installStatuslineDependencies(claudeDir) {
 // src/commands/setup/settings.ts
 var import_fs_extra3 = __toESM(require_lib4(), 1);
 import path5 from "path";
+
+// src/lib/platform.ts
 import os6 from "os";
+import { execSync as execSync2 } from "child_process";
+function escapeShellArg(arg) {
+  return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
+var cachedPlatformInfo = null;
+var cachedAudioPlayer = undefined;
+function isWSL() {
+  if (os6.platform() !== "linux")
+    return false;
+  const release = os6.release().toLowerCase();
+  return release.includes("microsoft") || release.includes("wsl");
+}
+function getPlatformInfo() {
+  if (cachedPlatformInfo)
+    return cachedPlatformInfo;
+  const platform = os6.platform();
+  const wsl = isWSL();
+  cachedPlatformInfo = {
+    platform,
+    isWindows: platform === "win32",
+    isMacOS: platform === "darwin",
+    isLinux: platform === "linux" && !wsl,
+    isWSL: wsl,
+    homeDir: os6.homedir()
+  };
+  return cachedPlatformInfo;
+}
+function detectAudioPlayer() {
+  if (cachedAudioPlayer !== undefined)
+    return cachedAudioPlayer;
+  const platform = os6.platform();
+  if (platform === "darwin") {
+    cachedAudioPlayer = "afplay";
+    return cachedAudioPlayer;
+  }
+  if (platform === "win32") {
+    cachedAudioPlayer = "powershell";
+    return cachedAudioPlayer;
+  }
+  const linuxPlayers = ["paplay", "aplay", "mpv", "ffplay"];
+  for (const player of linuxPlayers) {
+    try {
+      execSync2(`which ${player}`, { stdio: "ignore" });
+      cachedAudioPlayer = player;
+      return cachedAudioPlayer;
+    } catch {
+      continue;
+    }
+  }
+  cachedAudioPlayer = null;
+  return cachedAudioPlayer;
+}
 function getPlaySoundCommand(soundPath) {
+  const player = detectAudioPlayer();
+  if (!player)
+    return null;
   const platform = os6.platform();
+  const safePath = escapeShellArg(soundPath);
   if (platform === "darwin") {
-    return `afplay -v 0.1 "${soundPath}"`;
-  } else if (platform === "win32") {
-    return `powershell -c "(New-Object Media.SoundPlayer '${soundPath}').PlaySync()"`;
-  } else {
-    return `paplay "${soundPath}" 2>/dev/null || aplay "${soundPath}" 2>/dev/null || true`;
+    return `afplay -v 0.1 ${safePath}`;
+  }
+  if (platform === "win32") {
+    const escapedPath = soundPath.replace(/'/g, "''");
+    return `powershell -c "(New-Object Media.SoundPlayer '${escapedPath}').PlaySync()"`;
+  }
+  switch (player) {
+    case "paplay":
+      return `paplay ${safePath} 2>/dev/null || true`;
+    case "aplay":
+      return `aplay ${safePath} 2>/dev/null || true`;
+    case "mpv":
+      return `mpv --no-video --volume=10 ${safePath} 2>/dev/null || true`;
+    case "ffplay":
+      return `ffplay -nodisp -autoexit -volume 10 ${safePath} 2>/dev/null || true`;
+    default:
+      return null;
+  }
+}
+var KNOWN_CLAUDE_PATHS = [
+  /\/Users\/[^/]+\/\.claude\//,
+  /\/home\/[^/]+\/\.claude\//,
+  /C:\\Users\\[^\\]+\\\.claude\\/i
+];
+function transformHookCommand(command, claudeDir) {
+  let transformed = command;
+  for (const pattern of KNOWN_CLAUDE_PATHS) {
+    transformed = transformed.replace(pattern, `${claudeDir}/`);
   }
+  transformed = transformed.replace(/\\/g, "/");
+  return transformed;
+}
+function transformHook(hook, claudeDir) {
+  if (!hook)
+    return hook;
+  const transformed = { ...hook };
+  if (transformed.command && typeof transformed.command === "string") {
+    transformed.command = transformHookCommand(transformed.command, claudeDir);
+  }
+  if (Array.isArray(transformed.hooks)) {
+    transformed.hooks = transformed.hooks.map((h) => transformHook(h, claudeDir));
+  }
+  return transformed;
+}
+
+// src/commands/setup/settings.ts
+function toPosixPath(p) {
+  return p.replace(/\\/g, "/");
 }
 async function hasExistingStatusLine(claudeDir) {
   const settingsPath = path5.join(claudeDir, "settings.json");
@@ -33246,7 +33346,7 @@ async function updateSettings(options, claudeDir) {
     if (shouldReplace) {
       settings.statusLine = {
         type: "command",
-        command: `bun ${path5.join(claudeDir, "scripts/statusline/src/index.ts")}`,
+        command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/statusline/src/index.ts"))}`,
         padding: 0
       };
     }
@@ -33263,7 +33363,7 @@ async function updateSettings(options, claudeDir) {
       hooks: [
         {
           type: "command",
-          command: `bun ${path5.join(claudeDir, "scripts/command-validator/src/cli.ts")}`
+          command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/command-validator/src/cli.ts"))}`
         }
       ]
     };
@@ -33273,39 +33373,45 @@ async function updateSettings(options, claudeDir) {
     }
   }
   if (options.notificationSounds) {
-    if (!settings.hooks.Stop) {
-      settings.hooks.Stop = [];
-    }
-    const finishSoundPath = path5.join(claudeDir, "song/finish.mp3");
-    const stopHook = {
-      matcher: "",
-      hooks: [
-        {
-          type: "command",
-          command: getPlaySoundCommand(finishSoundPath)
-        }
-      ]
-    };
-    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 finishSoundPath = toPosixPath(path5.join(claudeDir, "song/finish.mp3"));
+    const finishSoundCommand = getPlaySoundCommand(finishSoundPath);
+    if (finishSoundCommand) {
+      if (!settings.hooks.Stop) {
+        settings.hooks.Stop = [];
+      }
+      const stopHook = {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: finishSoundCommand
+          }
+        ]
+      };
+      const existingStopHook = settings.hooks.Stop.find((h) => h.hooks?.some((hook) => hook.command?.includes("finish.mp3")));
+      if (!existingStopHook) {
+        settings.hooks.Stop.push(stopHook);
+      }
     }
-    const needHumanSoundPath = path5.join(claudeDir, "song/need-human.mp3");
-    const notificationHook = {
-      matcher: "",
-      hooks: [
-        {
-          type: "command",
-          command: getPlaySoundCommand(needHumanSoundPath)
-        }
-      ]
-    };
-    const existingNotificationHook = settings.hooks.Notification.find((h) => h.hooks?.some((hook) => hook.command?.includes("need-human.mp3")));
-    if (!existingNotificationHook) {
-      settings.hooks.Notification.push(notificationHook);
+    const needHumanSoundPath = toPosixPath(path5.join(claudeDir, "song/need-human.mp3"));
+    const needHumanSoundCommand = getPlaySoundCommand(needHumanSoundPath);
+    if (needHumanSoundCommand) {
+      if (!settings.hooks.Notification) {
+        settings.hooks.Notification = [];
+      }
+      const notificationHook = {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: needHumanSoundCommand
+          }
+        ]
+      };
+      const existingNotificationHook = settings.hooks.Notification.find((h) => h.hooks?.some((hook) => hook.command?.includes("need-human.mp3")));
+      if (!existingNotificationHook) {
+        settings.hooks.Notification.push(notificationHook);
+      }
     }
   }
   if (options.postEditTypeScript) {
@@ -33317,7 +33423,7 @@ async function updateSettings(options, claudeDir) {
       hooks: [
         {
           type: "command",
-          command: `bun ${path5.join(claudeDir, "scripts/hook-post-file.ts")}`
+          command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/hook-post-file.ts"))}`
         }
       ]
     };
@@ -33610,9 +33716,13 @@ async function setupCommand(params = {}) {
         }
         if (options.customStatusline) {
           await downloadDirectoryFromGitHub("scripts/statusline", path8.join(scriptsDir, "statusline"));
+          await import_fs_extra6.default.ensureDir(path8.join(scriptsDir, "statusline/data"));
         }
       } else {
         await import_fs_extra6.default.copy(path8.join(sourceDir, "scripts"), path8.join(claudeDir, "scripts"), { overwrite: true });
+        if (options.customStatusline) {
+          await import_fs_extra6.default.ensureDir(path8.join(claudeDir, "scripts/statusline/data"));
+        }
       }
       s.stop("Scripts installed");
     }
@@ -33733,15 +33843,280 @@ Next steps:`));
   }
 }
 
+// src/commands/setup-terminal.ts
+var import_fs_extra7 = __toESM(require_lib4(), 1);
+import path9 from "path";
+import os9 from "os";
+import { execSync as execSync3, exec } from "child_process";
+var OHMYZSH_INSTALL_URL = "https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh";
+var INSTALL_TIMEOUT = 120000;
+var PLUGIN_TIMEOUT = 60000;
+var THEMES = [
+  { value: "robbyrussell", name: "robbyrussell (default) - Clean and minimal" },
+  { value: "agnoster", name: "agnoster - Powerline style (requires patched font)" },
+  { value: "af-magic", name: "af-magic - Colorful with git info" },
+  { value: "dst", name: "dst - Clean with directory path" },
+  { value: "simple", name: "simple - Minimalist" },
+  { value: "bira", name: "bira - Two-line prompt with user info" },
+  { value: "custom", name: "Custom theme (enter name manually)" }
+];
+var PLUGINS = ["git", "zsh-autosuggestions", "zsh-syntax-highlighting"];
+function sanitizeThemeName(theme) {
+  const sanitized = theme.replace(/[^a-zA-Z0-9_-]/g, "");
+  if (sanitized.length === 0) {
+    return "robbyrussell";
+  }
+  return sanitized;
+}
+function commandExists(cmd) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(cmd)) {
+    return false;
+  }
+  try {
+    execSync3(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isOhMyZshInstalled(homeDir) {
+  const ohMyZshDir = path9.join(homeDir, ".oh-my-zsh");
+  return import_fs_extra7.default.existsSync(ohMyZshDir);
+}
+function backupFile(filePath) {
+  if (!import_fs_extra7.default.existsSync(filePath))
+    return null;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  try {
+    import_fs_extra7.default.copyFileSync(filePath, backupPath);
+    return backupPath;
+  } catch (error) {
+    throw new Error(`Failed to create backup: ${error.message}`);
+  }
+}
+async function installOhMyZsh(homeDir) {
+  return new Promise((resolve, reject) => {
+    const installCmd = `sh -c "$(curl -fsSL ${OHMYZSH_INSTALL_URL})" "" --unattended`;
+    const env2 = { ...process.env, HOME: homeDir, ZSH: path9.join(homeDir, ".oh-my-zsh") };
+    exec(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
+      if (error) {
+        if (error.killed) {
+          reject(new Error("Oh My ZSH installation timed out. Please check your network connection."));
+        } else {
+          reject(new Error(`Failed to install Oh My ZSH: ${stderr || error.message}`));
+        }
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+async function installPlugin(pluginName, repoUrl, homeDir) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(pluginName)) {
+    throw new Error(`Invalid plugin name: ${pluginName}`);
+  }
+  if (!/^https:\/\/github\.com\/[\w-]+\/[\w-]+$/.test(repoUrl)) {
+    throw new Error(`Invalid repository URL: ${repoUrl}`);
+  }
+  const customPluginsDir = path9.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
+  if (import_fs_extra7.default.existsSync(customPluginsDir)) {
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    exec(`git clone ${repoUrl} "${customPluginsDir}"`, { timeout: PLUGIN_TIMEOUT }, (error, stdout, stderr) => {
+      if (error) {
+        if (error.killed) {
+          reject(new Error(`Plugin ${pluginName} installation timed out. Please check your network connection.`));
+        } else {
+          reject(new Error(`Failed to install ${pluginName}: ${stderr || error.message}`));
+        }
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+function updateZshrcTheme(theme, homeDir) {
+  const zshrcPath = path9.join(homeDir, ".zshrc");
+  const sanitizedTheme = sanitizeThemeName(theme);
+  if (!import_fs_extra7.default.existsSync(zshrcPath)) {
+    throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
+  }
+  try {
+    let content = import_fs_extra7.default.readFileSync(zshrcPath, "utf-8");
+    if (content.match(/^ZSH_THEME=/m)) {
+      content = content.replace(/^ZSH_THEME=.*/m, `ZSH_THEME="${sanitizedTheme}"`);
+    } else {
+      content = `ZSH_THEME="${sanitizedTheme}"
+${content}`;
+    }
+    import_fs_extra7.default.writeFileSync(zshrcPath, content);
+  } catch (error) {
+    if (error.message.includes(".zshrc file not found")) {
+      throw error;
+    }
+    throw new Error(`Failed to update theme in .zshrc: ${error.message}`);
+  }
+}
+function updateZshrcPlugins(plugins, homeDir) {
+  const zshrcPath = path9.join(homeDir, ".zshrc");
+  if (!import_fs_extra7.default.existsSync(zshrcPath)) {
+    throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
+  }
+  try {
+    let content = import_fs_extra7.default.readFileSync(zshrcPath, "utf-8");
+    const pluginsString = plugins.join(" ");
+    if (content.match(/^plugins=\(/m)) {
+      content = content.replace(/^plugins=\([^)]*\)/m, `plugins=(${pluginsString})`);
+    } else {
+      content = `${content}
+plugins=(${pluginsString})`;
+    }
+    import_fs_extra7.default.writeFileSync(zshrcPath, content);
+  } catch (error) {
+    if (error.message.includes(".zshrc file not found")) {
+      throw error;
+    }
+    throw new Error(`Failed to update plugins in .zshrc: ${error.message}`);
+  }
+}
+async function setupTerminalCommand(options = {}) {
+  const { skipInteractive, homeDir: customHomeDir } = options;
+  const homeDir = customHomeDir || os9.homedir();
+  try {
+    console.log(source_default.blue.bold(`
+\uD83D\uDDA5️  AIBlueprint Terminal Setup ${source_default.gray(`v${getVersion()}`)}
+`));
+    console.log(source_default.bgBlue(" Setting up your terminal with Oh My ZSH "));
+    const platformInfo = getPlatformInfo();
+    if (platformInfo.isWindows) {
+      console.log(source_default.red(`
+❌ This command is not supported on Windows.`));
+      console.log(source_default.yellow("Please use WSL (Windows Subsystem for Linux) instead:"));
+      console.log(source_default.gray("  1. Open PowerShell as Administrator"));
+      console.log(source_default.gray("  2. Run: wsl --install"));
+      console.log(source_default.gray("  3. Restart your computer"));
+      console.log(source_default.gray("  4. Open WSL and run this command again"));
+      process.exit(1);
+    }
+    const s = new SimpleSpinner;
+    s.start("Checking prerequisites");
+    const missingPrereqs = [];
+    if (!commandExists("curl")) {
+      missingPrereqs.push("curl");
+    }
+    if (!commandExists("git")) {
+      missingPrereqs.push("git");
+    }
+    if (!commandExists("zsh")) {
+      missingPrereqs.push("zsh");
+    }
+    if (missingPrereqs.length > 0) {
+      s.stop(source_default.red("Missing prerequisites"));
+      console.log(source_default.red(`
+❌ Missing required tools: ${missingPrereqs.join(", ")}`));
+      console.log(source_default.yellow(`
+Please install them first:`));
+      if (platformInfo.isMacOS) {
+        console.log(source_default.gray("  brew install " + missingPrereqs.join(" ")));
+      } else {
+        console.log(source_default.gray("  sudo apt install " + missingPrereqs.join(" ")));
+      }
+      process.exit(1);
+    }
+    s.stop("Prerequisites OK");
+    let selectedTheme = "robbyrussell";
+    if (!skipInteractive) {
+      const themeAnswer = await lib_default.prompt([
+        {
+          type: "list",
+          name: "theme",
+          message: "Which theme would you like to use?",
+          choices: THEMES,
+          default: "robbyrussell"
+        }
+      ]);
+      if (themeAnswer.theme === "custom") {
+        const customThemeAnswer = await lib_default.prompt([
+          {
+            type: "input",
+            name: "customTheme",
+            message: "Enter the theme name (see: https://github.com/ohmyzsh/ohmyzsh/wiki/Themes):",
+            default: "robbyrussell",
+            validate: (value) => {
+              const sanitized = sanitizeThemeName(value);
+              if (sanitized !== value) {
+                return `Theme name can only contain letters, numbers, hyphens, and underscores. Will use: "${sanitized}"`;
+              }
+              return true;
+            }
+          }
+        ]);
+        selectedTheme = sanitizeThemeName(customThemeAnswer.customTheme);
+      } else {
+        selectedTheme = themeAnswer.theme;
+      }
+    }
+    const zshrcPath = path9.join(homeDir, ".zshrc");
+    if (import_fs_extra7.default.existsSync(zshrcPath)) {
+      s.start("Backing up .zshrc");
+      const backupPath = backupFile(zshrcPath);
+      if (backupPath) {
+        s.stop(`Backup created: ${source_default.gray(backupPath)}`);
+      } else {
+        s.stop("No backup needed");
+      }
+    }
+    if (isOhMyZshInstalled(homeDir)) {
+      console.log(source_default.green("✓ Oh My ZSH already installed"));
+    } else {
+      s.start("Installing Oh My ZSH (this may take a minute)");
+      await installOhMyZsh(homeDir);
+      s.stop("Oh My ZSH installed");
+    }
+    s.start("Installing zsh-autosuggestions plugin");
+    await installPlugin("zsh-autosuggestions", "https://github.com/zsh-users/zsh-autosuggestions", homeDir);
+    s.stop("zsh-autosuggestions installed");
+    s.start("Installing zsh-syntax-highlighting plugin");
+    await installPlugin("zsh-syntax-highlighting", "https://github.com/zsh-users/zsh-syntax-highlighting", homeDir);
+    s.stop("zsh-syntax-highlighting installed");
+    s.start(`Configuring theme: ${selectedTheme}`);
+    updateZshrcTheme(selectedTheme, homeDir);
+    s.stop(`Theme set to: ${selectedTheme}`);
+    s.start("Configuring plugins");
+    updateZshrcPlugins(PLUGINS, homeDir);
+    s.stop("Plugins configured");
+    console.log(source_default.green(`
+✨ Terminal setup complete!`));
+    console.log(source_default.gray(`
+Next steps:`));
+    console.log(source_default.gray("  • Restart your terminal or run: source ~/.zshrc"));
+    console.log(source_default.gray(`  • Theme: ${selectedTheme}`));
+    console.log(source_default.gray(`  • Plugins: ${PLUGINS.join(", ")}`));
+    if (selectedTheme === "agnoster") {
+      console.log(source_default.yellow(`
+⚠️  Note: agnoster theme requires a Powerline-patched font.`));
+      console.log(source_default.gray("  Install from: https://github.com/powerline/fonts"));
+    }
+    console.log(source_default.blue(`
+\uD83D\uDCDA Explore more themes: https://github.com/ohmyzsh/ohmyzsh/wiki/Themes`));
+  } catch (error) {
+    console.error(source_default.red(`
+❌ Setup failed:`), error);
+    process.exit(1);
+  }
+}
+
 // src/commands/addHook.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
-import path12 from "path";
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import path13 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { dirname as dirname4 } from "path";
 
 // src/utils/claude-config.ts
-var import_fs_extra7 = __toESM(require_lib4(), 1);
-import path9 from "path";
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import path10 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname3 } from "path";
 var __filename3 = fileURLToPath3(import.meta.url);
@@ -33772,14 +34147,14 @@ function parseYamlFrontmatter(content) {
 }
 function getLocalConfigPaths(subDir) {
   return [
-    path9.join(__dirname3, `../claude-code-config/${subDir}`),
-    path9.join(__dirname3, `../../claude-code-config/${subDir}`)
+    path10.join(__dirname3, `../claude-code-config/${subDir}`),
+    path10.join(__dirname3, `../../claude-code-config/${subDir}`)
   ];
 }
 async function findLocalConfigDir(subDir) {
   const possiblePaths = getLocalConfigPaths(subDir);
   for (const testPath of possiblePaths) {
-    if (await import_fs_extra7.default.pathExists(testPath)) {
+    if (await import_fs_extra8.default.pathExists(testPath)) {
       return testPath;
     }
   }
@@ -33790,22 +34165,22 @@ async function getTargetDirectory(options) {
     return options.folder;
   }
   const cwd = process.cwd();
-  const localClaudeDir = path9.join(cwd, ".claude");
-  const isGitRepo = await import_fs_extra7.default.pathExists(path9.join(cwd, ".git"));
-  const hasClaudeConfig = await import_fs_extra7.default.pathExists(localClaudeDir);
+  const localClaudeDir = path10.join(cwd, ".claude");
+  const isGitRepo = await import_fs_extra8.default.pathExists(path10.join(cwd, ".git"));
+  const hasClaudeConfig = await import_fs_extra8.default.pathExists(localClaudeDir);
   if (isGitRepo || hasClaudeConfig) {
     return localClaudeDir;
   }
-  return path9.join(process.env.HOME || process.env.USERPROFILE || "~", ".claude");
+  return path10.join(process.env.HOME || process.env.USERPROFILE || "~", ".claude");
 }
 
 // src/utils/file-installer.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
-import path11 from "path";
+var import_fs_extra10 = __toESM(require_lib4(), 1);
+import path12 from "path";
 
 // src/utils/github.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
-import path10 from "path";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import path11 from "path";
 var GITHUB_RAW_BASE3 = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
 async function downloadFromGitHub2(relativePath) {
   try {
@@ -33853,8 +34228,8 @@ async function isGitHubAvailable() {
 async function downloadAndWriteFile(relativePath, targetPath) {
   const content = await downloadFromGitHub2(relativePath);
   if (content) {
-    await import_fs_extra8.default.ensureDir(path10.dirname(targetPath));
-    await import_fs_extra8.default.writeFile(targetPath, content);
+    await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
+    await import_fs_extra9.default.writeFile(targetPath, content);
     return true;
   }
   return false;
@@ -33863,7 +34238,7 @@ async function downloadAndWriteFile(relativePath, targetPath) {
 // src/utils/file-installer.ts
 async function installFileWithGitHubFallback(options) {
   const { sourceDir, targetPath, fileName } = options;
-  await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
+  await import_fs_extra10.default.ensureDir(path12.dirname(targetPath));
   const useGitHub = options.useGitHub ?? await isGitHubAvailable();
   if (useGitHub) {
     const relativePath = `${sourceDir}/${fileName}`;
@@ -33877,11 +34252,11 @@ async function installFileWithGitHubFallback(options) {
   if (!localConfigDir) {
     throw new Error(`Neither GitHub nor local ${sourceDir} directory found`);
   }
-  const localFilePath = path11.join(localConfigDir, fileName);
-  if (!await import_fs_extra9.default.pathExists(localFilePath)) {
+  const localFilePath = path12.join(localConfigDir, fileName);
+  if (!await import_fs_extra10.default.pathExists(localFilePath)) {
     throw new Error(`File not found: ${fileName}`);
   }
-  await import_fs_extra9.default.copy(localFilePath, targetPath);
+  await import_fs_extra10.default.copy(localFilePath, targetPath);
 }
 async function getFileContentWithGitHubFallback(sourceDir, fileName) {
   const useGitHub = await isGitHubAvailable();
@@ -33896,11 +34271,11 @@ async function getFileContentWithGitHubFallback(sourceDir, fileName) {
   if (!localConfigDir) {
     throw new Error(`Neither GitHub nor local ${sourceDir} directory found`);
   }
-  const localFilePath = path11.join(localConfigDir, fileName);
-  if (!await import_fs_extra9.default.pathExists(localFilePath)) {
+  const localFilePath = path12.join(localConfigDir, fileName);
+  if (!await import_fs_extra10.default.pathExists(localFilePath)) {
     throw new Error(`File not found: ${fileName}`);
   }
-  return await import_fs_extra9.default.readFile(localFilePath, "utf-8");
+  return await import_fs_extra10.default.readFile(localFilePath, "utf-8");
 }
 
 // src/commands/addHook.ts
@@ -33942,10 +34317,10 @@ async function addHookCommand(hookType, options) {
   const s = new SimpleSpinner2;
   const targetDir = await getTargetDirectory(options);
   const claudeDir = targetDir;
-  const targetHookDir = path12.join(claudeDir, hook.targetDir || "hooks");
-  const hookFilePath = path12.join(targetHookDir, hook.hookFile);
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  if (await import_fs_extra10.default.pathExists(hookFilePath)) {
+  const targetHookDir = path13.join(claudeDir, hook.targetDir || "hooks");
+  const hookFilePath = path13.join(targetHookDir, hook.hookFile);
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  if (await import_fs_extra11.default.pathExists(hookFilePath)) {
     const overwriteAnswer = await lib_default.prompt([{
       type: "confirm",
       name: "overwrite",
@@ -33958,18 +34333,18 @@ async function addHookCommand(hookType, options) {
   }
   try {
     s.start("Installing hook...");
-    await import_fs_extra10.default.ensureDir(targetHookDir);
+    await import_fs_extra11.default.ensureDir(targetHookDir);
     await installFileWithGitHubFallback({
       sourceDir: hook.sourceDir || "hooks",
       targetPath: hookFilePath,
       fileName: hook.hookFile
     });
-    await import_fs_extra10.default.chmod(hookFilePath, 493);
+    await import_fs_extra11.default.chmod(hookFilePath, 493);
     s.stop("Hook file installed");
     s.start("Updating settings.json...");
     let settings = {};
     try {
-      const existingSettings = await import_fs_extra10.default.readFile(settingsPath, "utf-8");
+      const existingSettings = await import_fs_extra11.default.readFile(settingsPath, "utf-8");
       settings = JSON.parse(existingSettings);
     } catch {
       settings = {};
@@ -34006,7 +34381,7 @@ async function addHookCommand(hookType, options) {
     } else {
       settings.hooks[hook.event].push(newHook);
     }
-    await import_fs_extra10.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+    await import_fs_extra11.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(`
@@ -34025,8 +34400,8 @@ The hook will run automatically when you edit TypeScript files with Claude Code.
 }
 
 // src/commands/addCommand.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
-import path13 from "path";
+var import_fs_extra12 = __toESM(require_lib4(), 1);
+import path14 from "path";
 class SimpleSpinner3 {
   message = "";
   start(message) {
@@ -34039,11 +34414,11 @@ class SimpleSpinner3 {
 }
 async function getLocalMdFilesRecursively(dir, basePath = "") {
   const files = [];
-  const entries = await import_fs_extra11.default.readdir(dir, { withFileTypes: true });
+  const entries = await import_fs_extra12.default.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      const subFiles = await getLocalMdFilesRecursively(path13.join(dir, entry.name), relativePath);
+      const subFiles = await getLocalMdFilesRecursively(path14.join(dir, entry.name), relativePath);
       files.push(...subFiles);
     } else if (entry.name.endsWith(".md")) {
       files.push(relativePath);
@@ -34099,8 +34474,8 @@ function displayAvailableCommands(commands) {
     console.log();
   });
   console.log(source_default.gray("Usage:"));
-  console.log(source_default.gray("  aiblueprint claude-code add commands <command-name>  # Install specific command"));
-  console.log(source_default.gray("  aiblueprint claude-code add commands                 # Show this list"));
+  console.log(source_default.gray("  npx aiblueprint-cli@latest claude-code add commands <command-name>  # Install specific command"));
+  console.log(source_default.gray("  npx aiblueprint-cli@latest claude-code add commands                 # Show this list"));
 }
 async function addCommandCommand(commandName, options = {}) {
   console.log(source_default.bgBlue(` aiblueprint-cli v${getVersion()} `));
@@ -34123,9 +34498,9 @@ async function addCommandCommand(commandName, options = {}) {
   if (options.folder) {
     console.log(source_default.gray(`Using custom folder: ${targetDir}`));
   }
-  const commandsDir = path13.join(targetDir, "commands");
-  const commandFilePath = path13.join(commandsDir, command.commandFile);
-  if (await import_fs_extra11.default.pathExists(commandFilePath)) {
+  const commandsDir = path14.join(targetDir, "commands");
+  const commandFilePath = path14.join(commandsDir, command.commandFile);
+  if (await import_fs_extra12.default.pathExists(commandFilePath)) {
     const overwriteAnswer = await lib_default.prompt([{
       type: "confirm",
       name: "overwrite",
@@ -34332,22 +34707,22 @@ async function symlinkCommand(params = {}) {
 }
 
 // src/commands/statusline.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
-import path14 from "path";
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import path15 from "path";
 import { homedir } from "os";
 async function statuslineCommand(options) {
-  const claudeDir = options.folder ? path14.resolve(options.folder) : path14.join(homedir(), ".claude");
+  const claudeDir = options.folder ? path15.resolve(options.folder) : path15.join(homedir(), ".claude");
   console.log(source_default.blue(`\uD83D\uDE80 Setting up AIBlueprint Statusline ${source_default.gray(`v${getVersion()}`)}...`));
   console.log(source_default.gray(`  Target: ${claudeDir}
 `));
-  await import_fs_extra12.default.ensureDir(claudeDir);
+  await import_fs_extra13.default.ensureDir(claudeDir);
   console.log(source_default.cyan("\uD83D\uDCE6 Checking dependencies..."));
   await checkAndInstallDependencies();
   console.log(source_default.cyan(`
 \uD83D\uDCE5 Downloading statusline files...`));
-  const scriptsDir = path14.join(claudeDir, "scripts");
-  await import_fs_extra12.default.ensureDir(scriptsDir);
-  const success = await downloadDirectoryFromGitHub("scripts/statusline", path14.join(scriptsDir, "statusline"));
+  const scriptsDir = path15.join(claudeDir, "scripts");
+  await import_fs_extra13.default.ensureDir(scriptsDir);
+  const success = await downloadDirectoryFromGitHub("scripts/statusline", path15.join(scriptsDir, "statusline"));
   if (!success) {
     console.log(source_default.red("  Failed to download statusline files from GitHub"));
     return;
@@ -34357,19 +34732,19 @@ async function statuslineCommand(options) {
   await installStatuslineDependencies(claudeDir);
   console.log(source_default.cyan(`
 ⚙️  Configuring settings.json...`));
-  const settingsPath = path14.join(claudeDir, "settings.json");
+  const settingsPath = path15.join(claudeDir, "settings.json");
   let settings = {};
   try {
-    const existingSettings = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
+    const existingSettings = await import_fs_extra13.default.readFile(settingsPath, "utf-8");
     settings = JSON.parse(existingSettings);
   } catch {
   }
   settings.statusLine = {
     type: "command",
-    command: `bun ${path14.join(claudeDir, "scripts/statusline/src/index.ts")}`,
+    command: `bun ${path15.join(claudeDir, "scripts/statusline/src/index.ts")}`,
     padding: 0
   };
-  await import_fs_extra12.default.writeJson(settingsPath, settings, { spaces: 2 });
+  await import_fs_extra13.default.writeJson(settingsPath, settings, { spaces: 2 });
   console.log(source_default.green(`
 ✅ Statusline setup complete!`));
   console.log(source_default.gray(`
@@ -35033,13 +35408,13 @@ var de = () => {
 };
 
 // src/commands/pro.ts
-import os11 from "os";
-import path17 from "path";
+import os12 from "os";
+import path18 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
-import os9 from "os";
-import path15 from "path";
+var import_fs_extra14 = __toESM(require_lib4(), 1);
+import os10 from "os";
+import path16 from "path";
 var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
 async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath, githubToken) {
@@ -35056,8 +35431,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra13.default.ensureDir(path15.dirname(targetPath));
-    await import_fs_extra13.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra14.default.ensureDir(path16.dirname(targetPath));
+    await import_fs_extra14.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -35082,10 +35457,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra13.default.ensureDir(targetDir);
+    await import_fs_extra14.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path15.join(targetDir, file.name);
+      const targetPath = path16.join(targetDir, file.name);
       const displayPath = relativePath.replace("claude-code-config/", "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -35102,14 +35477,14 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
 }
 async function installProConfigs(options) {
   const { githubToken, claudeCodeFolder, onProgress } = options;
-  const claudeFolder = claudeCodeFolder || path15.join(os9.homedir(), ".claude");
-  const tempDir = path15.join(os9.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const claudeFolder = claudeCodeFolder || path16.join(os10.homedir(), ".claude");
+  const tempDir = path16.join(os10.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
     const success = await downloadDirectoryFromPrivateGitHub(PREMIUM_REPO, PREMIUM_BRANCH, "claude-code-config", tempDir, githubToken, onProgress);
     if (!success) {
       throw new Error("Failed to download premium configurations");
     }
-    await import_fs_extra13.default.copy(tempDir, claudeFolder, {
+    await import_fs_extra14.default.copy(tempDir, claudeFolder, {
       overwrite: true,
       recursive: true
     });
@@ -35117,41 +35492,41 @@ async function installProConfigs(options) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra13.default.remove(tempDir);
+      await import_fs_extra14.default.remove(tempDir);
     } catch {
     }
   }
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
-import os10 from "os";
-import path16 from "path";
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import os11 from "os";
+import path17 from "path";
 function getConfigDir() {
-  const platform = os10.platform();
+  const platform = os11.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path16.join(os10.homedir(), "AppData", "Roaming");
-    return path16.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path17.join(os11.homedir(), "AppData", "Roaming");
+    return path17.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path16.join(os10.homedir(), ".config");
-    return path16.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path17.join(os11.homedir(), ".config");
+    return path17.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath() {
-  return path16.join(getConfigDir(), "token.txt");
+  return path17.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath();
-  await import_fs_extra14.default.ensureDir(path16.dirname(tokenFile));
-  await import_fs_extra14.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra15.default.ensureDir(path17.dirname(tokenFile));
+  await import_fs_extra15.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath();
-  if (!await import_fs_extra14.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra15.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra14.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra15.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35160,12 +35535,12 @@ async function getToken() {
 function getTokenInfo() {
   return {
     path: getTokenFilePath(),
-    platform: os10.platform()
+    platform: os11.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
+var import_fs_extra16 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_ID = "prd_XJVgxVPbGG";
 async function countInstalledItems(claudeDir) {
@@ -35175,27 +35550,27 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const commandsDir = path17.join(claudeDir, "commands");
-    if (await import_fs_extra15.default.pathExists(commandsDir)) {
-      const files = await import_fs_extra15.default.readdir(commandsDir);
+    const commandsDir = path18.join(claudeDir, "commands");
+    if (await import_fs_extra16.default.pathExists(commandsDir)) {
+      const files = await import_fs_extra16.default.readdir(commandsDir);
       counts.commands = files.filter((f3) => f3.endsWith(".md")).length;
     }
   } catch {
   }
   try {
-    const agentsDir = path17.join(claudeDir, "agents");
-    if (await import_fs_extra15.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra15.default.readdir(agentsDir);
+    const agentsDir = path18.join(claudeDir, "agents");
+    if (await import_fs_extra16.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra16.default.readdir(agentsDir);
       counts.agents = files.filter((f3) => f3.endsWith(".md")).length;
     }
   } catch {
   }
   try {
-    const skillsDir = path17.join(claudeDir, "skills");
-    if (await import_fs_extra15.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra15.default.readdir(skillsDir);
+    const skillsDir = path18.join(claudeDir, "skills");
+    if (await import_fs_extra16.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra16.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra15.default.stat(path17.join(skillsDir, item));
+        const stat = await import_fs_extra16.default.stat(path18.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35258,7 +35633,7 @@ async function proActivateCommand(userToken) {
     f2.info(`Product: ${data.product.title}`);
     f2.info(`Token saved to: ${tokenInfo.path}`);
     f2.info(source_default.cyan(`
-\uD83D\uDCA1 Next step: Run 'aiblueprint claude-code pro setup' to install premium configs`));
+\uD83D\uDCA1 Next step: Run 'npx aiblueprint-cli@latest claude-code pro setup' to install premium configs`));
     $e(source_default.green("✅ Activation complete!"));
   } catch (error) {
     if (error instanceof Error) {
@@ -35274,7 +35649,7 @@ async function proStatusCommand() {
     const token = await getToken();
     if (!token) {
       f2.warn("No token found");
-      f2.info("Run: aiblueprint claude-code pro activate <token>");
+      f2.info("Run: npx aiblueprint-cli@latest claude-code pro activate <token>");
       f2.info("Get your token at: https://mlv.sh/claude-cli");
       $e(source_default.yellow("⚠️  Not activated"));
       process.exit(0);
@@ -35298,11 +35673,11 @@ async function proSetupCommand(options = {}) {
     const githubToken = await getToken();
     if (!githubToken) {
       f2.error("No token found");
-      f2.info("Run: aiblueprint claude-code pro activate <token>");
+      f2.info("Run: npx aiblueprint-cli@latest claude-code pro activate <token>");
       $e(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path17.resolve(options.folder) : path17.join(os11.homedir(), ".claude");
+    const claudeDir = options.folder ? path18.resolve(options.folder) : path18.join(os12.homedir(), ".claude");
     const spinner = de();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -35357,7 +35732,7 @@ async function proUpdateCommand(options = {}) {
     const githubToken = await getToken();
     if (!githubToken) {
       f2.error("No token found");
-      f2.info("Run: aiblueprint claude-code pro activate <token>");
+      f2.info("Run: npx aiblueprint-cli@latest claude-code pro activate <token>");
       $e(source_default.red("❌ Not activated"));
       process.exit(1);
     }
@@ -35379,12 +35754,12 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/commands/sync.ts
-import os12 from "os";
-import path19 from "path";
+import os13 from "os";
+import path20 from "path";
 
 // src/lib/sync-utils.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
-import path18 from "path";
+var import_fs_extra17 = __toESM(require_lib4(), 1);
+import path19 from "path";
 import crypto from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -35433,7 +35808,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra16.default.readFile(filePath);
+    const content = await import_fs_extra17.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -35441,15 +35816,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra16.default.pathExists(dir)) {
+  if (!await import_fs_extra17.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra16.default.readdir(dir);
+  const items = await import_fs_extra17.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path18.join(dir, item);
-    const stat = await import_fs_extra16.default.stat(fullPath);
+    const fullPath = path19.join(dir, item);
+    const stat = await import_fs_extra17.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(item);
       const subFiles = await listLocalFilesRecursive(fullPath, item);
@@ -35462,13 +35837,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra16.default.readdir(dir);
+  const items = await import_fs_extra17.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path18.join(dir, item);
+    const fullPath = path19.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra16.default.stat(fullPath);
+    const stat = await import_fs_extra17.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(relativePath);
       const subFiles = await listLocalFilesRecursive(fullPath, relativePath);
@@ -35481,7 +35856,7 @@ async function listLocalFilesRecursive(dir, basePath) {
 }
 async function analyzeCategory(category, claudeDir, githubToken) {
   const items = [];
-  const localDir = path18.join(claudeDir, category);
+  const localDir = path19.join(claudeDir, category);
   const remoteFiles = await listRemoteFilesRecursive(category, githubToken);
   const localFiles = await listLocalFiles(localDir);
   const remoteSet = new Map;
@@ -35490,7 +35865,7 @@ async function analyzeCategory(category, claudeDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path18.join(localDir, remotePath);
+    const localPath = path19.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -35522,8 +35897,8 @@ async function analyzeCategory(category, claudeDir, githubToken) {
   }
   for (const localPath of localSet) {
     if (!remoteSet.has(localPath)) {
-      const fullPath = path18.join(localDir, localPath);
-      const stat = await import_fs_extra16.default.stat(fullPath).catch(() => null);
+      const fullPath = path19.join(localDir, localPath);
+      const stat = await import_fs_extra17.default.stat(fullPath).catch(() => null);
       if (stat && !stat.isDirectory()) {
         items.push({
           name: localPath,
@@ -35554,9 +35929,9 @@ async function fetchRemoteSettings(githubToken) {
   }
 }
 async function getLocalSettings(claudeDir) {
-  const settingsPath = path18.join(claudeDir, "settings.json");
+  const settingsPath = path19.join(claudeDir, "settings.json");
   try {
-    const content = await import_fs_extra16.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra17.default.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -35637,8 +36012,8 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken)
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra16.default.ensureDir(path18.dirname(targetPath));
-    await import_fs_extra16.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra17.default.ensureDir(path19.dirname(targetPath));
+    await import_fs_extra17.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch {
     return false;
@@ -35648,10 +36023,10 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
   if (hooks.length === 0) {
     return { success: 0, failed: 0 };
   }
-  const settingsPath = path18.join(claudeDir, "settings.json");
+  const settingsPath = path19.join(claudeDir, "settings.json");
   let settings = {};
   try {
-    const content = await import_fs_extra16.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra17.default.readFile(settingsPath, "utf-8");
     settings = JSON.parse(content);
   } catch {
     settings = {};
@@ -35668,17 +36043,18 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
         settings.hooks[hook.hookType] = [];
       }
       const existingIndex = settings.hooks[hook.hookType].findIndex((h2) => h2.matcher === hook.matcher);
+      const transformedHook = transformHook(hook.remoteHook, claudeDir);
       if (existingIndex >= 0) {
-        settings.hooks[hook.hookType][existingIndex] = hook.remoteHook;
+        settings.hooks[hook.hookType][existingIndex] = transformedHook;
       } else {
-        settings.hooks[hook.hookType].push(hook.remoteHook);
+        settings.hooks[hook.hookType].push(transformedHook);
       }
       success++;
     } catch {
       failed++;
     }
   }
-  await import_fs_extra16.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await import_fs_extra17.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
   return { success, failed };
 }
 async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
@@ -35686,11 +36062,11 @@ async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
   let failed = 0;
   let deleted = 0;
   for (const item of items) {
-    const targetPath = path18.join(claudeDir, item.relativePath);
+    const targetPath = path19.join(claudeDir, item.relativePath);
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra16.default.remove(targetPath);
+        await import_fs_extra17.default.remove(targetPath);
         deleted++;
       } catch {
         failed++;
@@ -35837,11 +36213,11 @@ async function proSyncCommand(options = {}) {
     const githubToken = await getToken();
     if (!githubToken) {
       f2.error("No token found");
-      f2.info("Run: aiblueprint claude-code pro activate <token>");
+      f2.info("Run: npx aiblueprint-cli@latest claude-code pro activate <token>");
       $e(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path19.resolve(options.folder) : path19.join(os12.homedir(), ".claude");
+    const claudeDir = options.folder ? path20.resolve(options.folder) : path20.join(os13.homedir(), ".claude");
     const spinner = de();
     spinner.start("Analyzing changes...");
     const result = await analyzeSyncChanges(claudeDir, githubToken);
@@ -36033,11 +36409,18 @@ claudeCodeCmd.command("setup").description("Setup Claude Code configuration with
     skipInteractive: parentOptions.skip
   });
 });
+claudeCodeCmd.command("setup-terminal").description("Setup terminal with Oh My ZSH, plugins, and a beautiful theme").action((options, command) => {
+  const parentOptions = command.parent.opts();
+  setupTerminalCommand({
+    skipInteractive: parentOptions.skip,
+    homeDir: parentOptions.claudeCodeFolder || parentOptions.folder
+  });
+});
 var addCmd = claudeCodeCmd.command("add").description(`Add components to your Claude Code configuration
 ` + `Examples:
-` + `  aiblueprint claude-code add hook post-edit-typescript
-` + `  aiblueprint claude-code add commands
-` + "  aiblueprint claude-code add commands commit");
+` + `  npx aiblueprint-cli@latest claude-code add hook post-edit-typescript
+` + `  npx aiblueprint-cli@latest claude-code add commands
+` + "  npx aiblueprint-cli@latest 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();
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "AIBlueprint CLI for setting up Claude Code configurations",
   "author": "AIBlueprint",
   "license": "MIT",