vibecheck-ai 2.0.2 → 5.0.1

package/bin/runners/runCheckpoint.js

@@ -0,0 +1,530 @@
+/**
+ * Checkpoint Command Runner
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * "Checkpoint is the time machine. Let users experiment fearlessly."
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Commands:
+ * - checkpoint create [message] - Create manual checkpoint
+ * - checkpoint list             - List all checkpoints
+ * - checkpoint restore <id>     - Restore checkpoint
+ * - checkpoint diff <id>        - Show changes since checkpoint
+ * - checkpoint delete <id>      - Delete checkpoint
+ * - checkpoint prune            - Clean up old checkpoints
+ * - checkpoint status           - Show storage status
+ * 
+ * @module runners/runCheckpoint
+ */
+
+const path = require("path");
+const {
+  createCheckpoint,
+  restoreCheckpoint,
+  deleteCheckpoint,
+  listCheckpoints,
+  getCheckpoint,
+  getLatestCheckpoint,
+  diffCheckpoint,
+  pruneCheckpoints,
+  getStorageStatus,
+  updateSettings,
+  rollback,
+  formatBytes,
+  AUTO_REASONS,
+} = require("./lib/checkpoint");
+
+const { parseGlobalFlags, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+const { c: colors, sym: symbols, box: renderBox, table: renderTable } = require("./lib/ui");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXIT CODES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const EXIT = {
+  SUCCESS: 0,
+  ERROR: 1,
+  NOT_FOUND: 2,
+  USER_ERROR: 3,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function showHelp() {
+  console.log(`
+${colors.bold}vibecheck checkpoint${colors.reset} - Time machine for fearless experimentation
+
+${colors.bold}COMMANDS${colors.reset}
+  create [message]     Create a checkpoint
+  list                 List all checkpoints
+  restore <id>         Restore files from checkpoint
+  diff <id>            Show changes since checkpoint
+  delete <id>          Delete a checkpoint
+  prune                Clean up old checkpoints
+  status               Show storage status
+
+${colors.bold}CREATE OPTIONS${colors.reset}
+  --tag <name>         Tag the checkpoint for easy reference
+  --files <paths>      Specific files to checkpoint (comma-separated)
+
+${colors.bold}RESTORE OPTIONS${colors.reset}
+  --dry-run            Preview restore without changes
+  --only <files>       Only restore specific files (comma-separated)
+  
+${colors.bold}LIST OPTIONS${colors.reset}
+  --limit <n>          Limit number of results
+  --json               Output as JSON
+
+${colors.bold}PRUNE OPTIONS${colors.reset}
+  --keep <n>           Keep N most recent checkpoints
+  --older-than <days>  Delete checkpoints older than N days
+
+${colors.bold}SPECIAL IDS${colors.reset}
+  latest               Use most recent checkpoint
+  <tag>                Use checkpoint by tag name
+
+${colors.bold}EXAMPLES${colors.reset}
+  ${colors.dim}# Create checkpoint before major change${colors.reset}
+  vibecheck checkpoint create "Before auth refactor"
+  vibecheck checkpoint create --tag pre-refactor
+
+  ${colors.dim}# List checkpoints${colors.reset}
+  vibecheck checkpoint list
+  vibecheck checkpoint list --limit 5
+
+  ${colors.dim}# Restore${colors.reset}
+  vibecheck checkpoint restore latest
+  vibecheck checkpoint restore CP_1234567890_abc123
+  vibecheck checkpoint restore pre-refactor
+
+  ${colors.dim}# Preview restore${colors.reset}
+  vibecheck checkpoint restore latest --dry-run
+
+  ${colors.dim}# See what changed${colors.reset}
+  vibecheck checkpoint diff latest
+
+  ${colors.dim}# Cleanup${colors.reset}
+  vibecheck checkpoint prune --keep 10
+  vibecheck checkpoint prune --older-than 7
+
+${colors.bold}AUTO-CHECKPOINTS${colors.reset}
+  Checkpoints are automatically created before:
+  • vibecheck fix --apply
+  • vibecheck polish --apply
+  • vibecheck shield enforce
+  • vibecheck forge (when overwriting)
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SUBCOMMAND HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Create checkpoint.
+ */
+async function handleCreate(args, flags) {
+  const json = isJsonMode(flags);
+  const message = args.join(" ").trim() || undefined;
+  const tag = flags.tag;
+  const filesArg = flags.files;
+  
+  // Parse files if provided
+  let files = [];
+  if (filesArg) {
+    files = filesArg.split(",").map(f => f.trim()).filter(Boolean);
+  }
+  
+  try {
+    const checkpoint = createCheckpoint({
+      cwd: process.cwd(),
+      files,
+      reason: message || AUTO_REASONS.MANUAL,
+      tag,
+      command: "checkpoint create",
+      context: { message },
+    });
+    
+    if (json) {
+      console.log(JSON.stringify({ success: true, checkpoint }));
+    } else {
+      console.log();
+      console.log(`${symbols.success} Checkpoint created: ${colors.cyan}${checkpoint.id}${colors.reset}`);
+      console.log();
+      console.log(`  ${colors.dim}Files:${colors.reset}  ${checkpoint.files}`);
+      console.log(`  ${colors.dim}Size:${colors.reset}   ${formatBytes(checkpoint.size)}`);
+      if (tag) {
+        console.log(`  ${colors.dim}Tag:${colors.reset}    ${colors.yellow}${tag}${colors.reset}`);
+      }
+      console.log();
+      console.log(`${colors.dim}Restore with: vibecheck checkpoint restore ${tag || checkpoint.id}${colors.reset}`);
+      console.log();
+    }
+    
+    return EXIT.SUCCESS;
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: err.message }));
+    } else {
+      console.error(`${symbols.error} Failed to create checkpoint: ${err.message}`);
+    }
+    return EXIT.ERROR;
+  }
+}
+
+/**
+ * List checkpoints.
+ */
+async function handleList(args, flags) {
+  const json = isJsonMode(flags);
+  const limit = flags.limit ? parseInt(flags.limit, 10) : undefined;
+  
+  const checkpoints = listCheckpoints({ limit });
+  
+  if (json) {
+    console.log(JSON.stringify({ success: true, checkpoints }));
+    return EXIT.SUCCESS;
+  }
+  
+  if (checkpoints.length === 0) {
+    console.log();
+    console.log(`${colors.dim}No checkpoints found.${colors.reset}`);
+    console.log(`${colors.dim}Create one with: vibecheck checkpoint create "message"${colors.reset}`);
+    console.log();
+    return EXIT.SUCCESS;
+  }
+  
+  console.log();
+  console.log(`${colors.bold}Checkpoints${colors.reset} (${checkpoints.length} total)`);
+  console.log();
+  
+  // Table header
+  console.log(`  ${colors.dim}ID                              Age        Files  Size     Tag${colors.reset}`);
+  console.log(`  ${colors.dim}${"─".repeat(80)}${colors.reset}`);
+  
+  for (const cp of checkpoints) {
+    const idShort = cp.id.length > 30 ? cp.id.slice(0, 27) + "..." : cp.id.padEnd(30);
+    const age = cp.age.padEnd(10);
+    const files = String(cp.fileCount).padStart(5);
+    const size = cp.sizeFormatted.padStart(8);
+    const tag = cp.tag ? colors.yellow + cp.tag + colors.reset : colors.dim + "-" + colors.reset;
+    const reason = cp.reason.startsWith("auto:") ? colors.blue + "⚡" + colors.reset : "";
+    
+    console.log(`  ${reason}${colors.cyan}${idShort}${colors.reset} ${age} ${files} ${size}  ${tag}`);
+  }
+  
+  console.log();
+  
+  // Storage status
+  const status = getStorageStatus();
+  console.log(`${colors.dim}Storage: ${status.totalSizeFormatted} / ${status.maxSizeFormatted} (${status.usagePercent}%)${colors.reset}`);
+  console.log();
+  
+  return EXIT.SUCCESS;
+}
+
+/**
+ * Restore checkpoint.
+ */
+async function handleRestore(args, flags) {
+  const json = isJsonMode(flags);
+  const dryRun = flags["dry-run"] || flags.dryRun;
+  const onlyFiles = flags.only ? flags.only.split(",").map(f => f.trim()) : [];
+  
+  const checkpointId = args[0];
+  
+  if (!checkpointId) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: "Checkpoint ID required" }));
+    } else {
+      console.error(`${symbols.error} Checkpoint ID required`);
+      console.log(`${colors.dim}Usage: vibecheck checkpoint restore <id|latest|tag>${colors.reset}`);
+    }
+    return EXIT.USER_ERROR;
+  }
+  
+  try {
+    const result = restoreCheckpoint(checkpointId, { dryRun, onlyFiles });
+    
+    if (json) {
+      console.log(JSON.stringify({ success: true, result }));
+      return EXIT.SUCCESS;
+    }
+    
+    console.log();
+    
+    if (dryRun) {
+      console.log(`${colors.yellow}DRY RUN${colors.reset} - No files changed`);
+      console.log();
+    }
+    
+    console.log(`${symbols.success} ${dryRun ? "Would restore" : "Restored"} checkpoint: ${colors.cyan}${result.id}${colors.reset}`);
+    console.log();
+    
+    if (result.restored.length > 0) {
+      console.log(`${colors.green}${dryRun ? "Would restore" : "Restored"}:${colors.reset}`);
+      for (const r of result.restored) {
+        console.log(`  ${symbols.success} ${r.file}`);
+      }
+    }
+    
+    if (result.skipped.length > 0) {
+      console.log();
+      console.log(`${colors.yellow}Skipped:${colors.reset}`);
+      for (const s of result.skipped) {
+        console.log(`  ${symbols.warning} ${s.file} (${s.reason})`);
+      }
+    }
+    
+    if (result.errors.length > 0) {
+      console.log();
+      console.log(`${colors.red}Errors:${colors.reset}`);
+      for (const e of result.errors) {
+        console.log(`  ${symbols.error} ${e.file}: ${e.reason}`);
+      }
+    }
+    
+    console.log();
+    
+    return result.errors.length > 0 ? EXIT.ERROR : EXIT.SUCCESS;
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: err.message }));
+    } else {
+      console.error(`${symbols.error} Failed to restore: ${err.message}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+}
+
+/**
+ * Diff checkpoint.
+ */
+async function handleDiff(args, flags) {
+  const json = isJsonMode(flags);
+  const checkpointId = args[0] || "latest";
+  
+  try {
+    const diff = diffCheckpoint(checkpointId);
+    
+    if (json) {
+      console.log(JSON.stringify({ success: true, diff }));
+      return EXIT.SUCCESS;
+    }
+    
+    console.log();
+    console.log(`${colors.bold}Checkpoint diff:${colors.reset} ${colors.cyan}${diff.id}${colors.reset}`);
+    console.log(`${colors.dim}Created: ${diff.created}${colors.reset}`);
+    console.log();
+    
+    // Summary
+    const { modified, deleted, unchanged } = diff.summary;
+    console.log(`${colors.bold}Summary:${colors.reset}`);
+    console.log(`  ${colors.yellow}Modified:${colors.reset}  ${modified}`);
+    console.log(`  ${colors.red}Deleted:${colors.reset}   ${deleted}`);
+    console.log(`  ${colors.green}Unchanged:${colors.reset} ${unchanged}`);
+    console.log();
+    
+    // Details
+    if (diff.changes.some(c => c.status !== "unchanged")) {
+      console.log(`${colors.bold}Changes:${colors.reset}`);
+      for (const change of diff.changes) {
+        if (change.status === "unchanged") continue;
+        
+        const icon = change.status === "modified" ? colors.yellow + "~" : colors.red + "-";
+        console.log(`  ${icon}${colors.reset} ${change.file}`);
+      }
+      console.log();
+    } else {
+      console.log(`${colors.green}No changes since checkpoint.${colors.reset}`);
+      console.log();
+    }
+    
+    return EXIT.SUCCESS;
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: err.message }));
+    } else {
+      console.error(`${symbols.error} ${err.message}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+}
+
+/**
+ * Delete checkpoint.
+ */
+async function handleDelete(args, flags) {
+  const json = isJsonMode(flags);
+  const checkpointId = args[0];
+  
+  if (!checkpointId) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: "Checkpoint ID required" }));
+    } else {
+      console.error(`${symbols.error} Checkpoint ID required`);
+    }
+    return EXIT.USER_ERROR;
+  }
+  
+  const deleted = deleteCheckpoint(checkpointId);
+  
+  if (json) {
+    console.log(JSON.stringify({ success: deleted, id: checkpointId }));
+    return deleted ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  }
+  
+  if (deleted) {
+    console.log(`${symbols.success} Deleted checkpoint: ${checkpointId}`);
+    return EXIT.SUCCESS;
+  } else {
+    console.error(`${symbols.error} Checkpoint not found: ${checkpointId}`);
+    return EXIT.NOT_FOUND;
+  }
+}
+
+/**
+ * Prune checkpoints.
+ */
+async function handlePrune(args, flags) {
+  const json = isJsonMode(flags);
+  const keep = flags.keep ? parseInt(flags.keep, 10) : undefined;
+  const olderThanDays = flags["older-than"] ? parseInt(flags["older-than"], 10) : undefined;
+  
+  if (keep === undefined && olderThanDays === undefined) {
+    // Default: keep 10
+    flags.keep = 10;
+  }
+  
+  const result = pruneCheckpoints({
+    keep: flags.keep ? parseInt(flags.keep, 10) : undefined,
+    olderThanDays: flags["older-than"] ? parseInt(flags["older-than"], 10) : undefined,
+  });
+  
+  if (json) {
+    console.log(JSON.stringify({ success: true, ...result }));
+    return EXIT.SUCCESS;
+  }
+  
+  console.log();
+  
+  if (result.deleted.length === 0) {
+    console.log(`${symbols.success} No checkpoints to prune.`);
+  } else {
+    console.log(`${symbols.success} Pruned ${result.deleted.length} checkpoint(s)`);
+    console.log();
+    for (const id of result.deleted) {
+      console.log(`  ${colors.dim}${symbols.success} ${id}${colors.reset}`);
+    }
+  }
+  
+  console.log();
+  console.log(`${colors.dim}Keeping ${result.kept.length} checkpoint(s)${colors.reset}`);
+  console.log();
+  
+  return EXIT.SUCCESS;
+}
+
+/**
+ * Show storage status.
+ */
+async function handleStatus(args, flags) {
+  const json = isJsonMode(flags);
+  const status = getStorageStatus();
+  
+  if (json) {
+    console.log(JSON.stringify({ success: true, status }));
+    return EXIT.SUCCESS;
+  }
+  
+  console.log();
+  console.log(`${colors.bold}Checkpoint Storage Status${colors.reset}`);
+  console.log();
+  
+  // Progress bar
+  const barWidth = 30;
+  const filled = Math.round((status.usagePercent / 100) * barWidth);
+  const bar = colors.green + "█".repeat(filled) + colors.dim + "░".repeat(barWidth - filled) + colors.reset;
+  
+  console.log(`  Storage: [${bar}] ${status.usagePercent}%`);
+  console.log(`           ${status.totalSizeFormatted} / ${status.maxSizeFormatted}`);
+  console.log();
+  console.log(`  Checkpoints: ${status.checkpointCount} / ${status.maxCheckpoints}`);
+  console.log();
+  
+  return EXIT.SUCCESS;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN RUNNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Main runner.
+ * @param {string[]} args
+ * @returns {Promise<number>}
+ */
+async function runCheckpoint(args = []) {
+  const { cleanArgs, flags } = parseGlobalFlags(args);
+  
+  if (flags.help || flags.h) {
+    showHelp();
+    return EXIT.SUCCESS;
+  }
+  
+  const subcommand = cleanArgs[0]?.toLowerCase();
+  const subArgs = cleanArgs.slice(1);
+  
+  switch (subcommand) {
+    case "create":
+    case "new":
+    case "save":
+      return handleCreate(subArgs, flags);
+      
+    case "list":
+    case "ls":
+      return handleList(subArgs, flags);
+      
+    case "restore":
+    case "rollback":
+    case "revert":
+      return handleRestore(subArgs, flags);
+      
+    case "diff":
+    case "compare":
+      return handleDiff(subArgs, flags);
+      
+    case "delete":
+    case "rm":
+    case "remove":
+      return handleDelete(subArgs, flags);
+      
+    case "prune":
+    case "cleanup":
+    case "gc":
+      return handlePrune(subArgs, flags);
+      
+    case "status":
+    case "info":
+      return handleStatus(subArgs, flags);
+      
+    default:
+      // Default to list if no subcommand
+      if (!subcommand) {
+        return handleList([], flags);
+      }
+      
+      // Check if it's a checkpoint ID (for quick restore)
+      if (subcommand.startsWith("CP_") || subcommand === "latest") {
+        return handleRestore([subcommand, ...subArgs], flags);
+      }
+      
+      console.error(`${symbols.error} Unknown subcommand: ${subcommand}`);
+      console.log(`${colors.dim}Run "vibecheck checkpoint --help" for usage.${colors.reset}`);
+      return EXIT.USER_ERROR;
+  }
+}
+
+module.exports = { runCheckpoint };