aiblueprint-cli 1.4.23 → 1.4.25

package/dist/cli.js

@@ -33301,6 +33301,44 @@ 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);
+  if (!exists) {
+    return [];
+  }
+  const entries = await import_fs_extra5.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})$/);
+    if (!match)
+      continue;
+    const [, year, month, day, hour, minute, second] = match;
+    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),
+      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);
+  if (!exists) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  await import_fs_extra5.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 });
+    }
+  }
+}
 async function createBackup(claudeDir) {
   const exists = await import_fs_extra5.default.pathExists(claudeDir);
   if (!exists) {
@@ -35732,6 +35770,22 @@ async function proSyncCommand(options = {}) {
     if (syncMode === "updates") {
       selectedItems = [...newItems, ...modifiedItems];
     } else if (syncMode === "updates_and_delete") {
+      M2.message("");
+      M2.message(source_default.red.bold("⚠️  WARNING: DESTRUCTIVE ACTION"));
+      M2.message(source_default.red("━".repeat(50)));
+      M2.message(source_default.red("All your custom skills, commands, agents, and configuration files"));
+      M2.message(source_default.red("that are not in the premium version will be PERMANENTLY DELETED"));
+      M2.message(source_default.red("and replaced by the new version."));
+      M2.message(source_default.red("━".repeat(50)));
+      M2.message("");
+      const deleteConfirm = await ye({
+        message: source_default.red.bold("Are you sure you want to delete and replace all files?"),
+        initialValue: false
+      });
+      if (pD(deleteConfirm) || !deleteConfirm) {
+        xe("Sync cancelled");
+        process.exit(0);
+      }
       selectedItems = [...newItems, ...modifiedItems, ...deletedItems];
     } else {
       const fileChoices = choices.filter((c) => c.value.type !== "hook");
@@ -35879,13 +35933,90 @@ async function proSyncCommand(options = {}) {
   }
 }
 
+// src/commands/backup.ts
+import os15 from "os";
+import path15 from "path";
+function formatBackupDate(date) {
+  const now = new Date;
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffMinutes = Math.floor(diffMs / (1000 * 60));
+  let relative;
+  if (diffMinutes < 60) {
+    relative = `${diffMinutes} minute${diffMinutes !== 1 ? "s" : ""} ago`;
+  } else if (diffHours < 24) {
+    relative = `${diffHours} hour${diffHours !== 1 ? "s" : ""} ago`;
+  } else if (diffDays < 7) {
+    relative = `${diffDays} day${diffDays !== 1 ? "s" : ""} ago`;
+  } else {
+    relative = date.toLocaleDateString();
+  }
+  return `${date.toLocaleString()} (${relative})`;
+}
+async function backupLoadCommand(options = {}) {
+  const claudeDir = options.folder || path15.join(os15.homedir(), ".claude");
+  Ie(source_default.blue("\uD83D\uDCE6 Load Backup"));
+  const spinner = Y2();
+  spinner.start("Scanning for backups...");
+  const backups = await listBackups();
+  spinner.stop(`Found ${backups.length} backup${backups.length !== 1 ? "s" : ""}`);
+  if (backups.length === 0) {
+    M2.warn("No backups found in ~/.config/aiblueprint/backup/");
+    M2.info("Backups are created automatically when you run setup or sync commands.");
+    Se(source_default.gray("Nothing to restore"));
+    return;
+  }
+  const backupOptions = backups.map((backup) => ({
+    value: backup,
+    label: backup.name,
+    hint: formatBackupDate(backup.date)
+  }));
+  const selected = await ve({
+    message: "Select a backup to restore:",
+    options: backupOptions
+  });
+  if (pD(selected)) {
+    xe("Operation cancelled");
+    process.exit(0);
+  }
+  M2.info(`Selected: ${source_default.cyan(selected.name)}`);
+  M2.info(`Date: ${source_default.gray(formatBackupDate(selected.date))}`);
+  const confirm = await ye({
+    message: `This will overwrite your current configuration in ${source_default.cyan(claudeDir)}. Continue?`,
+    initialValue: false
+  });
+  if (pD(confirm) || !confirm) {
+    xe("Operation cancelled");
+    process.exit(0);
+  }
+  spinner.start("Creating backup of current configuration...");
+  const currentBackup = await createBackup(claudeDir);
+  if (currentBackup) {
+    spinner.stop(`Current config backed up to: ${source_default.gray(currentBackup)}`);
+  } else {
+    spinner.stop("No current config to backup");
+  }
+  spinner.start("Restoring backup...");
+  try {
+    await loadBackup(selected.path, claudeDir);
+    spinner.stop("Backup restored successfully");
+    M2.success(`Restored configuration from ${source_default.cyan(selected.name)}`);
+    Se(source_default.green("✅ Backup loaded successfully"));
+  } catch (error) {
+    spinner.stop("Restore failed");
+    M2.error(`Failed to restore backup: ${error}`);
+    process.exit(1);
+  }
+}
+
 // src/commands/dynamic-scripts.ts
-import path17 from "path";
+import path18 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
 var import_fs_extra12 = __toESM(require_lib4(), 1);
-import path15 from "path";
+import path16 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -35896,7 +36027,7 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path15.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path16.join(claudeDir, "scripts", "package.json");
   try {
     if (!await import_fs_extra12.default.pathExists(packageJsonPath)) {
       return null;
@@ -35948,11 +36079,11 @@ function groupScriptsByPrefix(commands) {
 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";
+import path17 from "path";
+import os16 from "os";
 function checkCommand(cmd) {
   try {
-    const isWindows = os15.platform() === "win32";
+    const isWindows = os16.platform() === "win32";
     const whichCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
     execSync4(whichCmd, { stdio: "ignore" });
     return true;
@@ -35978,13 +36109,13 @@ async function executeScript(scriptName, claudeDir) {
     console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
     return 1;
   }
-  const scriptsDir = path16.join(claudeDir, "scripts");
+  const scriptsDir = path17.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");
+  const packageJsonPath = path17.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;
@@ -36012,7 +36143,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path17.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path17.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path18.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path18.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -36095,6 +36226,12 @@ proCmd.command("sync").description("Sync premium configurations with selective u
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
   proSyncCommand({ folder: claudeCodeFolder });
 });
+var backupCmd = claudeCodeCmd.command("backup").description("Manage Claude Code configuration backups");
+backupCmd.command("load").description("Load a previous backup interactively").action((options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
+  backupLoadCommand({ folder: claudeCodeFolder });
+});
 try {
   const claudeDir = join2(homedir2(), ".claude");
   await registerDynamicScriptCommands(claudeCodeCmd, claudeDir);

package/package.json

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

package/claude-code-config/commands/explore.md

@@ -1,90 +0,0 @@
----
-description: Deep exploration of codebase, docs, and web for any topic or question
-argument-hint: <topic-or-question>
----
-
-You are an exploration specialist. Your mission is to gather comprehensive context about a topic.
-
-**ULTRA THINK before launching agents.**
-
-## Workflow
-
-1. **ULTRA THINK**: Plan exploration strategy
-   - Identify key concepts, files, patterns to find
-   - Determine which sources need exploration (codebase/docs/web)
-   - List specific questions each agent should answer
-   - **CRITICAL**: Know EXACTLY what to search for before launching agents
-
-2. **LAUNCH PARALLEL EXPLORATION**: Gather context from all sources
-
-   Launch ALL relevant agents in parallel in a single message.
-   Scale agent count based on complexity:
-
-   - **Codebase exploration** (`explore-codebase` agents):
-     - Simple topic: 1 agent for general search
-     - Complex topic: 2-3 agents for different aspects
-     - Multi-area: 1 agent per codebase area
-
-     Each agent should:
-     - Find related implementations and examples
-     - Locate relevant files and patterns
-     - Identify existing conventions and utilities
-     - Search for related helpers and abstractions
-
-   - **Documentation exploration** (`explore-docs` agents):
-     - Single library: 1 agent with focused topics
-     - Multiple libraries: 1 agent per library
-     - Complex integration: agents for each + integration
-
-     Each agent should:
-     - Search library docs for APIs and patterns
-     - Find best practices for tools being used
-     - Gather code examples from official docs
-
-   - **Web research** (`websearch` agents):
-     - Simple question: 1 agent
-     - Multi-faceted topic: 2-3 agents for different angles
-
-     Each agent should:
-     - Research latest approaches and solutions
-     - Find community examples and patterns
-     - Gather architectural guidance
-
-   ## Agent Scaling Guide
-
-   | Complexity | Codebase | Docs | Web |
-   |-----------|----------|------|-----|
-   | Simple | 1 | 1 | 1 |
-   | Medium | 2 | 1-2 | 1 |
-   | Complex | 2-3 | 2-3 | 2 |
-   | Multi-library | 1-2 | 1 per lib | 1-2 |
-
-3. **SYNTHESIZE FINDINGS**: Combine and organize results
-   - Merge findings from all agents
-   - Organize by topic/concern
-   - Include file paths with line numbers (e.g., `src/auth.ts:42`)
-   - Highlight key patterns and examples found
-   - Note any dependencies or prerequisites
-
-4. **REPORT**: Present findings to user
-   - **Key Files**: List relevant files with purposes
-   - **Patterns**: Existing conventions to follow
-   - **Examples**: Code snippets and implementations found
-   - **Documentation**: Key insights from docs
-   - **Recommendations**: Suggested approaches based on findings
-
-## Execution Rules
-
-- **PARALLEL EXECUTION**: All agents must run simultaneously for speed
-- **ULTRA THINK FIRST**: Never launch agents without clear search strategy
-- **COMPREHENSIVE**: Gather more context than seems necessary
-- **FILE REFERENCES**: Always include file paths with line numbers
-- **NO FILES**: Do NOT create any files - output findings directly
-
-## Priority
-
-Context depth > Speed. Thorough exploration prevents implementation issues.
-
----
-
-User: #$ARGUMENTS

package/claude-code-config/commands/git/commit.md

@@ -1,60 +0,0 @@
----
-description: Quick commit and push with minimal, clean messages
-model: haiku
-allowed-tools: Bash(git :*), Bash(npm :*), Bash(pnpm :*)
----
-
-<objective>
-Quickly analyze git changes and create a conventional commit message following the commitizen format (e.g., "update(statusline): refresh spend data"). This command prioritizes speed and efficiency for straightforward commits.
-</objective>
-
-<context>
-Git state: !`git status`
-Staged changes: !`git diff --cached --stat`
-Unstaged changes: !`git diff --stat`
-Recent commits: !`git log --oneline -5`
-Current branch: !`git branch --show-current`
-</context>
-
-<process>
-1. **Analyze changes**: Review git status to determine what needs to be committed
-   - If nothing staged but unstaged changes exist: stage all changes with `git add .`
-   - If nothing to commit: inform user and exit
-
-2. **Determine commit type and scope**:
-   - Types: `feat`, `fix`, `update`, `docs`, `chore`, `refactor`, `test`, `perf`, `revert`
-   - Scope: Identify the main area affected (e.g., `statusline`, `auth`, `api`, `ui`, `commands`)
-   - Use `update` for refreshing/updating existing features
-   - Use `feat` for new features
-   - Use `fix` for bug fixes
-
-3. **Generate commit message**:
-   - Format: `type(scope): brief description`
-   - Keep it under 72 characters
-   - Use imperative mood ("add" not "added")
-   - Start description with lowercase
-   - Be specific but concise
-   - Example: `update(statusline): refresh spend data`
-
-4. **Create commit**: Execute `git commit -m "message"` immediately with the generated message
-
-5. **Push changes**: After successful commit, push to remote with `git push`
-</process>
-
-<success_criteria>
-- Changes properly staged if needed
-- Commit message follows format: `type(scope): description`
-- Commit created successfully
-- Changes pushed to remote
-- No errors during git operations
-</success_criteria>
-
-<rules>
-- **SPEED OVER PERFECTION**: Generate one good commit message and commit immediately
-- **NO INTERACTION**: Never use AskUserQuestion - just analyze and commit
-- **AUTO-STAGE**: If changes exist but nothing staged, stage everything
-- **AUTO-PUSH**: Always push after committing
-- **MINIMAL OUTPUT**: Brief confirmation of what was committed
-- **IMPERATIVE MOOD**: Use "add", "update", "fix", not past tense
-- **LOWERCASE**: Description starts lowercase after colon
-</rules>

package/claude-code-config/commands/git/fix-pr-comments.md

@@ -1,59 +0,0 @@
----
-description: Fetch PR review comments and implement all requested changes
-allowed-tools: Bash(gh :*), Bash(git :*), Read, Edit, MultiEdit
----
-
-You are a PR review resolver. **Systematically address ALL unresolved review comments until PR is approved.**
-
-## Context
-
-- Current branch: !`git branch --show-current`
-- Working tree status: !`git status --short`
-- Recent commits: !`git log --oneline -3`
-
-## Workflow
-
-1. **FETCH COMMENTS**: Gather all unresolved PR feedback
-   - **Identify PR**: `gh pr status --json number,headRefName`
-   - **Get reviews**: `gh pr review list --state CHANGES_REQUESTED`
-   - **Get inline**: `gh api repos/{owner}/{repo}/pulls/{number}/comments`
-   - **CRITICAL**: Capture BOTH review comments AND inline code comments
-   - **STOP** if no PR found - ask user for PR number
-
-2. **ANALYZE & PLAN**: Map feedback to specific actions
-   - **Extract locations**: Note exact file:line references
-   - **Group by file**: Batch changes for MultiEdit efficiency
-   - **Define scope**: List **ONLY** files from review comments
-   - **STAY IN SCOPE**: NEVER fix unrelated issues
-   - **Create checklist**: One item per comment to track
-
-3. **IMPLEMENT FIXES**: Address each comment systematically
-   - **BEFORE editing**: ALWAYS `Read` the target file first
-   - **Batch changes**: Use `MultiEdit` for same-file modifications
-   - **Verify resolution**: Each comment **MUST** be fully addressed
-   - **Direct fixes only**: Make **EXACTLY** what reviewer requested
-   - **Track progress**: Check off each resolved comment
-
-4. **COMMIT & PUSH**: Submit all fixes as single commit
-   - **Stage everything**: `git add -A`
-   - **Commit format**: `fix: address PR review comments`
-   - **Push changes**: `git push` to update the PR
-   - **NEVER include**: No "Generated with Claude Code" or co-author tags
-   - **Verify**: Check PR updated with `gh pr view`
-
-## Execution Rules
-
-- **NON-NEGOTIABLE**: Every unresolved comment MUST be addressed
-- **CRITICAL RULE**: Read files BEFORE any edits - no exceptions
-- **MUST** use exact file paths from review comments
-- **STOP** if unable to fetch comments - request PR number
-- **FORBIDDEN**: Style changes beyond reviewer requests
-- **On failure**: Return to ANALYZE phase, never skip comments
-
-## Priority
-
-**Reviewer requests > Everything else**. STAY IN SCOPE - fix ONLY what was requested.
-
----
-
-User: #$ARGUMENTS

package/claude-code-config/commands/oneshot.md

@@ -1,57 +0,0 @@
----
-description: Ultra-fast feature implementation - Explore then Code then Test
-argument-hint: <feature-description>
----
-
-<objective>
-Implement #$ARGUMENTS at maximum speed using the OneShot methodology.
-
-This workflow prioritizes rapid delivery through surgical exploration, immediate implementation, and focused validation. Speed over completeness - ship fast, iterate later.
-</objective>
-
-<process>
-1. **EXPLORE** (5-10 min max):
-   - Launch 1-2 parallel subagents maximum to find relevant files
-   - Use `explore-codebase` for codebase search
-   - Use `explore-docs` ONLY if library-specific knowledge needed
-   - Find files to use as examples or edit targets
-   - Be surgical - know exactly what to search for
-   - NO PLANNING PHASE - gather context and move to coding
-
-2. **CODE** (implement immediately):
-   - Start coding as soon as basic context available
-   - Follow existing codebase patterns and style
-   - Prefer clear variable/method names over comments
-   - Stay STRICTLY in scope - change only what's needed
-   - NO comments unless absolutely necessary
-   - NO refactoring beyond feature requirements
-   - Run autoformatting scripts when done
-   - Fix reasonable linter warnings as you go
-
-3. **TEST** (validate quality):
-   - Check package.json for available scripts (lint, typecheck, format)
-   - Run: `npm run lint && npm run typecheck` (or equivalent)
-   - If checks fail: fix errors immediately and re-run
-   - Stay in scope - don't run full test suite unless requested
-   - For major changes only: run relevant tests with `npm test -- <pattern>`
-     </process>
-
-<rules>
-**Critical constraints:**
-- SPEED IS PRIORITY: Move fast, break nothing
-- NO PLANNING: Trust exploration and code directly
-- PARALLEL AGENTS: Max 2 agents during explore phase
-- MINIMAL TESTS: Lint + typecheck only (unless user requests more)
-- STAY FOCUSED: Implement exactly what's requested, nothing more
-- ULTRA THINK: Always engage deep reasoning for optimal solutions
-- If stuck or uncertain: ask user immediately instead of over-exploring
-</rules>
-
-<success_criteria>
-
-- Feature implemented following existing codebase patterns
-- Code passes linting and type checking
-- Implementation stays strictly within requested scope
-- No unnecessary comments or refactoring
-- Autoformatting applied where available
-  </success_criteria>