aiblueprint-cli 1.4.34 → 1.4.35

package/claude-code-config/skills/ralph-loop/steps/step-00-init.md

@@ -134,8 +134,8 @@ fi
 
 ```bash
 # Make script executable and run it
-chmod +x /Users/melvynx/.claude/skills/setup-ralph/scripts/setup.sh
-/Users/melvynx/.claude/skills/setup-ralph/scripts/setup.sh "{project_path}" "{feature_name}"
+chmod +x {SKILL_PATH}/scripts/setup.sh
+{SKILL_PATH}/scripts/setup.sh "{project_path}" "{feature_name}"
 ```
 
 The setup script creates:

package/dist/cli.js

@@ -32249,8 +32249,8 @@ var inquirer = {
 var lib_default = inquirer;
 
 // src/commands/setup.ts
-var import_fs_extra6 = __toESM(require_lib4(), 1);
-import path8 from "path";
+var import_fs_extra7 = __toESM(require_lib4(), 1);
+import path9 from "path";
 import os9 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -32992,11 +32992,13 @@ async function installStatuslineDependencies(claudeDir) {
 }
 
 // src/commands/setup/settings.ts
-var import_fs_extra3 = __toESM(require_lib4(), 1);
-import path5 from "path";
+var import_fs_extra4 = __toESM(require_lib4(), 1);
+import path6 from "path";
 
 // src/lib/platform.ts
+var import_fs_extra3 = __toESM(require_lib4(), 1);
 import os6 from "os";
+import path5 from "path";
 import { execSync as execSync2 } from "child_process";
 function escapeShellArg(arg) {
   return "'" + arg.replace(/'/g, "'\\''") + "'";
@@ -33172,8 +33174,27 @@ function transformAudioCommand(command, claudeDir) {
   }
   return getPlaySoundCommand(soundPath);
 }
+function replaceClaudePathPlaceholder(content, claudeDir) {
+  return content.replaceAll("{CLAUDE_PATH}", claudeDir);
+}
+async function replacePathPlaceholdersInDir(dir, claudeDir) {
+  const entries = await import_fs_extra3.default.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await replacePathPlaceholdersInDir(fullPath, claudeDir);
+    } else if (isTextFile(entry.name)) {
+      const content = await import_fs_extra3.default.readFile(fullPath, "utf-8");
+      const replaced = replaceClaudePathPlaceholder(content, claudeDir);
+      if (replaced !== content) {
+        await import_fs_extra3.default.writeFile(fullPath, replaced, "utf-8");
+      }
+    }
+  }
+}
 function transformFileContent(content, claudeDir) {
   let transformed = content;
+  transformed = replaceClaudePathPlaceholder(transformed, claudeDir);
   for (const pattern of KNOWN_CLAUDE_PATHS) {
     transformed = transformed.replace(new RegExp(pattern.source, "g"), `${claudeDir}/`);
   }
@@ -33200,9 +33221,9 @@ function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
 async function hasExistingStatusLine(claudeDir) {
-  const settingsPath = path5.join(claudeDir, "settings.json");
+  const settingsPath = path6.join(claudeDir, "settings.json");
   try {
-    const existingSettings = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+    const existingSettings = await import_fs_extra4.default.readFile(settingsPath, "utf-8");
     const settings = JSON.parse(existingSettings);
     return !!settings.statusLine;
   } catch {
@@ -33210,10 +33231,10 @@ async function hasExistingStatusLine(claudeDir) {
   }
 }
 async function updateSettings(options, claudeDir) {
-  const settingsPath = path5.join(claudeDir, "settings.json");
+  const settingsPath = path6.join(claudeDir, "settings.json");
   let settings = {};
   try {
-    const existingSettings = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+    const existingSettings = await import_fs_extra4.default.readFile(settingsPath, "utf-8");
     settings = JSON.parse(existingSettings);
   } catch {}
   if (options.customStatusline) {
@@ -33221,7 +33242,7 @@ async function updateSettings(options, claudeDir) {
     if (shouldReplace) {
       settings.statusLine = {
         type: "command",
-        command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/statusline/src/index.ts"))}`,
+        command: `bun ${toPosixPath(path6.join(claudeDir, "scripts/statusline/src/index.ts"))}`,
         padding: 0
       };
     }
@@ -33238,7 +33259,7 @@ async function updateSettings(options, claudeDir) {
       hooks: [
         {
           type: "command",
-          command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/command-validator/src/cli.ts"))}`
+          command: `bun ${toPosixPath(path6.join(claudeDir, "scripts/command-validator/src/cli.ts"))}`
         }
       ]
     };
@@ -33248,7 +33269,7 @@ async function updateSettings(options, claudeDir) {
     }
   }
   if (options.notificationSounds) {
-    const finishSoundPath = toPosixPath(path5.join(claudeDir, "song/finish.mp3"));
+    const finishSoundPath = toPosixPath(path6.join(claudeDir, "song/finish.mp3"));
     const finishSoundCommand = getPlaySoundCommand(finishSoundPath);
     if (finishSoundCommand) {
       if (!settings.hooks.Stop) {
@@ -33268,7 +33289,7 @@ async function updateSettings(options, claudeDir) {
         settings.hooks.Stop.push(stopHook);
       }
     }
-    const needHumanSoundPath = toPosixPath(path5.join(claudeDir, "song/need-human.mp3"));
+    const needHumanSoundPath = toPosixPath(path6.join(claudeDir, "song/need-human.mp3"));
     const needHumanSoundCommand = getPlaySoundCommand(needHumanSoundPath);
     if (needHumanSoundCommand) {
       if (!settings.hooks.Notification) {
@@ -33289,12 +33310,12 @@ async function updateSettings(options, claudeDir) {
       }
     }
   }
-  await import_fs_extra3.default.writeJson(settingsPath, settings, { spaces: 2 });
+  await import_fs_extra4.default.writeJson(settingsPath, settings, { spaces: 2 });
 }
 
 // src/commands/setup/utils.ts
-var import_fs_extra4 = __toESM(require_lib4(), 1);
-import path6 from "path";
+var import_fs_extra5 = __toESM(require_lib4(), 1);
+import path7 from "path";
 import os7 from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -33312,20 +33333,20 @@ class SimpleSpinner {
 }
 var GITHUB_REPO = "https://github.com/Melvynx/aiblueprint.git";
 async function cloneRepository() {
-  const tmpDir = path6.join(os7.tmpdir(), `aiblueprint-${Date.now()}`);
+  const tmpDir = path7.join(os7.tmpdir(), `aiblueprint-${Date.now()}`);
   try {
-    await import_fs_extra4.default.ensureDir(tmpDir);
+    await import_fs_extra5.default.ensureDir(tmpDir);
     await execAsync(`git clone --depth 1 --quiet ${GITHUB_REPO} "${tmpDir}"`);
     return tmpDir;
   } catch (error) {
     console.error(source_default.yellow(`  Warning: Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`));
-    await import_fs_extra4.default.remove(tmpDir).catch(() => {});
+    await import_fs_extra5.default.remove(tmpDir).catch(() => {});
     return null;
   }
 }
 async function cleanupRepository(repoPath) {
   try {
-    await import_fs_extra4.default.remove(repoPath);
+    await import_fs_extra5.default.remove(repoPath);
   } catch (error) {
     console.error(source_default.yellow(`  Warning: Failed to cleanup temporary directory: ${error instanceof Error ? error.message : String(error)}`));
   }
@@ -33350,20 +33371,20 @@ function getVersion() {
 }
 
 // src/lib/backup-utils.ts
-var import_fs_extra5 = __toESM(require_lib4(), 1);
-import path7 from "path";
+var import_fs_extra6 = __toESM(require_lib4(), 1);
+import path8 from "path";
 import os8 from "os";
-var BACKUP_BASE_DIR = path7.join(os8.homedir(), ".config", "aiblueprint", "backup");
+var BACKUP_BASE_DIR = path8.join(os8.homedir(), ".config", "aiblueprint", "backup");
 function formatDate(date) {
   const pad = (n) => n.toString().padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
 }
 async function listBackups() {
-  const exists = await import_fs_extra5.default.pathExists(BACKUP_BASE_DIR);
+  const exists = await import_fs_extra6.default.pathExists(BACKUP_BASE_DIR);
   if (!exists) {
     return [];
   }
-  const entries = await import_fs_extra5.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
+  const entries = await import_fs_extra6.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
@@ -33375,46 +33396,46 @@ async function listBackups() {
     const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
     backups.push({
       name: entry.name,
-      path: path7.join(BACKUP_BASE_DIR, entry.name),
+      path: path8.join(BACKUP_BASE_DIR, entry.name),
       date
     });
   }
   return backups.sort((a, b) => b.date.getTime() - a.date.getTime());
 }
 async function loadBackup(backupPath, claudeDir) {
-  const exists = await import_fs_extra5.default.pathExists(backupPath);
+  const exists = await import_fs_extra6.default.pathExists(backupPath);
   if (!exists) {
     throw new Error(`Backup not found: ${backupPath}`);
   }
-  await import_fs_extra5.default.ensureDir(claudeDir);
+  await import_fs_extra6.default.ensureDir(claudeDir);
   const itemsToCopy = ["commands", "agents", "skills", "scripts", "song", "settings.json"];
   for (const item of itemsToCopy) {
-    const sourcePath = path7.join(backupPath, item);
-    const destPath = path7.join(claudeDir, item);
-    if (await import_fs_extra5.default.pathExists(sourcePath)) {
-      await import_fs_extra5.default.copy(sourcePath, destPath, { overwrite: true });
+    const sourcePath = path8.join(backupPath, item);
+    const destPath = path8.join(claudeDir, item);
+    if (await import_fs_extra6.default.pathExists(sourcePath)) {
+      await import_fs_extra6.default.copy(sourcePath, destPath, { overwrite: true });
     }
   }
 }
 async function createBackup(claudeDir) {
-  const exists = await import_fs_extra5.default.pathExists(claudeDir);
+  const exists = await import_fs_extra6.default.pathExists(claudeDir);
   if (!exists) {
     return null;
   }
-  const files = await import_fs_extra5.default.readdir(claudeDir);
+  const files = await import_fs_extra6.default.readdir(claudeDir);
   const hasContent = files.some((f) => f !== ".DS_Store");
   if (!hasContent) {
     return null;
   }
   const timestamp = formatDate(new Date);
-  const backupPath = path7.join(BACKUP_BASE_DIR, timestamp);
-  await import_fs_extra5.default.ensureDir(backupPath);
+  const backupPath = path8.join(BACKUP_BASE_DIR, timestamp);
+  await import_fs_extra6.default.ensureDir(backupPath);
   const itemsToCopy = ["commands", "agents", "skills", "scripts", "song", "settings.json"];
   for (const item of itemsToCopy) {
-    const sourcePath = path7.join(claudeDir, item);
-    const destPath = path7.join(backupPath, item);
-    if (await import_fs_extra5.default.pathExists(sourcePath)) {
-      await import_fs_extra5.default.copy(sourcePath, destPath, { overwrite: true });
+    const sourcePath = path8.join(claudeDir, item);
+    const destPath = path8.join(backupPath, item);
+    if (await import_fs_extra6.default.pathExists(sourcePath)) {
+      await import_fs_extra6.default.copy(sourcePath, destPath, { overwrite: true });
     }
   }
   return backupPath;
@@ -33518,9 +33539,9 @@ async function setupCommand(params = {}) {
       skipInteractive
     };
     const s = new SimpleSpinner;
-    const claudeDir = customClaudeCodeFolder ? path8.resolve(customClaudeCodeFolder) : path8.join(os9.homedir(), ".claude");
+    const claudeDir = customClaudeCodeFolder ? path9.resolve(customClaudeCodeFolder) : path9.join(os9.homedir(), ".claude");
     console.log(source_default.gray(`Installing to: ${claudeDir}`));
-    await import_fs_extra6.default.ensureDir(claudeDir);
+    await import_fs_extra7.default.ensureDir(claudeDir);
     s.start("Creating backup of existing configuration");
     const backupPath = await createBackup(claudeDir);
     if (backupPath) {
@@ -33533,8 +33554,8 @@ async function setupCommand(params = {}) {
     if (!repoPath) {
       throw new Error("Failed to clone repository. Please check your internet connection and try again.");
     }
-    const sourceDir = path8.join(repoPath, "claude-code-config");
-    if (!await import_fs_extra6.default.pathExists(sourceDir)) {
+    const sourceDir = path9.join(repoPath, "claude-code-config");
+    if (!await import_fs_extra7.default.pathExists(sourceDir)) {
       await cleanupRepository(repoPath);
       throw new Error("Configuration directory not found in cloned repository");
     }
@@ -33546,17 +33567,19 @@ async function setupCommand(params = {}) {
     }
     if (options.commandValidation || options.customStatusline || options.notificationSounds) {
       s.start("Setting up scripts");
-      await import_fs_extra6.default.copy(path8.join(sourceDir, "scripts"), path8.join(claudeDir, "scripts"), { overwrite: true });
+      await import_fs_extra7.default.copy(path9.join(sourceDir, "scripts"), path9.join(claudeDir, "scripts"), { overwrite: true });
+      await replacePathPlaceholdersInDir(path9.join(claudeDir, "scripts"), claudeDir);
       if (options.customStatusline) {
-        await import_fs_extra6.default.ensureDir(path8.join(claudeDir, "scripts/statusline/data"));
+        await import_fs_extra7.default.ensureDir(path9.join(claudeDir, "scripts/statusline/data"));
       }
       s.stop("Scripts installed");
     }
     if (options.aiblueprintCommands) {
       s.start("Setting up AIBlueprint commands");
-      const commandsSourcePath = path8.join(sourceDir, "commands");
-      if (await import_fs_extra6.default.pathExists(commandsSourcePath)) {
-        await import_fs_extra6.default.copy(commandsSourcePath, path8.join(claudeDir, "commands"), { overwrite: true });
+      const commandsSourcePath = path9.join(sourceDir, "commands");
+      if (await import_fs_extra7.default.pathExists(commandsSourcePath)) {
+        await import_fs_extra7.default.copy(commandsSourcePath, path9.join(claudeDir, "commands"), { overwrite: true });
+        await replacePathPlaceholdersInDir(path9.join(claudeDir, "commands"), claudeDir);
         s.stop("Commands installed");
       } else {
         s.stop("Commands not available in repository");
@@ -33574,14 +33597,16 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
-      await import_fs_extra6.default.copy(path8.join(sourceDir, "agents"), path8.join(claudeDir, "agents"), { overwrite: true });
+      await import_fs_extra7.default.copy(path9.join(sourceDir, "agents"), path9.join(claudeDir, "agents"), { overwrite: true });
+      await replacePathPlaceholdersInDir(path9.join(claudeDir, "agents"), claudeDir);
       s.stop("Agents installed");
     }
     if (options.aiblueprintSkills) {
       s.start("Setting up AIBlueprint Skills");
-      const skillsSourcePath = path8.join(sourceDir, "skills");
-      if (await import_fs_extra6.default.pathExists(skillsSourcePath)) {
-        await import_fs_extra6.default.copy(skillsSourcePath, path8.join(claudeDir, "skills"), { overwrite: true });
+      const skillsSourcePath = path9.join(sourceDir, "skills");
+      if (await import_fs_extra7.default.pathExists(skillsSourcePath)) {
+        await import_fs_extra7.default.copy(skillsSourcePath, path9.join(claudeDir, "skills"), { overwrite: true });
+        await replacePathPlaceholdersInDir(path9.join(claudeDir, "skills"), claudeDir);
         s.stop("Skills installed");
       } else {
         s.stop("Skills not available in repository");
@@ -33589,7 +33614,7 @@ async function setupCommand(params = {}) {
     }
     if (options.notificationSounds) {
       s.start("Setting up notification sounds");
-      await import_fs_extra6.default.copy(path8.join(sourceDir, "song"), path8.join(claudeDir, "song"), { overwrite: true });
+      await import_fs_extra7.default.copy(path9.join(sourceDir, "song"), path9.join(claudeDir, "song"), { overwrite: true });
       s.stop("Notification sounds installed");
     }
     if (options.customStatusline) {
@@ -33651,8 +33676,8 @@ Next steps:`));
 }
 
 // src/commands/setup-terminal.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 os10 from "os";
 import { execSync as execSync3, exec as exec2 } from "child_process";
 var OHMYZSH_INSTALL_URL = "https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh";
@@ -33687,16 +33712,16 @@ function commandExists(cmd) {
   }
 }
 function isOhMyZshInstalled(homeDir) {
-  const ohMyZshDir = path9.join(homeDir, ".oh-my-zsh");
-  return import_fs_extra7.default.existsSync(ohMyZshDir);
+  const ohMyZshDir = path10.join(homeDir, ".oh-my-zsh");
+  return import_fs_extra8.default.existsSync(ohMyZshDir);
 }
 function backupFile(filePath) {
-  if (!import_fs_extra7.default.existsSync(filePath))
+  if (!import_fs_extra8.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);
+    import_fs_extra8.default.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (error) {
     throw new Error(`Failed to create backup: ${error.message}`);
@@ -33735,7 +33760,7 @@ function installPrerequisiteSync(packageName, installCmd) {
 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") };
+    const env2 = { ...process.env, HOME: homeDir, ZSH: path10.join(homeDir, ".oh-my-zsh") };
     exec2(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
@@ -33756,8 +33781,8 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   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)) {
+  const customPluginsDir = path10.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
+  if (import_fs_extra8.default.existsSync(customPluginsDir)) {
     return;
   }
   return new Promise((resolve, reject) => {
@@ -33775,20 +33800,20 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   });
 }
 function updateZshrcTheme(theme, homeDir) {
-  const zshrcPath = path9.join(homeDir, ".zshrc");
+  const zshrcPath = path10.join(homeDir, ".zshrc");
   const sanitizedTheme = sanitizeThemeName(theme);
-  if (!import_fs_extra7.default.existsSync(zshrcPath)) {
+  if (!import_fs_extra8.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");
+    let content = import_fs_extra8.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);
+    import_fs_extra8.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -33797,12 +33822,12 @@ ${content}`;
   }
 }
 function updateZshrcPlugins(plugins, homeDir) {
-  const zshrcPath = path9.join(homeDir, ".zshrc");
-  if (!import_fs_extra7.default.existsSync(zshrcPath)) {
+  const zshrcPath = path10.join(homeDir, ".zshrc");
+  if (!import_fs_extra8.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");
+    let content = import_fs_extra8.default.readFileSync(zshrcPath, "utf-8");
     const pluginsString = plugins.join(" ");
     if (content.match(/^plugins=\(/m)) {
       content = content.replace(/^plugins=\([^)]*\)/m, `plugins=(${pluginsString})`);
@@ -33810,7 +33835,7 @@ function updateZshrcPlugins(plugins, homeDir) {
       content = `${content}
 plugins=(${pluginsString})`;
     }
-    import_fs_extra7.default.writeFileSync(zshrcPath, content);
+    import_fs_extra8.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -33917,8 +33942,8 @@ Installing missing prerequisites: ${missingPrereqs.join(", ")}`));
         selectedTheme = themeAnswer.theme;
       }
     }
-    const zshrcPath = path9.join(homeDir, ".zshrc");
-    if (import_fs_extra7.default.existsSync(zshrcPath)) {
+    const zshrcPath = path10.join(homeDir, ".zshrc");
+    if (import_fs_extra8.default.existsSync(zshrcPath)) {
       s.start("Backing up .zshrc");
       const backupPath = backupFile(zshrcPath);
       if (backupPath) {
@@ -34850,19 +34875,19 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 
 // src/commands/pro.ts
 import os13 from "os";
-import path12 from "path";
+import path13 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
+var import_fs_extra9 = __toESM(require_lib4(), 1);
 import os11 from "os";
-import path10 from "path";
+import path11 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
 var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
 function getCacheRepoDir() {
-  return path10.join(os11.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path11.join(os11.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
 }
 async function execGitWithAuth(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -34876,33 +34901,39 @@ async function execGitWithAuth(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo(token) {
   const cacheDir = getCacheRepoDir();
   const repoUrl = `https://github.com/${PREMIUM_REPO}.git`;
-  if (await import_fs_extra8.default.pathExists(path10.join(cacheDir, ".git"))) {
+  if (await import_fs_extra9.default.pathExists(path11.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra8.default.remove(cacheDir);
-      await import_fs_extra8.default.ensureDir(path10.dirname(cacheDir));
+      await import_fs_extra9.default.remove(cacheDir);
+      await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra8.default.ensureDir(path10.dirname(cacheDir));
+    await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path10.join(cacheDir, "claude-code-config");
+  return path11.join(cacheDir, "claude-code-config");
 }
 async function copyConfigFromCache(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra8.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra9.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path10.join(dir, entry.name);
-      const relativePath = path10.relative(baseDir, sourcePath);
-      const targetPath = path10.join(targetDir, relativePath);
+      const sourcePath = path11.join(dir, entry.name);
+      const relativePath = path11.relative(baseDir, sourcePath);
+      const targetPath = path11.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra8.default.ensureDir(targetPath);
+        await import_fs_extra9.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
+      } else if (isTextFile(entry.name)) {
+        const content = await import_fs_extra9.default.readFile(sourcePath, "utf-8");
+        const replaced = replaceClaudePathPlaceholder(content, targetDir);
+        await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
+        await import_fs_extra9.default.writeFile(targetPath, replaced, "utf-8");
+        onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra8.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra9.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -34923,8 +34954,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra8.default.ensureDir(path10.dirname(targetPath));
-    await import_fs_extra8.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
+    await import_fs_extra9.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -34949,10 +34980,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra8.default.ensureDir(targetDir);
+    await import_fs_extra9.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path10.join(targetDir, file.name);
+      const targetPath = path11.join(targetDir, file.name);
       const displayPath = relativePath.replace("claude-code-config/", "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -34969,7 +35000,7 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
 }
 async function installProConfigs(options) {
   const { githubToken, claudeCodeFolder, onProgress } = options;
-  const claudeFolder = claudeCodeFolder || path10.join(os11.homedir(), ".claude");
+  const claudeFolder = claudeCodeFolder || path11.join(os11.homedir(), ".claude");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
     await copyConfigFromCache(cacheConfigDir, claudeFolder, onProgress);
@@ -34977,46 +35008,46 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path10.join(os11.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path11.join(os11.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_extra8.default.copy(tempDir, claudeFolder, {
+    await import_fs_extra9.default.copy(tempDir, claudeFolder, {
       overwrite: true
     });
   } catch (error) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra8.default.remove(tempDir);
+      await import_fs_extra9.default.remove(tempDir);
     } catch {}
   }
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
+var import_fs_extra10 = __toESM(require_lib4(), 1);
 import os12 from "os";
-import path11 from "path";
+import path12 from "path";
 function getConfigDir() {
   const platform = os12.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path11.join(os12.homedir(), "AppData", "Roaming");
-    return path11.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path12.join(os12.homedir(), "AppData", "Roaming");
+    return path12.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path11.join(os12.homedir(), ".config");
-    return path11.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path12.join(os12.homedir(), ".config");
+    return path12.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath() {
-  return path11.join(getConfigDir(), "token.txt");
+  return path12.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath();
-  const configDir = path11.dirname(tokenFile);
+  const configDir = path12.dirname(tokenFile);
   try {
-    await import_fs_extra9.default.ensureDir(configDir);
+    await import_fs_extra10.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -35024,15 +35055,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra9.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra10.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath();
-  if (!await import_fs_extra9.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra10.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra9.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra10.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35046,7 +35077,7 @@ function getTokenInfo() {
 }
 
 // src/commands/pro.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
+var import_fs_extra11 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -35056,29 +35087,29 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const commandsDir = path12.join(claudeDir, "commands");
-    if (await import_fs_extra10.default.pathExists(commandsDir)) {
-      const files = await import_fs_extra10.default.readdir(commandsDir);
+    const commandsDir = path13.join(claudeDir, "commands");
+    if (await import_fs_extra11.default.pathExists(commandsDir)) {
+      const files = await import_fs_extra11.default.readdir(commandsDir);
       counts.commands = files.filter((f) => f.endsWith(".md")).length;
     }
   } catch (error) {
     console.error("Failed to count commands:", error instanceof Error ? error.message : error);
   }
   try {
-    const agentsDir = path12.join(claudeDir, "agents");
-    if (await import_fs_extra10.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra10.default.readdir(agentsDir);
+    const agentsDir = path13.join(claudeDir, "agents");
+    if (await import_fs_extra11.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra11.default.readdir(agentsDir);
       counts.agents = files.filter((f) => f.endsWith(".md")).length;
     }
   } catch (error) {
     console.error("Failed to count agents:", error instanceof Error ? error.message : error);
   }
   try {
-    const skillsDir = path12.join(claudeDir, "skills");
-    if (await import_fs_extra10.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra10.default.readdir(skillsDir);
+    const skillsDir = path13.join(claudeDir, "skills");
+    if (await import_fs_extra11.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra11.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra10.default.stat(path12.join(skillsDir, item));
+        const stat = await import_fs_extra11.default.stat(path13.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35191,7 +35222,7 @@ async function proSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path12.resolve(options.folder) : path12.join(os13.homedir(), ".claude");
+    const claudeDir = options.folder ? path13.resolve(options.folder) : path13.join(os13.homedir(), ".claude");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -35274,11 +35305,11 @@ async function proUpdateCommand(options = {}) {
 
 // src/commands/sync.ts
 import os14 from "os";
-import path14 from "path";
+import path15 from "path";
 
 // src/lib/sync-utils.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";
 import crypto from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -35327,7 +35358,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra11.default.readFile(filePath);
+    const content = await import_fs_extra12.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -35335,15 +35366,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra11.default.pathExists(dir)) {
+  if (!await import_fs_extra12.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra11.default.readdir(dir);
+  const items = await import_fs_extra12.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path13.join(dir, item);
-    const stat = await import_fs_extra11.default.stat(fullPath);
+    const fullPath = path14.join(dir, item);
+    const stat = await import_fs_extra12.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(item);
       const subFiles = await listLocalFilesRecursive(fullPath, item);
@@ -35356,13 +35387,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra11.default.readdir(dir);
+  const items = await import_fs_extra12.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path13.join(dir, item);
+    const fullPath = path14.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra11.default.stat(fullPath);
+    const stat = await import_fs_extra12.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(relativePath);
       const subFiles = await listLocalFilesRecursive(fullPath, relativePath);
@@ -35375,7 +35406,7 @@ async function listLocalFilesRecursive(dir, basePath) {
 }
 async function analyzeCategory(category, claudeDir, githubToken) {
   const items = [];
-  const localDir = path13.join(claudeDir, category);
+  const localDir = path14.join(claudeDir, category);
   const remoteFiles = await listRemoteFilesRecursive(category, githubToken);
   const localFiles = await listLocalFiles(localDir);
   const remoteSet = new Map;
@@ -35384,7 +35415,7 @@ async function analyzeCategory(category, claudeDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path13.join(localDir, remotePath);
+    const localPath = path14.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -35427,8 +35458,8 @@ async function analyzeCategory(category, claudeDir, githubToken) {
       if (parentAlreadyDeleted) {
         continue;
       }
-      const fullPath = path13.join(localDir, localPath);
-      const stat = await import_fs_extra11.default.stat(fullPath).catch(() => null);
+      const fullPath = path14.join(localDir, localPath);
+      const stat = await import_fs_extra12.default.stat(fullPath).catch(() => null);
       if (stat) {
         const isFolder = stat.isDirectory();
         items.push({
@@ -35464,9 +35495,9 @@ async function fetchRemoteSettings(githubToken) {
   }
 }
 async function getLocalSettings(claudeDir) {
-  const settingsPath = path13.join(claudeDir, "settings.json");
+  const settingsPath = path14.join(claudeDir, "settings.json");
   try {
-    const content = await import_fs_extra11.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -35548,13 +35579,13 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra11.default.ensureDir(path13.dirname(targetPath));
+    await import_fs_extra12.default.ensureDir(path14.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra11.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra12.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra11.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra12.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
@@ -35565,10 +35596,10 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
   if (hooks.length === 0) {
     return { success: 0, failed: 0 };
   }
-  const settingsPath = path13.join(claudeDir, "settings.json");
+  const settingsPath = path14.join(claudeDir, "settings.json");
   let settings = {};
   try {
-    const content = await import_fs_extra11.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
     settings = JSON.parse(content);
   } catch {
     settings = {};
@@ -35596,7 +35627,7 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
       failed++;
     }
   }
-  await import_fs_extra11.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await import_fs_extra12.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
   return { success, failed };
 }
 async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
@@ -35604,11 +35635,11 @@ async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
   let failed = 0;
   let deleted = 0;
   for (const item of items) {
-    const targetPath = path13.join(claudeDir, item.relativePath);
+    const targetPath = path14.join(claudeDir, item.relativePath);
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra11.default.remove(targetPath);
+        await import_fs_extra12.default.remove(targetPath);
         deleted++;
       } catch {
         failed++;
@@ -35760,7 +35791,7 @@ async function proSyncCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path14.resolve(options.folder) : path14.join(os14.homedir(), ".claude");
+    const claudeDir = options.folder ? path15.resolve(options.folder) : path15.join(os14.homedir(), ".claude");
     const spinner = Y2();
     spinner.start("Analyzing changes...");
     const result = await analyzeSyncChanges(claudeDir, githubToken);
@@ -36006,7 +36037,7 @@ async function proSyncCommand(options = {}) {
 
 // src/commands/backup.ts
 import os15 from "os";
-import path15 from "path";
+import path16 from "path";
 function formatBackupDate(date) {
   const now = new Date;
   const diffMs = now.getTime() - date.getTime();
@@ -36026,7 +36057,7 @@ function formatBackupDate(date) {
   return `${date.toLocaleString()} (${relative})`;
 }
 async function backupLoadCommand(options = {}) {
-  const claudeDir = options.folder || path15.join(os15.homedir(), ".claude");
+  const claudeDir = options.folder || path16.join(os15.homedir(), ".claude");
   Ie(source_default.blue("\uD83D\uDCE6 Load Backup"));
   const spinner = Y2();
   spinner.start("Scanning for backups...");
@@ -36083,18 +36114,18 @@ async function backupLoadCommand(options = {}) {
 
 // src/commands/openclaw-pro.ts
 import os18 from "os";
-import path18 from "path";
+import path19 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
+var import_fs_extra13 = __toESM(require_lib4(), 1);
 import os16 from "os";
-import path16 from "path";
+import path17 from "path";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec4);
 var OPENCLAW_PRO_REPO = "Melvynx/openclawpro";
 function getCacheRepoDir2() {
-  return path16.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path17.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -36108,33 +36139,33 @@ async function execGitWithAuth2(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo2(token) {
   const cacheDir = getCacheRepoDir2();
   const repoUrl = `https://github.com/${OPENCLAW_PRO_REPO}.git`;
-  if (await import_fs_extra12.default.pathExists(path16.join(cacheDir, ".git"))) {
+  if (await import_fs_extra13.default.pathExists(path17.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra12.default.remove(cacheDir);
-      await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+      await import_fs_extra13.default.remove(cacheDir);
+      await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+    await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path16.join(cacheDir, "openclaw-config");
+  return path17.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra12.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra13.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path16.join(dir, entry.name);
-      const relativePath = path16.relative(baseDir, sourcePath);
-      const targetPath = path16.join(targetDir, relativePath);
+      const sourcePath = path17.join(dir, entry.name);
+      const relativePath = path17.relative(baseDir, sourcePath);
+      const targetPath = path17.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra12.default.ensureDir(targetPath);
+        await import_fs_extra13.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra12.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra13.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -36143,7 +36174,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path16.join(os16.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path17.join(os16.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -36154,28 +36185,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
+var import_fs_extra14 = __toESM(require_lib4(), 1);
 import os17 from "os";
-import path17 from "path";
+import path18 from "path";
 function getConfigDir2() {
   const platform = os17.platform();
   if (platform === "win32") {
-    return path17.join(process.env.APPDATA || os17.homedir(), "openclaw");
+    return path18.join(process.env.APPDATA || os17.homedir(), "openclaw");
   }
-  return path17.join(os17.homedir(), ".config", "openclaw");
+  return path18.join(os17.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path17.join(getConfigDir2(), "token.txt");
+  return path18.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra13.default.ensureDir(configDir);
-  await import_fs_extra13.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra14.default.ensureDir(configDir);
+  await import_fs_extra14.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra13.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra13.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra14.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra14.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -36188,7 +36219,7 @@ function getOpenclawTokenInfo() {
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
+var import_fs_extra15 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -36295,7 +36326,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path18.resolve(options.folder) : path18.join(os18.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path19.resolve(options.folder) : path19.join(os18.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -36308,23 +36339,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path18.join(openclawDir, "skills");
-    if (await import_fs_extra14.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra14.default.readdir(skillsDir);
+    const skillsDir = path19.join(openclawDir, "skills");
+    if (await import_fs_extra15.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra15.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra14.default.stat(path18.join(skillsDir, item));
+        const stat = await import_fs_extra15.default.stat(path19.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path18.join(openclawDir, "workspace");
-    const toolsPath = path18.join(workspaceDir, "TOOLS.md");
-    await import_fs_extra14.default.ensureDir(workspaceDir);
-    if (await import_fs_extra14.default.pathExists(toolsPath)) {
-      const existingContent = await import_fs_extra14.default.readFile(toolsPath, "utf-8");
+    const workspaceDir = path19.join(openclawDir, "workspace");
+    const toolsPath = path19.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra15.default.ensureDir(workspaceDir);
+    if (await import_fs_extra15.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra15.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra14.default.appendFile(toolsPath, `
+        await import_fs_extra15.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -36338,7 +36369,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra14.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra15.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -36349,9 +36380,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path18.join(binDir, "claude-run");
+    const wrapperPath = path19.join(binDir, "claude-run");
     try {
-      await import_fs_extra14.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra15.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
       spinner.stop("claude-run wrapper created");
     } catch {
       spinner.stop("claude-run wrapper skipped (no write access to /usr/local/bin)");
@@ -36400,12 +36431,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path21 from "path";
+import path22 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
-import path19 from "path";
+var import_fs_extra16 = __toESM(require_lib4(), 1);
+import path20 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -36416,12 +36447,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path19.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path20.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra15.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra16.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra15.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra16.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -36465,10 +36496,10 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
+var import_fs_extra17 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path20 from "path";
+import path21 from "path";
 import os19 from "os";
 function checkCommand(cmd) {
   try {
@@ -36498,18 +36529,18 @@ async function executeScript(scriptName, claudeDir) {
     console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
     return 1;
   }
-  const scriptsDir = path20.join(claudeDir, "scripts");
-  if (!await import_fs_extra16.default.pathExists(scriptsDir)) {
+  const scriptsDir = path21.join(claudeDir, "scripts");
+  if (!await import_fs_extra17.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint claude-code setup"));
     return 1;
   }
-  const packageJsonPath = path20.join(scriptsDir, "package.json");
-  if (!await import_fs_extra16.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path21.join(scriptsDir, "package.json");
+  if (!await import_fs_extra17.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra16.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra17.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -36532,7 +36563,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path21.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path21.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path22.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path22.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);

package/package.json

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