vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runPolish.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Type declarations for runPolish.js
+ */
+export function runPolish(args: string[]): Promise<number>;

package/bin/runners/runPolish.js

@@ -0,0 +1,390 @@
+/**
+ * vibecheck polish - Production Polish Analyzer
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Finds all the small detailed things you forgot - the polish that makes
+ * projects production-ready.
+ * 
+ * 13 engines: frontend, backend, security, performance, accessibility, seo,
+ * configuration, documentation, infrastructure, observability, resilience,
+ * internationalization, privacy
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { EXIT } = require("./lib/exit-codes");
+const { parseGlobalFlags, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MODULAR POLISH ENGINE (13 category engines from lib/polish/)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const { analyzeProject } = require("./lib/polish/analyzer");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL STYLING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+};
+
+const icons = {
+  critical: '🔴',
+  high: '🟠',
+  medium: '🟡',
+  low: '🔵',
+  check: '✓',
+  cross: '✗',
+  arrow: '→',
+  star: '★',
+  sparkle: '✨',
+  wrench: '🔧',
+  rocket: '🚀',
+  shield: '🛡️',
+  lightning: '⚡',
+  eye: '👁️',
+  search: '🔍',
+  book: '📖',
+  gear: '⚙️',
+  server: '🖥️',
+  lock: '🔒',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function pathExists(filePath) {
+  try { await fs.promises.access(filePath); return true; } catch { return false; }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CLI INTERFACE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const opts = {
+    help: false, fix: false, json: false, prompts: false, verbose: false,
+    category: null, path: process.cwd(),
+    cleanup: false, apply: false, aggressive: false, yesIAmSure: false, rollback: null,
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--fix' || arg === '-f') opts.fix = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--prompts' || arg === '--ai') opts.prompts = true;
+    else if (arg === '--verbose' || arg === '-v') opts.verbose = true;
+    else if (arg === '--category' || arg === '-c') opts.category = args[++i];
+    else if (arg === '--path' || arg === '-p') opts.path = args[++i];
+    else if (arg === '--cleanup') opts.cleanup = 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 === '--rollback' || arg === '-r') opts.rollback = args[++i];
+    else if (!arg.startsWith('-')) opts.path = arg;
+  }
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}${icons.sparkle} vibecheck polish${c.reset} - Production Polish Analyzer
+
+${c.dim}Finds all the small detailed things you forgot - the polish that makes
+projects production-ready.${c.reset}
+
+${c.bold}USAGE${c.reset}
+  vibecheck polish [options] [path]
+
+${c.bold}OPTIONS${c.reset}
+  -h, --help              Show this help message
+  -f, --fix               Auto-fix issues where possible
+  --prompts, --ai         Show AI prompts for each issue (copy to AI assistant)
+  -v, --verbose           Show detailed output including AI prompts inline
+  -c, --category <name>   Check only specific category
+  -p, --path <path>       Project path (defaults to current directory)
+  --json                  Output as JSON (includes AI prompts)
+
+${c.bold}${icons.wrench} CLEANUP MODE${c.reset} ${c.dim}(production-grade code cleanup)${c.reset}
+  --cleanup               Enter cleanup mode (remove footguns)
+  --apply                 Apply safe fixes (creates backup first)
+  --aggressive            Include risky transformations
+  --yes-i-am-sure         Confirm aggressive fixes
+  --rollback <backup>     Rollback changes using backup
+
+${c.bold}CATEGORIES${c.reset}
+  frontend            Error boundaries, skeletons, ARIA, haptics, animations, caching
+  backend             Health endpoints, validation, rate limiting, error handling
+  security            .env files, security headers, CORS, secrets management
+  performance         Image optimization, caching, bundle analysis
+  accessibility       A11y testing, skip links, focus management
+  seo                 Meta tags, sitemap, robots.txt, Open Graph
+  configuration       TypeScript, ESLint, Prettier, EditorConfig
+  documentation       README, CHANGELOG, CONTRIBUTING, LICENSE
+  infrastructure      Docker, CI/CD, deployment config, env validation
+  observability       OpenTelemetry, structured logging, metrics, tracing
+  resilience          Circuit breakers, retry logic, timeouts, graceful shutdown
+  internationalization  i18n setup, RTL support, locale detection, translations
+  privacy             GDPR, cookie consent, data export, account deletion
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck polish                     # Analyze current project
+  vibecheck polish --prompts           # Show AI prompts for all issues
+  vibecheck polish -c frontend --ai    # Frontend issues with AI prompts
+  vibecheck polish --fix               # Auto-fix issues
+  vibecheck polish --json              # Output JSON for CI
+`);
+}
+
+function formatScore(score) {
+  if (score >= 90) return `${c.green}${c.bold}${score}/100${c.reset} ${c.green}(Excellent)${c.reset}`;
+  if (score >= 70) return `${c.yellow}${c.bold}${score}/100${c.reset} ${c.yellow}(Good)${c.reset}`;
+  if (score >= 50) return `${c.yellow}${c.bold}${score}/100${c.reset} ${c.yellow}(Needs Work)${c.reset}`;
+  return `${c.red}${c.bold}${score}/100${c.reset} ${c.red}(Critical Issues)${c.reset}`;
+}
+
+function formatSeverity(severity) {
+  const styles = {
+    critical: `${icons.critical} ${c.red}${c.bold}CRITICAL${c.reset}`,
+    high: `${icons.high} ${c.yellow}${c.bold}HIGH${c.reset}`,
+    medium: `${icons.medium} ${c.yellow}MEDIUM${c.reset}`,
+    low: `${icons.low} ${c.blue}LOW${c.reset}`,
+  };
+  return styles[severity] || severity;
+}
+
+function getCategoryIcon(category) {
+  const categoryIcons = {
+    Frontend: icons.sparkle, Backend: icons.server, Security: icons.lock,
+    Performance: icons.lightning, Accessibility: icons.eye, SEO: icons.search,
+    Configuration: icons.gear, Documentation: icons.book, Infrastructure: icons.rocket,
+    Observability: '📊', Resilience: '🛡️', Internationalization: '🌍', Privacy: '🔐',
+  };
+  return categoryIcons[category] || icons.star;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN RUNNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runPolish(args) {
+  const opts = parseArgs(args);
+  const { flags: globalFlags } = parseGlobalFlags(args);
+  const quiet = shouldSuppressOutput(globalFlags);
+  const json = isJsonMode(globalFlags) || opts.json;
+
+  // Cleanup mode delegates to runCleanup
+  if (opts.cleanup || opts.rollback) {
+    try {
+      const { runCleanup } = require("./runCleanup");
+      return runCleanup(args);
+    } catch {
+      console.error(`${c.red}${icons.cross} Cleanup module not available${c.reset}`);
+      return EXIT.INTERNAL_ERROR;
+    }
+  }
+
+  if (opts.help) {
+    printHelp();
+    return EXIT.SUCCESS;
+  }
+
+  const projectPath = path.resolve(opts.path);
+
+  // Verify project exists
+  if (!await pathExists(projectPath)) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${projectPath}` }));
+    } else {
+      console.error(`${c.red}${icons.cross} Project path does not exist: ${projectPath}${c.reset}`);
+    }
+    return EXIT.NOT_FOUND;
+  }
+
+  try {
+    // JSON mode
+    if (json) {
+      const report = await analyzeProject(projectPath, opts);
+      console.log(JSON.stringify(report, null, 2));
+      return report.critical > 0 ? EXIT.BLOCKING : EXIT.SUCCESS;
+    }
+
+    // Interactive mode
+    console.log(`
+${c.bold}╔══════════════════════════════════════════════════════════════════════════════╗
+║                                                                              ║
+║  ${icons.sparkle} ${c.cyan}VIBECHECK POLISH${c.reset}${c.bold} - Production Readiness Analyzer                        ║
+║                                                                              ║
+║  ${c.dim}Finds all the small detailed things you forgot - the polish that${c.reset}${c.bold}           ║
+║  ${c.dim}makes projects production-ready.${c.reset}${c.bold}                                            ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝${c.reset}
+`);
+
+    console.log(`${c.dim}Project:${c.reset} ${projectPath}\n`);
+
+    // Show spinner
+    const isTTY = process.stdout.isTTY;
+    if (isTTY) {
+      process.stdout.write(`${icons.search} Scanning project for polish issues...`);
+    } else {
+      console.log(`${icons.search} Scanning project for polish issues...`);
+    }
+
+    const report = await analyzeProject(projectPath, opts);
+
+    // Clear spinner line
+    if (isTTY && process.stdout.clearLine) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+
+    // Summary
+    console.log(`${c.bold}${icons.star} POLISH REPORT SUMMARY${c.reset}\n`);
+    console.log(`   ${c.bold}Score:${c.reset}    ${formatScore(report.score)}`);
+    console.log(`   ${c.bold}Issues:${c.reset}   ${report.totalIssues} total`);
+    console.log(`            ${icons.critical} ${report.critical} critical  ${icons.high} ${report.high} high  ${icons.medium} ${report.medium} medium  ${icons.low} ${report.low} low\n`);
+
+    if (report.issues.length === 0) {
+      if (!quiet) {
+        console.log(`\n${c.green}${c.bold}${icons.check} Perfect!${c.reset} No polish issues found. Your project is production-ready! ${icons.rocket}\n`);
+      }
+      return EXIT.SUCCESS;
+    }
+
+    // Group by category
+    const byCategory = {};
+    for (const issue of report.issues) {
+      if (!byCategory[issue.category]) byCategory[issue.category] = [];
+      byCategory[issue.category].push(issue);
+    }
+
+    // Show issues by category
+    console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+    console.log(`${c.bold}${icons.wrench} ISSUES BY CATEGORY${c.reset}`);
+    console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}\n`);
+
+    const issuesWithPrompts = [];
+
+    for (const [category, issues] of Object.entries(byCategory)) {
+      console.log(`${c.bold}${getCategoryIcon(category)} ${category}${c.reset} ${c.dim}(${issues.length} issues)${c.reset}`);
+      console.log(`${'─'.repeat(60)}`);
+
+      for (const issue of issues) {
+        console.log(`\n   ${formatSeverity(issue.severity)}`);
+        console.log(`   ${c.bold}${issue.title}${c.reset}`);
+        console.log(`   ${c.dim}${issue.description}${c.reset}`);
+        if (issue.file) {
+          console.log(`   ${c.dim}File: ${path.relative(projectPath, issue.file)}${c.reset}`);
+        }
+        console.log(`   ${c.cyan}${icons.arrow} ${issue.suggestion}${c.reset}`);
+        if (issue.autoFixable) {
+          console.log(`   ${c.green}${icons.check} Auto-fixable${c.reset}`);
+        }
+        if (issue.aiPrompt) {
+          issuesWithPrompts.push(issue);
+          if (opts.verbose) {
+            console.log(`\n   ${c.magenta}${c.bold}🤖 AI PROMPT:${c.reset}`);
+            console.log(`   ${c.dim}${'─'.repeat(50)}${c.reset}`);
+            for (const line of issue.aiPrompt.split('\n')) {
+              console.log(`   ${c.dim}${line}${c.reset}`);
+            }
+            console.log(`   ${c.dim}${'─'.repeat(50)}${c.reset}`);
+          } else {
+            console.log(`   ${c.magenta}🤖 Has AI prompt${c.reset} ${c.dim}(use --prompts to see)${c.reset}`);
+          }
+        }
+      }
+      console.log();
+    }
+
+    // Recommendations
+    if (report.recommendations.length > 0) {
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+      console.log(`${c.bold}💡 RECOMMENDATIONS${c.reset}`);
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}\n`);
+      report.recommendations.forEach((rec, i) => {
+        console.log(`   ${i + 1}. ${rec}`);
+      });
+      console.log();
+    }
+
+    // Auto-fix prompt
+    const autoFixable = report.issues.filter(i => i.autoFixable);
+    if (autoFixable.length > 0 && opts.fix) {
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+      console.log(`${c.bold}${icons.wrench} AUTO-FIX${c.reset}`);
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}\n`);
+      console.log(`   ${c.yellow}Auto-fix for ${autoFixable.length} issue(s) is coming soon!${c.reset}`);
+      console.log(`   ${c.dim}For now, please follow the suggestions above to fix issues manually.${c.reset}\n`);
+    } else if (autoFixable.length > 0) {
+      console.log(`${c.dim}Tip: Run 'vibecheck polish --fix' to auto-fix ${autoFixable.length} issue(s)${c.reset}\n`);
+    }
+
+    // AI Prompts section
+    if (opts.prompts && issuesWithPrompts.length > 0) {
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+      console.log(`${c.bold}🤖 AI PROMPTS - Copy to your AI assistant${c.reset}`);
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}\n`);
+      console.log(`${c.dim}Copy these prompts to Cursor, Copilot, Claude, or your preferred AI assistant.${c.reset}\n`);
+
+      for (let i = 0; i < issuesWithPrompts.length; i++) {
+        const issue = issuesWithPrompts[i];
+        console.log(`${c.bold}╭───────────────────────────────────────────────────────────────────────────────╮${c.reset}`);
+        console.log(`${c.bold}│${c.reset} ${c.cyan}[${i + 1}/${issuesWithPrompts.length}]${c.reset} ${c.bold}${issue.title}${c.reset}`);
+        console.log(`${c.bold}│${c.reset} ${c.dim}Severity: ${issue.severity} | Category: ${issue.category}${c.reset}`);
+        console.log(`${c.bold}╰───────────────────────────────────────────────────────────────────────────────╯${c.reset}`);
+        console.log();
+        console.log(`${c.magenta}${issue.aiPrompt}${c.reset}`);
+        console.log();
+        console.log(`${c.dim}${'─'.repeat(79)}${c.reset}\n`);
+      }
+
+      console.log(`${c.green}${c.bold}💡 Tip:${c.reset} Copy one prompt at a time and paste into your AI coding assistant.`);
+      console.log(`${c.dim}The prompts are designed to give AI complete context to generate the right code.${c.reset}\n`);
+    } else if (issuesWithPrompts.length > 0 && !opts.verbose) {
+      console.log(`${c.dim}${icons.star} ${issuesWithPrompts.length} issue(s) have AI prompts. Run with ${c.cyan}--prompts${c.reset}${c.dim} to see them.${c.reset}\n`);
+    }
+
+    // Next steps
+    if (!quiet) {
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}`);
+      console.log(`${c.bold}${icons.rocket} NEXT STEPS${c.reset}`);
+      console.log(`${c.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c.reset}\n`);
+      console.log(`   1. Fix ${c.red}critical${c.reset} and ${c.yellow}high${c.reset} severity issues first`);
+      console.log(`   2. Use ${c.cyan}vibecheck polish --prompts${c.reset} to get AI-ready fixes`);
+      console.log(`   3. Copy prompts to your AI assistant (Cursor, Copilot, Claude)`);
+      console.log(`   4. Re-run ${c.cyan}vibecheck polish${c.reset} to verify fixes`);
+      console.log(`   5. Run ${c.cyan}vibecheck ship${c.reset} when score is 80+\n`);
+    }
+
+    return report.critical > 0 ? EXIT.BLOCKING : EXIT.SUCCESS;
+  } catch (error) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: error.message }));
+    } else {
+      console.error(`${c.red}${icons.cross} Polish analysis failed: ${error.message}${c.reset}`);
+    }
+    return EXIT.INTERNAL_ERROR;
+  }
+}
+
+module.exports = { runPolish };

package/bin/runners/runPromptFirewall.js

@@ -0,0 +1,211 @@
+/**
+ * Prompt Firewall Runner
+ * 
+ * Processes prompts through the advanced firewall with:
+ * - Task breakdown
+ * - Verification
+ * - Version control integration
+ * - Immediate fixes
+ * - Future planning
+ */
+
+const path = require("path");
+const readline = require("readline");
+const { withErrorHandling } = require("./lib/error-handler");
+
+// ANSI colors
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+};
+
+async function runPromptFirewall(args) {
+  return withErrorHandling(async () => {
+    const projectPath = args.path || process.cwd();
+    const json = args.json || false;
+    const prompt = args.prompt || args._[0];
+    const autoFix = args["auto-fix"] === true;
+    const includeVersionControl = args["version-control"] !== false;
+    const generatePlan = args.plan !== false;
+
+    if (!prompt) {
+      console.error(`${c.red}Error: Prompt is required${c.reset}`);
+      console.error(`Usage: vibecheck prompt-firewall "your prompt here"`);
+      console.error(`   or: vibecheck prompt-firewall --prompt "your prompt here"`);
+      const { EXIT_CODES } = require('./lib/error-handler');
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+
+    // Try to load prompt firewall
+    let createPromptFirewall;
+    try {
+      const modulePath = path.resolve(__dirname, "../../packages/ai-vibechecks/dist/firewall/advanced-prompt-firewall.js");
+      createPromptFirewall = require(modulePath).createPromptFirewall;
+    } catch {
+      try {
+        const tsModulePath = path.resolve(__dirname, "../../packages/ai-vibechecks/src/firewall/advanced-prompt-firewall.ts");
+        require("ts-node/register");
+        createPromptFirewall = require(tsModulePath).createPromptFirewall;
+      } catch {
+        console.error(`${c.red}Error: Prompt firewall not available.${c.reset}`);
+        console.error(`Please run: pnpm build in packages/ai-vibechecks`);
+        const { EXIT_CODES } = require('./lib/error-handler');
+        process.exit(EXIT_CODES.INTERNAL_ERROR);
+      }
+    }
+
+    if (!json) {
+      console.log(`${c.cyan}${c.bold}━━━ Prompt Firewall Analysis ━━━${c.reset}\n`);
+      console.log(`Prompt: ${c.dim}${prompt}${c.reset}\n`);
+      console.log(`Project: ${path.relative(process.cwd(), projectPath)}\n`);
+    }
+
+    // Create firewall instance
+    const firewall = createPromptFirewall(projectPath);
+
+    // Process prompt
+    const result = await firewall.process(prompt, {
+      autoBreakdown: true,
+      autoVerify: true,
+      autoFix: autoFix,
+      includeVersionControl: includeVersionControl,
+      generatePlan: generatePlan,
+    });
+
+    // Output results
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+      return result.verification.passed ? 0 : 1;
+    }
+
+    // Print formatted report
+    printFirewallReport(result);
+
+    // Ask to apply fixes if available
+    if (result.immediateFixes.length > 0 && !autoFix) {
+      const shouldApply = await askToApplyFixes(result.immediateFixes.length);
+      if (shouldApply) {
+        console.log(`\n${c.cyan}Applying fixes...${c.reset}\n`);
+        for (const fix of result.immediateFixes) {
+          const applyResult = await firewall.applyFix(fix);
+          if (applyResult.success) {
+            console.log(`${c.green}✅${c.reset} ${applyResult.message}`);
+          } else {
+            console.log(`${c.red}❌${c.reset} ${applyResult.message}`);
+          }
+        }
+      }
+    }
+
+    return result.verification.passed ? 0 : 1;
+  });
+}
+
+function printFirewallReport(result) {
+  // Verification status
+  const statusColor = result.verification.passed ? c.green : c.red;
+  const statusIcon = result.verification.passed ? "✅" : "❌";
+
+  console.log(`${statusColor}${c.bold}${statusIcon} VERIFICATION: ${result.verification.passed ? "PASSED" : "FAILED"}${c.reset}`);
+  console.log(`   Score: ${result.verification.score}/100`);
+  console.log();
+
+  // Verification checks
+  console.log(`${c.cyan}${c.bold}🔍 VERIFICATION CHECKS:${c.reset}`);
+  for (const check of result.verification.checks) {
+    const icon = check.status === "pass" ? "✅" :
+                 check.status === "fail" ? "❌" : "⚠️";
+    const checkColor = check.status === "pass" ? c.green :
+                       check.status === "fail" ? c.red : c.yellow;
+    console.log(`   ${icon} ${check.name}: ${checkColor}${check.status.toUpperCase()}${c.reset}`);
+    console.log(`      ${c.dim}${check.message}${c.reset}`);
+    if (check.evidence) {
+      console.log(`      Evidence: ${c.dim}${check.evidence}${c.reset}`);
+    }
+  }
+  console.log();
+
+  // Task breakdown
+  if (result.taskBreakdown.length > 0) {
+    console.log(`${c.cyan}${c.bold}📋 TASK BREAKDOWN:${c.reset}`);
+    for (const task of result.taskBreakdown) {
+      const priorityColor = task.priority === "critical" ? c.red :
+                            task.priority === "high" ? c.yellow :
+                            task.priority === "medium" ? c.blue : c.dim;
+      console.log(`   ${priorityColor}[${task.priority.toUpperCase()}]${c.reset} ${task.title}`);
+      console.log(`      ${c.dim}${task.description}${c.reset}`);
+      console.log(`      Estimated time: ${task.estimatedTime.toFixed(0)} minutes`);
+      if (task.dependencies.length > 0) {
+        console.log(`      Depends on: ${task.dependencies.join(", ")}`);
+      }
+    }
+    console.log();
+  }
+
+  // Version control info
+  if (result.versionControl && result.versionControl.branch !== "unknown") {
+    console.log(`${c.cyan}${c.bold}🔀 VERSION CONTROL:${c.reset}`);
+    console.log(`   Branch: ${result.versionControl.branch}`);
+    console.log(`   Commit: ${result.versionControl.commit.substring(0, 8)}`);
+    console.log(`   Changes: ${result.versionControl.changes.length} file(s)`);
+    if (result.versionControl.conflicts.length > 0) {
+      console.log(`   ${c.red}Conflicts: ${result.versionControl.conflicts.length}${c.reset}`);
+    }
+    console.log();
+  }
+
+  // Immediate fixes
+  if (result.immediateFixes.length > 0) {
+    console.log(`${c.yellow}${c.bold}🔧 IMMEDIATE FIXES AVAILABLE:${c.reset}`);
+    for (const fix of result.immediateFixes) {
+      console.log(`   • ${fix.description}`);
+      console.log(`     File: ${fix.file}`);
+      console.log(`     Confidence: ${(fix.confidence * 100).toFixed(0)}%`);
+    }
+    console.log();
+  }
+
+  // Future plan
+  if (result.futurePlan && result.futurePlan.tasks.length > 0) {
+    console.log(`${c.cyan}${c.bold}📅 FUTURE PLAN:${c.reset}`);
+    console.log(`   Phase: ${result.futurePlan.phase}`);
+    console.log(`   Tasks: ${result.futurePlan.tasks.length}`);
+    console.log(`   Milestones: ${result.futurePlan.milestones.length}`);
+    if (result.futurePlan.risks.length > 0) {
+      console.log(`   ${c.yellow}Risks: ${result.futurePlan.risks.length}${c.reset}`);
+    }
+    console.log();
+  }
+
+  // Recommendations
+  if (result.recommendations.length > 0) {
+    console.log(`${c.cyan}${c.bold}💡 RECOMMENDATIONS:${c.reset}`);
+    for (const rec of result.recommendations) {
+      console.log(`   • ${rec}`);
+    }
+    console.log();
+  }
+}
+
+function askToApplyFixes(fixCount) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(`${c.yellow}Apply ${fixCount} immediate fix(es)? (y/n): ${c.reset}`, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+module.exports = { runPromptFirewall };