aiblueprint-cli 1.4.19 → 1.4.21

package/dist/cli.js

@@ -32251,7 +32251,7 @@ var lib_default = inquirer;
 // src/commands/setup.ts
 var import_fs_extra6 = __toESM(require_lib4(), 1);
 import path8 from "path";
-import os8 from "os";
+import os9 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -33201,6 +33201,10 @@ async function updateSettings(options, claudeDir) {
 // src/commands/setup/utils.ts
 var import_fs_extra4 = __toESM(require_lib4(), 1);
 import path6 from "path";
+import os7 from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
 
 class SimpleSpinner {
   message = "";
@@ -33212,57 +33216,24 @@ class SimpleSpinner {
     console.log(source_default.green(`✓ ${message}`));
   }
 }
-var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
-async function downloadFromGitHub(relativePath, targetPath) {
+var GITHUB_REPO = "https://github.com/Melvynx/aiblueprint.git";
+async function cloneRepository() {
+  const tmpDir = path6.join(os7.tmpdir(), `aiblueprint-${Date.now()}`);
   try {
-    const url = `${GITHUB_RAW_BASE}/${relativePath}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      return false;
-    }
-    const content = await response.arrayBuffer();
-    await import_fs_extra4.default.ensureDir(path6.dirname(targetPath));
-    await import_fs_extra4.default.writeFile(targetPath, Buffer.from(content));
-    return true;
+    await import_fs_extra4.default.ensureDir(tmpDir);
+    await execAsync(`git clone --depth 1 --quiet ${GITHUB_REPO} "${tmpDir}"`);
+    return tmpDir;
   } catch (error) {
-    return false;
+    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(() => {});
+    return null;
   }
 }
-async function downloadDirectoryFromGitHub(dirPath, targetDir) {
+async function cleanupRepository(repoPath) {
   try {
-    const apiUrl = `https://api.github.com/repos/Melvynx/aiblueprint-cli/contents/claude-code-config/${dirPath}`;
-    const response = await fetch(apiUrl);
-    if (!response.ok) {
-      console.error(source_default.yellow(`  Warning: Failed to fetch directory from GitHub: ${dirPath} (HTTP ${response.status})`));
-      return false;
-    }
-    const files = await response.json();
-    if (!Array.isArray(files)) {
-      console.error(source_default.yellow(`  Warning: Invalid response from GitHub API for: ${dirPath}`));
-      return false;
-    }
-    await import_fs_extra4.default.ensureDir(targetDir);
-    let allSuccess = true;
-    for (const file of files) {
-      const relativePath = `${dirPath}/${file.name}`;
-      const targetPath = path6.join(targetDir, file.name);
-      if (file.type === "file") {
-        const success = await downloadFromGitHub(relativePath, targetPath);
-        if (!success) {
-          console.error(source_default.yellow(`  Warning: Failed to download file: ${relativePath}`));
-          allSuccess = false;
-        }
-      } else if (file.type === "dir") {
-        const success = await downloadDirectoryFromGitHub(relativePath, targetPath);
-        if (!success) {
-          allSuccess = false;
-        }
-      }
-    }
-    return allSuccess;
+    await import_fs_extra4.default.remove(repoPath);
   } catch (error) {
-    console.error(source_default.yellow(`  Warning: Error downloading directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`));
-    return false;
+    console.error(source_default.yellow(`  Warning: Failed to cleanup temporary directory: ${error instanceof Error ? error.message : String(error)}`));
   }
 }
 
@@ -33287,8 +33258,8 @@ function getVersion() {
 // src/lib/backup-utils.ts
 var import_fs_extra5 = __toESM(require_lib4(), 1);
 import path7 from "path";
-import os7 from "os";
-var BACKUP_BASE_DIR = path7.join(os7.homedir(), ".config", "aiblueprint", "backup");
+import os8 from "os";
+var BACKUP_BASE_DIR = path7.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())}`;
@@ -33320,7 +33291,6 @@ async function createBackup(claudeDir) {
 // src/commands/setup.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
-var GITHUB_RAW_BASE2 = "https://raw.githubusercontent.com/Melvynx/aiblueprint-cli/main/claude-code-config";
 async function setupCommand(params = {}) {
   const {
     claudeCodeFolder: customClaudeCodeFolder,
@@ -33328,6 +33298,7 @@ async function setupCommand(params = {}) {
     openCodeFolder: customOpenCodeFolder,
     skipInteractive
   } = params;
+  let repoPath = null;
   try {
     console.log(source_default.blue.bold(`
 \uD83D\uDE80 AIBlueprint Claude Code Setup ${source_default.gray(`v${getVersion()}`)}
@@ -33415,7 +33386,7 @@ async function setupCommand(params = {}) {
       skipInteractive
     };
     const s = new SimpleSpinner;
-    const claudeDir = customClaudeCodeFolder ? path8.resolve(customClaudeCodeFolder) : path8.join(os8.homedir(), ".claude");
+    const claudeDir = customClaudeCodeFolder ? path8.resolve(customClaudeCodeFolder) : path8.join(os9.homedir(), ".claude");
     console.log(source_default.gray(`Installing to: ${claudeDir}`));
     await import_fs_extra6.default.ensureDir(claudeDir);
     s.start("Creating backup of existing configuration");
@@ -33425,37 +33396,17 @@ async function setupCommand(params = {}) {
     } else {
       s.stop("No existing config to backup");
     }
-    let useGitHub = true;
-    let sourceDir;
-    const testUrl = `${GITHUB_RAW_BASE2}/scripts/validate-command.js`;
-    try {
-      const testResponse = await fetch(testUrl);
-      useGitHub = testResponse.ok;
-    } catch {
-      useGitHub = false;
-    }
-    if (!useGitHub) {
-      const currentDir = process.cwd();
-      const possiblePaths = [
-        path8.join(currentDir, "claude-code-config"),
-        path8.join(__dirname2, "../../claude-code-config"),
-        path8.join(__dirname2, "../claude-code-config"),
-        path8.join(path8.dirname(process.argv[1]), "../claude-code-config")
-      ];
-      sourceDir = possiblePaths.find((p) => {
-        try {
-          return import_fs_extra6.default.existsSync(p);
-        } catch {
-          return false;
-        }
-      });
-      if (!sourceDir) {
-        throw new Error("Could not find claude-code-config directory locally and GitHub is not accessible");
-      }
-      console.log(source_default.yellow("  Using local configuration files (GitHub not accessible)"));
-    } else {
-      console.log(source_default.green("  Downloading latest configuration from GitHub"));
+    s.start("Cloning configuration repository");
+    repoPath = await cloneRepository();
+    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)) {
+      await cleanupRepository(repoPath);
+      throw new Error("Configuration directory not found in cloned repository");
+    }
+    s.stop("Repository cloned successfully");
     if (options.shellShortcuts) {
       s.start("Setting up shell shortcuts");
       await setupShellShortcuts();
@@ -33463,31 +33414,15 @@ async function setupCommand(params = {}) {
     }
     if (options.commandValidation || options.customStatusline || options.notificationSounds) {
       s.start("Setting up scripts");
-      if (useGitHub) {
-        const scriptsDir = path8.join(claudeDir, "scripts");
-        await import_fs_extra6.default.ensureDir(scriptsDir);
-        if (options.commandValidation) {
-          await downloadDirectoryFromGitHub("scripts/command-validator", path8.join(scriptsDir, "command-validator"));
-        }
-        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"));
-        }
+      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");
     }
     if (options.aiblueprintCommands) {
       s.start("Setting up AIBlueprint commands");
-      if (useGitHub) {
-        await downloadDirectoryFromGitHub("commands", path8.join(claudeDir, "commands"));
-      } else {
-        await import_fs_extra6.default.copy(path8.join(sourceDir, "commands"), path8.join(claudeDir, "commands"), { overwrite: true });
-      }
+      await import_fs_extra6.default.copy(path8.join(sourceDir, "commands"), path8.join(claudeDir, "commands"), { overwrite: true });
       s.stop("Commands installed");
     }
     if (options.codexSymlink && options.aiblueprintCommands) {
@@ -33502,48 +33437,22 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
-      if (useGitHub) {
-        await downloadDirectoryFromGitHub("agents", path8.join(claudeDir, "agents"));
-      } else {
-        await import_fs_extra6.default.copy(path8.join(sourceDir, "agents"), path8.join(claudeDir, "agents"), { overwrite: true });
-      }
+      await import_fs_extra6.default.copy(path8.join(sourceDir, "agents"), path8.join(claudeDir, "agents"), { overwrite: true });
       s.stop("Agents installed");
     }
     if (options.aiblueprintSkills) {
       s.start("Setting up AIBlueprint Skills");
-      if (useGitHub) {
-        const testSkillsUrl = `${GITHUB_RAW_BASE2}/skills/create-prompt/SKILL.md`;
-        try {
-          const testResponse = await fetch(testSkillsUrl);
-          if (testResponse.ok) {
-            await downloadDirectoryFromGitHub("skills", path8.join(claudeDir, "skills"));
-            s.stop("Skills installed");
-          } else {
-            s.stop("Skills not available in repository");
-          }
-        } catch {
-          s.stop("Skills not available in repository");
-        }
+      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 });
+        s.stop("Skills installed");
       } else {
-        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 });
-          s.stop("Skills installed");
-        } else {
-          s.stop("Skills not available in local repository");
-        }
+        s.stop("Skills not available in repository");
       }
     }
     if (options.notificationSounds) {
       s.start("Setting up notification sounds");
-      if (useGitHub) {
-        const songDir = path8.join(claudeDir, "song");
-        await import_fs_extra6.default.ensureDir(songDir);
-        await downloadFromGitHub("song/finish.mp3", path8.join(songDir, "finish.mp3"));
-        await downloadFromGitHub("song/need-human.mp3", path8.join(songDir, "need-human.mp3"));
-      } else {
-        await import_fs_extra6.default.copy(path8.join(sourceDir, "song"), path8.join(claudeDir, "song"), { overwrite: true });
-      }
+      await import_fs_extra6.default.copy(path8.join(sourceDir, "song"), path8.join(claudeDir, "song"), { overwrite: true });
       s.stop("Notification sounds installed");
     }
     if (options.customStatusline) {
@@ -33574,11 +33483,14 @@ async function setupCommand(params = {}) {
     s.start("Updating settings.json");
     await updateSettings(options, claudeDir);
     s.stop("Settings updated");
+    s.start("Cleaning up temporary files");
+    await cleanupRepository(repoPath);
+    s.stop("Cleanup complete");
     console.log(source_default.green("✨ Setup complete!"));
     console.log(source_default.gray(`
 Next steps:`));
     if (options.shellShortcuts) {
-      const platform = os8.platform();
+      const platform = os9.platform();
       if (platform === "win32") {
         console.log(source_default.gray("  • Restart PowerShell to load the new functions"));
       } else {
@@ -33594,6 +33506,9 @@ Next steps:`));
     console.error(source_default.red(`
 ❌ Setup failed:`), error);
     console.log(source_default.red("Setup failed!"));
+    if (repoPath) {
+      await cleanupRepository(repoPath);
+    }
     process.exit(1);
   }
 }
@@ -33601,8 +33516,8 @@ 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";
+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";
 var INSTALL_TIMEOUT = 120000;
 var PLUGIN_TIMEOUT = 60000;
@@ -33684,7 +33599,7 @@ 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) => {
+    exec2(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
           reject(new Error("Oh My ZSH installation timed out. Please check your network connection."));
@@ -33709,7 +33624,7 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
     return;
   }
   return new Promise((resolve, reject) => {
-    exec(`git clone ${repoUrl} "${customPluginsDir}"`, { timeout: PLUGIN_TIMEOUT }, (error, stdout, stderr) => {
+    exec2(`git clone ${repoUrl} "${customPluginsDir}"`, { timeout: PLUGIN_TIMEOUT }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
           reject(new Error(`Plugin ${pluginName} installation timed out. Please check your network connection.`));
@@ -33768,7 +33683,7 @@ plugins=(${pluginsString})`;
 }
 async function setupTerminalCommand(options = {}) {
   const { skipInteractive, homeDir: customHomeDir } = options;
-  const homeDir = customHomeDir || os9.homedir();
+  const homeDir = customHomeDir || os10.homedir();
   try {
     console.log(source_default.blue.bold(`
 \uD83D\uDDA5️  AIBlueprint Terminal Setup ${source_default.gray(`v${getVersion()}`)}
@@ -34081,52 +33996,6 @@ async function symlinkCommand(params = {}) {
   }
 }
 
-// src/commands/statusline.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
-import path10 from "path";
-import { homedir } from "os";
-async function statuslineCommand(options) {
-  const claudeDir = options.folder ? path10.resolve(options.folder) : path10.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_extra8.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 = path10.join(claudeDir, "scripts");
-  await import_fs_extra8.default.ensureDir(scriptsDir);
-  const success = await downloadDirectoryFromGitHub("scripts/statusline", path10.join(scriptsDir, "statusline"));
-  if (!success) {
-    console.log(source_default.red("  Failed to download statusline files from GitHub"));
-    return;
-  }
-  console.log(source_default.cyan(`
-\uD83D\uDCE6 Installing statusline dependencies...`));
-  await installStatuslineDependencies(claudeDir);
-  console.log(source_default.cyan(`
-⚙️  Configuring settings.json...`));
-  const settingsPath = path10.join(claudeDir, "settings.json");
-  let settings = {};
-  try {
-    const existingSettings = await import_fs_extra8.default.readFile(settingsPath, "utf-8");
-    settings = JSON.parse(existingSettings);
-  } catch {}
-  settings.statusLine = {
-    type: "command",
-    command: `bun ${path10.join(claudeDir, "scripts/statusline/src/index.ts")}`,
-    padding: 0
-  };
-  await import_fs_extra8.default.writeJson(settingsPath, settings, { spaces: 2 });
-  console.log(source_default.green(`
-✅ Statusline setup complete!`));
-  console.log(source_default.gray(`
-Your Claude Code statusline is now configured.`));
-  console.log(source_default.gray(`Restart Claude Code to see the changes.
-`));
-}
-
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -34843,26 +34712,26 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import os12 from "os";
-import path13 from "path";
+import os13 from "os";
+import path12 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
-import os10 from "os";
-import path11 from "path";
-import { exec as exec2 } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec2);
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import os11 from "os";
+import path10 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 path11.join(os10.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path10.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?:\/\//, "")}`;
   const fullCommand = `git ${command.replace(repoUrl, authenticatedUrl)}`;
   try {
-    await execAsync(fullCommand, { cwd, timeout: 120000 });
+    await execAsync2(fullCommand, { cwd, timeout: 120000 });
   } catch (error) {
     throw new Error(`Git command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
@@ -34870,33 +34739,33 @@ 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_extra9.default.pathExists(path11.join(cacheDir, ".git"))) {
+  if (await import_fs_extra8.default.pathExists(path10.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra9.default.remove(cacheDir);
-      await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
+      await import_fs_extra8.default.remove(cacheDir);
+      await import_fs_extra8.default.ensureDir(path10.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
+    await import_fs_extra8.default.ensureDir(path10.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path11.join(cacheDir, "claude-code-config");
+  return path10.join(cacheDir, "claude-code-config");
 }
 async function copyConfigFromCache(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra9.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra8.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path11.join(dir, entry.name);
-      const relativePath = path11.relative(baseDir, sourcePath);
-      const targetPath = path11.join(targetDir, relativePath);
+      const sourcePath = path10.join(dir, entry.name);
+      const relativePath = path10.relative(baseDir, sourcePath);
+      const targetPath = path10.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra9.default.ensureDir(targetPath);
+        await import_fs_extra8.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra9.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra8.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -34917,8 +34786,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
-    await import_fs_extra9.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra8.default.ensureDir(path10.dirname(targetPath));
+    await import_fs_extra8.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -34943,10 +34812,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra9.default.ensureDir(targetDir);
+    await import_fs_extra8.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path11.join(targetDir, file.name);
+      const targetPath = path10.join(targetDir, file.name);
       const displayPath = relativePath.replace("claude-code-config/", "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -34963,7 +34832,7 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
 }
 async function installProConfigs(options) {
   const { githubToken, claudeCodeFolder, onProgress } = options;
-  const claudeFolder = claudeCodeFolder || path11.join(os10.homedir(), ".claude");
+  const claudeFolder = claudeCodeFolder || path10.join(os11.homedir(), ".claude");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
     await copyConfigFromCache(cacheConfigDir, claudeFolder, onProgress);
@@ -34971,53 +34840,53 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path11.join(os10.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path10.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_extra9.default.copy(tempDir, claudeFolder, {
+    await import_fs_extra8.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_extra9.default.remove(tempDir);
+      await import_fs_extra8.default.remove(tempDir);
     } catch {}
   }
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
-import os11 from "os";
-import path12 from "path";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import os12 from "os";
+import path11 from "path";
 function getConfigDir() {
-  const platform = os11.platform();
+  const platform = os12.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path12.join(os11.homedir(), "AppData", "Roaming");
-    return path12.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path11.join(os12.homedir(), "AppData", "Roaming");
+    return path11.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path12.join(os11.homedir(), ".config");
-    return path12.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path11.join(os12.homedir(), ".config");
+    return path11.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath() {
-  return path12.join(getConfigDir(), "token.txt");
+  return path11.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath();
-  await import_fs_extra10.default.ensureDir(path12.dirname(tokenFile));
-  await import_fs_extra10.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra9.default.ensureDir(path11.dirname(tokenFile));
+  await import_fs_extra9.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath();
-  if (!await import_fs_extra10.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra9.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra10.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra9.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35026,12 +34895,12 @@ async function getToken() {
 function getTokenInfo() {
   return {
     path: getTokenFilePath(),
-    platform: os11.platform()
+    platform: os12.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
+var import_fs_extra10 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -35041,29 +34910,29 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const commandsDir = path13.join(claudeDir, "commands");
-    if (await import_fs_extra11.default.pathExists(commandsDir)) {
-      const files = await import_fs_extra11.default.readdir(commandsDir);
+    const commandsDir = path12.join(claudeDir, "commands");
+    if (await import_fs_extra10.default.pathExists(commandsDir)) {
+      const files = await import_fs_extra10.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 = path13.join(claudeDir, "agents");
-    if (await import_fs_extra11.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra11.default.readdir(agentsDir);
+    const agentsDir = path12.join(claudeDir, "agents");
+    if (await import_fs_extra10.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra10.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 = path13.join(claudeDir, "skills");
-    if (await import_fs_extra11.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra11.default.readdir(skillsDir);
+    const skillsDir = path12.join(claudeDir, "skills");
+    if (await import_fs_extra10.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra10.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra11.default.stat(path13.join(skillsDir, item));
+        const stat = await import_fs_extra10.default.stat(path12.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35176,7 +35045,7 @@ async function proSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path13.resolve(options.folder) : path13.join(os12.homedir(), ".claude");
+    const claudeDir = options.folder ? path12.resolve(options.folder) : path12.join(os13.homedir(), ".claude");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -35258,12 +35127,12 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/commands/sync.ts
-import os13 from "os";
-import path15 from "path";
+import os14 from "os";
+import path14 from "path";
 
 // src/lib/sync-utils.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
-import path14 from "path";
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import path13 from "path";
 import crypto from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -35312,7 +35181,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra12.default.readFile(filePath);
+    const content = await import_fs_extra11.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -35320,15 +35189,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra12.default.pathExists(dir)) {
+  if (!await import_fs_extra11.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra12.default.readdir(dir);
+  const items = await import_fs_extra11.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path14.join(dir, item);
-    const stat = await import_fs_extra12.default.stat(fullPath);
+    const fullPath = path13.join(dir, item);
+    const stat = await import_fs_extra11.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(item);
       const subFiles = await listLocalFilesRecursive(fullPath, item);
@@ -35341,13 +35210,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra12.default.readdir(dir);
+  const items = await import_fs_extra11.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path14.join(dir, item);
+    const fullPath = path13.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra12.default.stat(fullPath);
+    const stat = await import_fs_extra11.default.stat(fullPath);
     if (stat.isDirectory()) {
       files.push(relativePath);
       const subFiles = await listLocalFilesRecursive(fullPath, relativePath);
@@ -35360,7 +35229,7 @@ async function listLocalFilesRecursive(dir, basePath) {
 }
 async function analyzeCategory(category, claudeDir, githubToken) {
   const items = [];
-  const localDir = path14.join(claudeDir, category);
+  const localDir = path13.join(claudeDir, category);
   const remoteFiles = await listRemoteFilesRecursive(category, githubToken);
   const localFiles = await listLocalFiles(localDir);
   const remoteSet = new Map;
@@ -35369,7 +35238,7 @@ async function analyzeCategory(category, claudeDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path14.join(localDir, remotePath);
+    const localPath = path13.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -35412,8 +35281,8 @@ async function analyzeCategory(category, claudeDir, githubToken) {
       if (parentAlreadyDeleted) {
         continue;
       }
-      const fullPath = path14.join(localDir, localPath);
-      const stat = await import_fs_extra12.default.stat(fullPath).catch(() => null);
+      const fullPath = path13.join(localDir, localPath);
+      const stat = await import_fs_extra11.default.stat(fullPath).catch(() => null);
       if (stat) {
         const isFolder = stat.isDirectory();
         items.push({
@@ -35449,9 +35318,9 @@ async function fetchRemoteSettings(githubToken) {
   }
 }
 async function getLocalSettings(claudeDir) {
-  const settingsPath = path14.join(claudeDir, "settings.json");
+  const settingsPath = path13.join(claudeDir, "settings.json");
   try {
-    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra11.default.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -35533,8 +35402,8 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken)
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra12.default.ensureDir(path14.dirname(targetPath));
-    await import_fs_extra12.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra11.default.ensureDir(path13.dirname(targetPath));
+    await import_fs_extra11.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch {
     return false;
@@ -35544,10 +35413,10 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
   if (hooks.length === 0) {
     return { success: 0, failed: 0 };
   }
-  const settingsPath = path14.join(claudeDir, "settings.json");
+  const settingsPath = path13.join(claudeDir, "settings.json");
   let settings = {};
   try {
-    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
+    const content = await import_fs_extra11.default.readFile(settingsPath, "utf-8");
     settings = JSON.parse(content);
   } catch {
     settings = {};
@@ -35575,7 +35444,7 @@ async function syncSelectedHooks(claudeDir, hooks, onProgress) {
       failed++;
     }
   }
-  await import_fs_extra12.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await import_fs_extra11.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
   return { success, failed };
 }
 async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
@@ -35583,11 +35452,11 @@ async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
   let failed = 0;
   let deleted = 0;
   for (const item of items) {
-    const targetPath = path14.join(claudeDir, item.relativePath);
+    const targetPath = path13.join(claudeDir, item.relativePath);
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra12.default.remove(targetPath);
+        await import_fs_extra11.default.remove(targetPath);
         deleted++;
       } catch {
         failed++;
@@ -35739,7 +35608,7 @@ async function proSyncCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path15.resolve(options.folder) : path15.join(os13.homedir(), ".claude");
+    const claudeDir = options.folder ? path14.resolve(options.folder) : path14.join(os14.homedir(), ".claude");
     const spinner = Y2();
     spinner.start("Analyzing changes...");
     const result = await analyzeSyncChanges(claudeDir, githubToken);
@@ -35967,10 +35836,170 @@ async function proSyncCommand(options = {}) {
   }
 }
 
+// src/commands/dynamic-scripts.ts
+import path17 from "path";
+import { homedir } from "os";
+
+// src/lib/script-parser.ts
+var import_fs_extra12 = __toESM(require_lib4(), 1);
+import path15 from "path";
+var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
+var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
+function shouldIncludeScript(scriptName) {
+  if (EXCLUDED_SCRIPTS.includes(scriptName))
+    return false;
+  if (EXCLUDED_SUFFIXES.some((suffix) => scriptName.endsWith(suffix)))
+    return false;
+  return true;
+}
+async function readScriptsPackageJson(claudeDir) {
+  const packageJsonPath = path15.join(claudeDir, "scripts", "package.json");
+  try {
+    if (!await import_fs_extra12.default.pathExists(packageJsonPath)) {
+      return null;
+    }
+    const content = await import_fs_extra12.default.readFile(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed.scripts || null;
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.error("Failed to read scripts package.json:", error);
+    }
+    return null;
+  }
+}
+function parseScriptCommands(scripts) {
+  const commands = [];
+  for (const scriptName of Object.keys(scripts)) {
+    if (!shouldIncludeScript(scriptName)) {
+      continue;
+    }
+    if (!scriptName.includes(":")) {
+      continue;
+    }
+    const [prefix, ...actionParts] = scriptName.split(":");
+    const action = actionParts.join(":");
+    if (!action) {
+      continue;
+    }
+    commands.push({
+      prefix,
+      action,
+      fullScriptName: scriptName
+    });
+  }
+  return commands;
+}
+function groupScriptsByPrefix(commands) {
+  const groups = {};
+  for (const command of commands) {
+    if (!groups[command.prefix]) {
+      groups[command.prefix] = [];
+    }
+    groups[command.prefix].push(command.action);
+  }
+  return groups;
+}
+
+// src/commands/script-runner.ts
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import { spawn as spawn2 } from "child_process";
+import { execSync as execSync4 } from "child_process";
+import path16 from "path";
+import os15 from "os";
+function checkCommand(cmd) {
+  try {
+    const isWindows = os15.platform() === "win32";
+    const whichCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
+    execSync4(whichCmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function showAvailableActions(prefix, actions) {
+  console.log(source_default.blue(`
+${prefix.charAt(0).toUpperCase() + prefix.slice(1)} Scripts:`));
+  console.log(source_default.gray(`Run scripts from ~/.claude/scripts
+`));
+  for (const action of actions) {
+    console.log(source_default.white(`  ${prefix} ${action}`));
+  }
+  console.log(source_default.gray(`
+Usage: aiblueprint ${prefix} <action>`));
+  console.log(source_default.gray(`Example: aiblueprint ${prefix} ${actions[0] || "start"}
+`));
+}
+async function executeScript(scriptName, claudeDir) {
+  if (!checkCommand("bun")) {
+    console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
+    return 1;
+  }
+  const scriptsDir = path16.join(claudeDir, "scripts");
+  if (!await import_fs_extra13.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 = path16.join(scriptsDir, "package.json");
+  if (!await import_fs_extra13.default.pathExists(packageJsonPath)) {
+    console.error(source_default.red(`package.json not found in ${scriptsDir}`));
+    return 1;
+  }
+  const packageJson = await import_fs_extra13.default.readJson(packageJsonPath);
+  if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
+    console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
+    return 1;
+  }
+  return new Promise((resolve) => {
+    const child = spawn2("bun", ["run", scriptName], {
+      cwd: scriptsDir,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("close", (code) => {
+      resolve(code || 0);
+    });
+    child.on("error", (error) => {
+      console.error(source_default.red(`Failed to execute script: ${error.message}`));
+      resolve(1);
+    });
+  });
+}
+
+// src/commands/dynamic-scripts.ts
+function getClaudeDir(parentOptions) {
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path17.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path17.join(homedir(), ".claude");
+}
+async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
+  const scripts = await readScriptsPackageJson(claudeDir);
+  if (!scripts) {
+    return;
+  }
+  const commands = parseScriptCommands(scripts);
+  if (commands.length === 0) {
+    return;
+  }
+  const scriptGroups = groupScriptsByPrefix(commands);
+  for (const [prefix, actions] of Object.entries(scriptGroups)) {
+    const command = claudeCodeCmd.command(`${prefix} [action]`).description(`Run ${prefix} scripts from ~/.claude/scripts`).option("-l, --list", "List available actions").action(async (action, options) => {
+      const parentOptions = command.parent?.opts() || {};
+      const resolvedClaudeDir = getClaudeDir(parentOptions);
+      if (options.list || !action) {
+        showAvailableActions(prefix, actions);
+        return;
+      }
+      const exitCode = await executeScript(`${prefix}:${action}`, resolvedClaudeDir);
+      process.exit(exitCode);
+    });
+  }
+}
+
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname3, join as join2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+import { homedir as homedir2 } from "os";
 var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
 var packageJson = JSON.parse(readFileSync3(join2(__dirname3, "../package.json"), "utf8"));
 var program2 = new Command;
@@ -36001,11 +36030,6 @@ claudeCodeCmd.command("symlink").description("Create symlinks between different
     factoryAiFolder: parentOptions.factoryAiFolder
   });
 });
-claudeCodeCmd.command("statusline").description("Setup custom statusline with git status, costs, and token usage").action((options, command) => {
-  const parentOptions = command.parent.opts();
-  const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
-  statuslineCommand({ folder: claudeCodeFolder });
-});
 var proCmd = claudeCodeCmd.command("pro").description("Manage AIBlueprint CLI Premium features");
 proCmd.command("activate [token]").description("Activate AIBlueprint CLI Premium with your access token").action((token) => {
   proActivateCommand(token);
@@ -36028,6 +36052,14 @@ proCmd.command("sync").description("Sync premium configurations with selective u
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
   proSyncCommand({ folder: claudeCodeFolder });
 });
+try {
+  const claudeDir = join2(homedir2(), ".claude");
+  await registerDynamicScriptCommands(claudeCodeCmd, claudeDir);
+} catch (error) {
+  if (process.env.DEBUG) {
+    console.error("Failed to register dynamic commands:", error);
+  }
+}
 program2.parse(process.argv);
 if (!process.argv.slice(2).length) {
   console.log(source_default.blue("\uD83D\uDE80 AIBlueprint CLI"));