@vibecheckai/cli 3.7.0 → 3.9.0

package/bin/runners/runCleanup.js

@@ -0,0 +1,343 @@
+/**
+ * vibecheck polish --cleanup
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * PRODUCTION-GRADE CLEANUP WITHOUT CHAOS
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Safe transformations to improve code quality:
+ * - Remove console.log, debugger statements
+ * - Flag empty catch blocks, dead code
+ * - Identify unsafe regex patterns
+ * 
+ * Design:
+ * - Safe by default: Only transformations that cannot change behavior
+ * - Aggressive opt-in: Requires --aggressive --yes-i-am-sure
+ * - Checkpoint integration: Automatic backup before any changes
+ * - Transparent: Full diff preview before applying
+ * 
+ * Usage:
+ *   vibecheck polish --cleanup              # Analyze and show diff
+ *   vibecheck polish --cleanup --apply      # Apply safe fixes
+ *   vibecheck polish --cleanup --aggressive # Include risky fixes (preview only)
+ *   vibecheck polish --cleanup --aggressive --yes-i-am-sure --apply  # Apply all
+ *   vibecheck polish --rollback <backup-id> # Undo changes
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { EXIT } = require("./lib/exit-codes");
+const { parseGlobalFlags, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+const cleanup = require("./lib/cleanup");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ARGUMENT PARSING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const opts = {
+    help: false,
+    json: false,
+    apply: false,
+    aggressive: false,
+    yesIAmSure: false,
+    rollback: null,
+    verbose: false,
+    path: process.cwd(),
+    quiet: false,
+    maxFiles: 1000,
+  };
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === "--help" || arg === "-h") opts.help = true;
+    else if (arg === "--json") opts.json = true;
+    else if (arg === "--apply" || arg === "-a") opts.apply = true;
+    else if (arg === "--aggressive") opts.aggressive = true;
+    else if (arg === "--yes-i-am-sure") opts.yesIAmSure = true;
+    else if (arg === "--verbose" || arg === "-v") opts.verbose = true;
+    else if (arg === "--quiet" || arg === "-q") opts.quiet = true;
+    else if (arg === "--rollback" || arg === "-r") opts.rollback = args[++i];
+    else if (arg === "--path" || arg === "-p") opts.path = args[++i];
+    else if (arg === "--max-files") opts.maxFiles = parseInt(args[++i], 10);
+    else if (!arg.startsWith("-") && !opts.rollback) opts.path = arg;
+  }
+  
+  return opts;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printHelp() {
+  const { colors: c, icons } = cleanup;
+  
+  console.log(`
+${c.bold}${icons.broom} vibecheck polish --cleanup${c.reset}
+${c.dim}Production-grade cleanup without chaos${c.reset}
+
+${c.bold}USAGE${c.reset}
+  vibecheck polish --cleanup [options]
+
+${c.bold}OPTIONS${c.reset}
+  ${c.cyan}--apply, -a${c.reset}          Apply safe fixes (creates backup first)
+  ${c.cyan}--aggressive${c.reset}         Include risky transformations in analysis
+  ${c.cyan}--yes-i-am-sure${c.reset}      Confirm aggressive fixes (required with --aggressive --apply)
+  ${c.cyan}--rollback <id>${c.reset}      Rollback changes using backup
+  ${c.cyan}--verbose, -v${c.reset}        Show detailed output
+  ${c.cyan}--json${c.reset}               Output as JSON
+  ${c.cyan}--path, -p <dir>${c.reset}     Project path (default: current directory)
+  ${c.cyan}--max-files <n>${c.reset}      Maximum files to scan (default: 1000)
+
+${c.bold}WHAT IT CLEANS${c.reset}
+
+  ${c.green}${icons.check} Safe (auto-fixable):${c.reset}
+    • console.log, console.debug, console.info
+    • debugger statements
+    • Trailing whitespace
+    • Multiple empty lines
+
+  ${c.yellow}${icons.warning} Moderate (flagged for review):${c.reset}
+    • Empty catch blocks (silent failures)
+    • Empty functions
+    • TODO/FIXME comments
+    • Code after return statements
+
+  ${c.red}${icons.cross} Aggressive (requires explicit opt-in):${c.reset}
+    • Unsafe regex patterns (ReDoS risk)
+    • Commented-out code blocks
+    • TypeScript 'any' types
+    • console.error statements
+    • Browser alert/confirm/prompt
+
+${c.bold}EXAMPLES${c.reset}
+
+  ${c.dim}# Preview what would be cleaned${c.reset}
+  ${c.cyan}vibecheck polish --cleanup${c.reset}
+
+  ${c.dim}# Apply safe fixes${c.reset}
+  ${c.cyan}vibecheck polish --cleanup --apply${c.reset}
+
+  ${c.dim}# See aggressive issues (preview only)${c.reset}
+  ${c.cyan}vibecheck polish --cleanup --aggressive${c.reset}
+
+  ${c.dim}# Apply ALL fixes (with confirmation)${c.reset}
+  ${c.cyan}vibecheck polish --cleanup --aggressive --yes-i-am-sure --apply${c.reset}
+
+  ${c.dim}# Undo changes${c.reset}
+  ${c.cyan}vibecheck polish --rollback .vibecheck/cleanup-backups/2024-01-15T10-30-00${c.reset}
+
+${c.bold}RISK LEVELS${c.reset}
+
+  ${c.green}Safe${c.reset}       Cannot change program behavior. Auto-applied with --apply.
+  ${c.yellow}Moderate${c.reset}   Generally safe, but worth reviewing. Flagged in output.
+  ${c.red}Aggressive${c.reset} Could change behavior. Requires --aggressive --yes-i-am-sure.
+
+${c.bold}INTEGRATION${c.reset}
+
+  • Creates automatic backups before changes
+  • Use ${c.cyan}vibecheck checkpoint${c.reset} before cleanup for full rollback support
+  • JSON output available for CI integration
+
+${c.dim}${"─".repeat(60)}${c.reset}
+${c.dim}Tip: Always run tests after applying fixes!${c.reset}
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runCleanup(args = [], context = {}) {
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  const opts = parseArgs([...cleanArgs, ...args]);
+  
+  const quiet = shouldSuppressOutput(globalFlags) || opts.quiet;
+  const json = isJsonMode(globalFlags) || opts.json;
+  const projectPath = path.resolve(opts.path || context.repoRoot || process.cwd());
+  
+  // Handle help
+  if (opts.help) {
+    printHelp();
+    return EXIT.SUCCESS;
+  }
+  
+  // Handle rollback
+  if (opts.rollback) {
+    return handleRollback(opts.rollback, json, quiet);
+  }
+  
+  const { colors: c, icons } = cleanup;
+  
+  // Validate project path
+  if (!fs.existsSync(projectPath)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Path not found: ${projectPath}` }));
+    } else {
+      console.error(`${c.red}${icons.cross}${c.reset} Path not found: ${projectPath}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+  
+  // Validate aggressive confirmation
+  if (opts.aggressive && opts.apply && !opts.yesIAmSure) {
+    if (json) {
+      console.log(JSON.stringify({ 
+        success: false, 
+        error: "Aggressive apply requires --yes-i-am-sure flag",
+        hint: "Add --yes-i-am-sure to confirm you understand the risks"
+      }));
+    } else {
+      console.error(`
+${c.red}${c.bold}${icons.warning} CONFIRMATION REQUIRED${c.reset}
+
+Aggressive transformations could change program behavior.
+To proceed, add the confirmation flag:
+
+  ${c.cyan}vibecheck polish --cleanup --aggressive --yes-i-am-sure --apply${c.reset}
+
+${c.dim}This ensures you understand that these changes need testing.${c.reset}
+`);
+    }
+    return EXIT.USER_ERROR;
+  }
+  
+  // Print banner
+  if (!json && !quiet) {
+    cleanup.printBanner();
+  }
+  
+  // Analyze project
+  if (!json && !quiet) {
+    process.stdout.write(`${icons.broom} Scanning project for cleanup opportunities...`);
+  }
+  
+  const analysis = await cleanup.analyzeProject(projectPath, {
+    aggressive: opts.aggressive,
+    includeModerate: true,
+    maxFiles: opts.maxFiles,
+  });
+  
+  if (!json && !quiet && process.stdout.clearLine) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  }
+  
+  // Calculate diffs
+  const diffsResult = await cleanup.calculateDiffs(projectPath, analysis, {
+    dryRun: !opts.apply,
+  });
+  
+  // Assess risk
+  const riskAssessment = cleanup.assessRisk(analysis, diffsResult);
+  
+  // JSON output
+  if (json) {
+    const output = cleanup.formatJsonOutput(analysis, diffsResult, riskAssessment, opts);
+    console.log(JSON.stringify(output, null, 2));
+    return analysis.byRisk.aggressive.length > 0 && !opts.aggressive 
+      ? EXIT.BLOCKING 
+      : EXIT.SUCCESS;
+  }
+  
+  // Human-readable output
+  if (!quiet) {
+    cleanup.printAnalysisSummary(analysis, projectPath);
+    cleanup.printRiskAssessment(riskAssessment);
+    cleanup.printFindingsByCategory(analysis, { verbose: opts.verbose });
+    cleanup.printDiffPreview(diffsResult, { verbose: opts.verbose });
+    
+    // Warn about aggressive findings if not in aggressive mode
+    if (!opts.aggressive) {
+      cleanup.printAggressiveWarning(analysis.byRisk.aggressive);
+    }
+  }
+  
+  // Apply changes if requested
+  if (opts.apply && diffsResult.filesChanged > 0) {
+    // Create backup directory
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupDir = path.join(projectPath, ".vibecheck", "cleanup-backups", timestamp);
+    
+    if (!quiet) {
+      console.log(`${c.bold}${icons.shield} Creating backup...${c.reset}`);
+    }
+    
+    const applyResult = await cleanup.applyTransformations(projectPath, diffsResult.diffs, backupDir);
+    
+    if (!quiet) {
+      cleanup.printApplyResults(applyResult);
+      cleanup.printRollbackInfo(backupDir);
+    }
+  }
+  
+  // Next steps
+  if (!quiet) {
+    cleanup.printNextSteps(analysis, diffsResult, {
+      applied: opts.apply,
+      aggressive: opts.aggressive,
+    });
+  }
+  
+  // Exit code based on findings
+  if (analysis.byRisk.aggressive.length > 0 && !opts.aggressive) {
+    return EXIT.BLOCKING; // Has aggressive findings that weren't addressed
+  }
+  
+  return EXIT.SUCCESS;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ROLLBACK HANDLER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function handleRollback(backupPath, json, quiet) {
+  const { colors: c, icons } = cleanup;
+  
+  if (!fs.existsSync(backupPath)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Backup not found: ${backupPath}` }));
+    } else {
+      console.error(`${c.red}${icons.cross}${c.reset} Backup not found: ${backupPath}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+  
+  const result = await cleanup.rollbackTransformations(backupPath);
+  
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.success ? EXIT.SUCCESS : EXIT.INTERNAL_ERROR;
+  }
+  
+  if (result.success) {
+    console.log(`
+${c.green}${c.bold}${icons.check} ROLLBACK COMPLETE${c.reset}
+
+  Restored ${result.restored.length} file(s) to original state.
+  
+${c.dim}Tip: Run your tests to verify everything works.${c.reset}
+`);
+    return EXIT.SUCCESS;
+  } else {
+    console.error(`
+${c.red}${c.bold}${icons.cross} ROLLBACK FAILED${c.reset}
+
+  ${result.error || "Unknown error"}
+  
+  Failed files:
+${result.failed.map(f => `    ${c.red}•${c.reset} ${f.file}: ${f.error}`).join("\n")}
+`);
+    return EXIT.INTERNAL_ERROR;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = { runCleanup };