aiblueprint-cli 1.4.24 → 1.4.25

package/claude-code-config/skills/workflow-apex-free/templates/README.md

@@ -0,0 +1,176 @@
+# APEX Template System
+
+## Overview
+
+This directory contains template files used to initialize APEX workflow outputs when save mode (`-s`) is enabled. This template system significantly reduces token usage by moving repetitive content out of step files.
+
+## Template Files
+
+| Template | Purpose | Created When |
+|----------|---------|--------------|
+| `00-context.md` | Workflow configuration and progress tracking | Always (if save_mode) |
+| `01-analyze.md` | Analysis findings | Always (if save_mode) |
+| `02-plan.md` | Implementation plan | Always (if save_mode) |
+| `03-execute.md` | Implementation log | Always (if save_mode) |
+| `04-validate.md` | Validation results and workflow completion | Always (if save_mode) |
+| `step-complete.md` | Completion marker template | Referenced in steps |
+
+## Template Variables
+
+Templates use `{{variable}}` syntax for placeholders:
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{task_id}}` | Kebab-case task identifier | `01-add-auth-middleware` |
+| `{{task_description}}` | Plain text task description | `add authentication middleware` |
+| `{{timestamp}}` | ISO 8601 timestamp | `2026-01-12T10:30:00Z` |
+| `{{auto_mode}}` | Auto mode flag | `true` or `false` |
+| `{{save_mode}}` | Save mode flag | `true` or `false` |
+| `{{economy_mode}}` | Economy mode flag | `true` or `false` |
+| `{{branch_mode}}` | Branch mode flag | `true` or `false` |
+| `{{interactive_mode}}` | Interactive mode flag | `true` or `false` |
+| `{{branch_name}}` | Git branch name | `feature/add-auth` |
+| `{{original_input}}` | Raw user input | `/apex -a -s add auth` |
+
+## Setup Script
+
+### `setup-templates.sh`
+
+Initializes all template files in the output directory with variables replaced.
+
+**Usage:**
+```bash
+bash scripts/setup-templates.sh \
+  "feature_name" \
+  "task_description" \
+  "auto_mode" \
+  "save_mode" \
+  "economy_mode" \
+  "branch_mode" \
+  "interactive_mode" \
+  "branch_name" \
+  "original_input"
+```
+
+**Output:**
+```
+.claude/output/apex/01-add-auth-middleware/
+├── 00-context.md      # Always created
+├── 01-analyze.md      # Always created
+├── 02-plan.md         # Always created
+├── 03-execute.md      # Always created
+└── 04-validate.md     # Always created
+```
+
+## Progress Update Script
+
+### `update-progress.sh`
+
+Updates the progress table in `00-context.md` without manual markdown editing.
+
+**Usage:**
+```bash
+bash scripts/update-progress.sh <task_id> <step_number> <step_name> <status>
+```
+
+**Examples:**
+```bash
+# Mark step 01 as in progress
+bash scripts/update-progress.sh "01-add-auth" "01" "analyze" "in_progress"
+
+# Mark step 01 as complete
+bash scripts/update-progress.sh "01-add-auth" "01" "analyze" "complete"
+
+# Mark step 02 as in progress
+bash scripts/update-progress.sh "01-add-auth" "02" "plan" "in_progress"
+```
+
+**Status Values:**
+- `in_progress` → `⏳ In Progress`
+- `complete` → `✓ Complete`
+
+## Token Savings
+
+### Before Optimization
+
+Each step file contained full template content inline:
+
+```markdown
+### 1. Initialize Save Output (if save_mode)
+
+**If `{save_mode}` = true:**
+
+Create `{output_dir}/01-analyze.md`:
+```markdown
+# Step 01: Analyze
+
+**Task:** {task_description}
+**Started:** {ISO timestamp}
+
+---
+
+## Context Discovery
+```
+
+Update `00-context.md` progress:
+```markdown
+| 01-analyze | ⏳ In Progress | {timestamp} |
+```
+```
+
+**Token cost per step:** ~200 tokens × 5 steps = ~1,000 tokens
+
+### After Optimization
+
+Step files now reference templates and scripts:
+
+```markdown
+### 1. Initialize Save Output (if save_mode)
+
+**If `{save_mode}` = true:**
+
+The file `{output_dir}/01-analyze.md` has already been created by the setup script.
+
+Update progress:
+```bash
+bash {skill_dir}/scripts/update-progress.sh "{task_id}" "01" "analyze" "in_progress"
+```
+
+Append your findings to `01-analyze.md` as you work.
+```
+
+**Token cost per step:** ~50 tokens × 5 steps = ~250 tokens
+
+**Total savings:** ~750 tokens per workflow execution (75% reduction)
+
+## How It Works
+
+1. **Initialization (step-00-init.md):**
+   - Runs `setup-templates.sh` once at workflow start
+   - Creates all template files with variables replaced
+   - Output directory is ready with pre-initialized files
+
+2. **Each Step:**
+   - Runs `update-progress.sh` to mark step as "in_progress"
+   - Appends findings/logs to the pre-created step file
+   - Runs `update-progress.sh` again to mark step as "complete"
+
+3. **Benefits:**
+   - AI doesn't need to hold template content in context
+   - Consistent formatting across all workflows
+   - Easy to update templates without editing step files
+   - Scripts handle the tedious markdown updates
+
+## Updating Templates
+
+To modify template content:
+
+1. Edit the template file in `templates/`
+2. Changes apply to all future workflows automatically
+3. No need to update step files
+
+## Maintenance
+
+- Templates are stateless (no workflow-specific logic)
+- Scripts are idempotent (safe to run multiple times)
+- Variables use `{{var}}` syntax to avoid conflicts with markdown

package/claude-code-config/skills/workflow-apex-free/templates/step-complete.md

@@ -0,0 +1,7 @@
+---
+
+## Step Complete
+
+**Status:** ✓ Complete
+**Next:** {{next_step}}
+**Timestamp:** {{timestamp}}

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.24",
+  "version": "1.4.25",
   "description": "AIBlueprint CLI for setting up Claude Code configurations",
   "author": "AIBlueprint",
   "license": "MIT",