@vibecheckai/cli 3.5.0 → 3.5.1

package/bin/runners/lib/scan-output.js

@@ -1,571 +1,545 @@
 /**
- * Enterprise Scan Output - Premium Format
- * Features:
- * - "SCAN" ASCII Art
- * - Fixed alignment tables
- * - "Redacted" Upsell section for Scan context
+ * Scan Output - Premium Scan Results Display
+ * 
+ * Handles all scan output formatting:
+ * - Layer status display
+ * - Findings grouped by category
+ * - Coverage maps
+ * - JSON/SARIF export
  */
 
-// Use ANSI codes directly (chalk v5 is ESM-only, this is CommonJS)
-const ESC = '\x1b';
-const chalk = {
-  reset: `${ESC}[0m`,
-  bold: `${ESC}[1m`,
-  dim: `${ESC}[2m`,
-  red: `${ESC}[31m`,
-  green: `${ESC}[32m`,
-  yellow: `${ESC}[33m`,
-  cyan: `${ESC}[36m`,
-  magenta: `${ESC}[35m`,
-  white: `${ESC}[37m`,
-  gray: `${ESC}[90m`,
-};
+const {
+  ansi,
+  colors,
+  box,
+  icons,
+  renderScoreCard,
+  renderFindingsList,
+  renderSection,
+  renderDivider,
+  renderTable,
+  formatDuration,
+  formatNumber,
+  truncate,
+} = require('./terminal-ui');
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// CONFIGURATION
+// LAYER STATUS DISPLAY
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const WIDTH = 76; 
-
-const BOX = {
-  topLeft: '╔', topRight: '╗', bottomLeft: '╚', bottomRight: '╝',
-  horizontal: '═', vertical: '║',
-  teeRight: '╠', teeLeft: '╣',
-  
-  // Table Borders (Light)
-  tTopLeft: '┌', tTopRight: '┐', tBottomLeft: '└', tBottomRight: '┘',
-  tHorizontal: '─', tVertical: '│',
-  tTeeTop: '┬', tTeeBottom: '┴', tTee: '┼', tTeeLeft: '├', tTeeRight: '┤'
-};
-
-const LOGO_SCAN = `
-  █████████   █████████   █████████   █████████
- ███░░░░░███ ███░░░░░███ ███░░░░░███ ███░░░░░███
-░███    ░░░ ░███    ░░░ ░███    ░███ ░███    ░███
-░░█████████ ░███        ░███████████ ░███    ░███
- ░░░░░░░░███░███        ░███░░░░░███ ░███    ░███
- ███    ░███░███    ███ ░███    ░███ ░███    ░███
-░░█████████ ░░█████████ ░███    ░███ ░███    ░███
- ░░░░░░░░░   ░░░░░░░░░  ░░░░    ░░░░ ░░░░    ░░░░
-`;
-
-// Column widths for the table (Must correspond to math below)
-const COL_1 = 10; // Severity
-const COL_2 = 13; // Component
-const COL_3 = 41; // Message
+function renderLayers(layers) {
+  const lines = [];
+  lines.push(renderSection('ANALYSIS LAYERS', '⚡'));
+  lines.push('');
+  
+  const layerConfig = {
+    ast: { name: 'AST Analysis', icon: '🔍', desc: 'Static code parsing' },
+    truth: { name: 'Build Truth', icon: '📦', desc: 'Manifest verification' },
+    reality: { name: 'Reality Check', icon: '🎭', desc: 'Playwright runtime' },
+    realitySniff: { name: 'Reality Sniff', icon: '🔬', desc: 'AI artifact detection' },
+    detection: { name: 'Detection Engines', icon: '🛡️', desc: 'Security patterns' },
+  };
+  
+  for (const layer of layers) {
+    const config = layerConfig[layer.name] || { name: layer.name, icon: '○', desc: '' };
+    
+    let status, statusColor;
+    if (layer.skipped) {
+      status = `${ansi.dim}○ skipped${ansi.reset}`;
+    } else if (layer.error) {
+      status = `${colors.error}${icons.error} error${ansi.reset}`;
+    } else {
+      status = `${colors.success}${icons.success}${ansi.reset}`;
+    }
+    
+    const duration = layer.duration ? `${ansi.dim}${layer.duration}ms${ansi.reset}` : '';
+    const findings = layer.findings !== undefined ? `${colors.accent}${layer.findings}${ansi.reset} ${ansi.dim}findings${ansi.reset}` : '';
+    
+    lines.push(`  ${status} ${config.icon} ${config.name.padEnd(20)} ${duration.padEnd(15)} ${findings}`);
+  }
+  
+  return lines.join('\n');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// UTILITIES
+// COVERAGE MAP DISPLAY
 // ═══════════════════════════════════════════════════════════════════════════════
 
-function padCenter(str, width) {
-  const visibleLen = str.replace(/\u001b\[\d+m/g, '').length;
-  const padding = Math.max(0, width - visibleLen);
-  const left = Math.floor(padding / 2);
-  const right = padding - left;
-  return ' '.repeat(left) + str + ' '.repeat(right);
-}
-
-function padRight(str, len) {
-  const visibleLen = str.length; // Simplified for this usage
-  const truncated = visibleLen > len ? str.substring(0, len - 3) + '...' : str;
-  return truncated + ' '.repeat(Math.max(0, len - truncated.length));
+function renderCoverageMap(coverage) {
+  if (!coverage) return '';
+  
+  const lines = [];
+  lines.push(renderSection('ROUTE COVERAGE', '🗺️'));
+  lines.push('');
+  
+  const pct = coverage.coveragePercent || 0;
+  const color = pct >= 80 ? colors.success : pct >= 60 ? colors.warning : colors.error;
+  
+  // Coverage bar
+  const barWidth = 50;
+  const filled = Math.round((pct / 100) * barWidth);
+  const bar = `${color}${'█'.repeat(filled)}${ansi.dim}${'░'.repeat(barWidth - filled)}${ansi.reset}`;
+  
+  lines.push(`  ${color}${ansi.bold}${pct}%${ansi.reset} ${ansi.dim}of routes reachable from${ansi.reset} ${colors.accent}/${ansi.reset}`);
+  lines.push(`  ${bar}`);
+  lines.push('');
+  
+  // Stats
+  const stats = [
+    ['Total Routes', coverage.totalRoutes || 0],
+    ['Reachable', coverage.reachableFromRoot || 0],
+    ['Orphaned', coverage.orphanedRoutes || 0],
+    ['Dead Links', coverage.deadLinks || 0],
+  ];
+  
+  for (const [label, value] of stats) {
+    const valueColor = label === 'Orphaned' || label === 'Dead Links' 
+      ? (value > 0 ? colors.error : colors.success)
+      : ansi.reset;
+    lines.push(`  ${ansi.dim}${label}:${ansi.reset} ${valueColor}${ansi.bold}${value}${ansi.reset}`);
+  }
+  
+  // Isolated clusters
+  if (coverage.isolatedClusters?.length > 0) {
+    lines.push('');
+    lines.push(`  ${colors.warning}${icons.warning}${ansi.reset} ${ansi.dim}Isolated clusters:${ansi.reset}`);
+    for (const cluster of coverage.isolatedClusters.slice(0, 3)) {
+      const auth = cluster.requiresAuth ? ` ${ansi.dim}(auth required)${ansi.reset}` : '';
+      lines.push(`    ${ansi.dim}├─${ansi.reset} ${ansi.bold}${cluster.name}${ansi.reset}${auth} ${ansi.dim}(${cluster.nodeIds?.length || 0} routes)${ansi.reset}`);
+    }
+    if (coverage.isolatedClusters.length > 3) {
+      lines.push(`    ${ansi.dim}└─ ... and ${coverage.isolatedClusters.length - 3} more clusters${ansi.reset}`);
+    }
+  }
+  
+  // Unreachable routes
+  if (coverage.unreachableRoutes?.length > 0) {
+    lines.push('');
+    lines.push(`  ${colors.error}${icons.error}${ansi.reset} ${ansi.dim}Unreachable routes:${ansi.reset}`);
+    for (const route of coverage.unreachableRoutes.slice(0, 5)) {
+      lines.push(`    ${ansi.dim}├─${ansi.reset} ${colors.error}${route}${ansi.reset}`);
+    }
+    if (coverage.unreachableRoutes.length > 5) {
+      lines.push(`    ${ansi.dim}└─ ... and ${coverage.unreachableRoutes.length - 5} more${ansi.reset}`);
+    }
+  }
+  
+  return lines.join('\n');
 }
 
-function padLogoBlock(ascii, width) {
-  const lines = ascii.trim().split('\n');
-  const maxContentWidth = Math.max(...lines.map(l => l.length));
-  
-  return lines.map(line => {
-    const solidLine = line + ' '.repeat(maxContentWidth - line.length);
-    return padCenter(solidLine, width);
-  });
-}
+// ═══════════════════════════════════════════════════════════════════════════════
+// BREAKDOWN DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
 
-function renderProgressBar(score, width = 20) {
-  const filled = Math.round((score / 100) * width);
-  const bar = `${chalk.green}█${chalk.reset}`.repeat(filled) + `${chalk.gray}░${chalk.reset}`.repeat(width - filled);
-  return bar;
+function renderBreakdown(breakdown) {
+  if (!breakdown) return '';
+  
+  const lines = [];
+  lines.push(renderSection('SCORE BREAKDOWN', '📊'));
+  lines.push('');
+  
+  const items = [
+    { key: 'deadLinks', label: 'Dead Links', icon: '🔗' },
+    { key: 'orphanRoutes', label: 'Orphan Routes', icon: '👻' },
+    { key: 'runtimeFailures', label: 'Runtime 404s', icon: '💥' },
+    { key: 'unresolvedDynamic', label: 'Unresolved Dynamic', icon: '❓' },
+    { key: 'placeholders', label: 'Placeholders', icon: '📝' },
+    { key: 'secretsExposed', label: 'Secrets Exposed', icon: '🔐' },
+    { key: 'authBypass', label: 'Auth Bypass', icon: '🚪' },
+    { key: 'mockData', label: 'Mock Data', icon: '🎭' },
+  ];
+  
+  for (const item of items) {
+    const data = breakdown[item.key];
+    if (!data && data !== 0) continue;
+    
+    const count = typeof data === 'object' ? data.count : data;
+    const penalty = typeof data === 'object' ? data.penalty : 0;
+    
+    const status = count === 0 ? `${colors.success}${icons.success}${ansi.reset}` : `${colors.error}${icons.error}${ansi.reset}`;
+    const countColor = count === 0 ? colors.success : colors.error;
+    const penaltyStr = penalty > 0 ? `${ansi.dim}-${penalty} pts${ansi.reset}` : `${ansi.dim}  ---${ansi.reset}`;
+    
+    lines.push(`  ${status} ${item.icon} ${item.label.padEnd(22)} ${countColor}${ansi.bold}${String(count).padStart(3)}${ansi.reset}  ${penaltyStr}`);
+  }
+  
+  return lines.join('\n');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// MAIN FORMATTER
+// BLOCKERS DISPLAY
 // ═══════════════════════════════════════════════════════════════════════════════
 
-function formatScanOutput(result, options = {}) {
-  // Extract data from various possible structures
-  let score = 0;
-  let findings = [];
-  let duration = 0;
-  let scannedFiles = 0;
-  
-  // Helper function to calculate score from findings
-  function calculateScoreFromFindings(findings) {
-    if (!findings || findings.length === 0) return 100;
-    
-    // Count by severity (handle various severity formats)
-    const severityCounts = {
-      critical: 0,
-      high: 0,
-      medium: 0,
-      low: 0,
-      info: 0,
-    };
+function renderBlockers(blockers, options = {}) {
+  const { maxItems = 8 } = options;
+  
+  if (!blockers || blockers.length === 0) {
+    const lines = [];
+    lines.push(renderSection('SHIP BLOCKERS', '🚀'));
+    lines.push('');
+    lines.push(`  ${colors.success}${ansi.bold}${icons.success} No blockers! You're clear to ship.${ansi.reset}`);
+    return lines.join('\n');
+  }
+  
+  const lines = [];
+  lines.push(renderSection(`SHIP BLOCKERS (${blockers.length})`, '🚨'));
+  lines.push('');
+  
+  for (const blocker of blockers.slice(0, maxItems)) {
+    const sevColor = blocker.severity === 'critical' || blocker.severity === 'BLOCK' 
+      ? colors.bg.error 
+      : colors.bg.warning;
+    const sevLabel = blocker.severity === 'critical' || blocker.severity === 'BLOCK'
+      ? 'CRITICAL'
+      : '  HIGH  ';
     
-    findings.forEach(f => {
-      const sev = (f.severity || '').toLowerCase();
-      if (sev === 'critical' || sev === 'block') {
-        severityCounts.critical++;
-      } else if (sev === 'high') {
-        severityCounts.high++;
-      } else if (sev === 'medium' || sev === 'warn' || sev === 'warning') {
-        severityCounts.medium++;
-      } else if (sev === 'low') {
-        severityCounts.low++;
-      } else if (sev === 'info') {
-        severityCounts.info++;
-      } else {
-        // Default unknown severities to medium
-        severityCounts.medium++;
-      }
-    });
+    lines.push(`  ${sevColor}${ansi.bold} ${sevLabel} ${ansi.reset} ${ansi.bold}${truncate(blocker.title || blocker.message, 45)}${ansi.reset}`);
     
-    // Calculate score with proper weights
-    // Critical: 25 points each, High: 15, Medium: 5, Low: 2, Info: 0
-    const deductions = 
-      (severityCounts.critical * 25) +
-      (severityCounts.high * 15) +
-      (severityCounts.medium * 5) +
-      (severityCounts.low * 2);
+    if (blocker.description) {
+      lines.push(`             ${ansi.dim}${truncate(blocker.description, 55)}${ansi.reset}`);
+    }
     
-    // Cap deductions to prevent negative scores, but allow score to go to 0
-    const calculatedScore = Math.max(0, 100 - deductions);
+    if (blocker.file) {
+      const fileDisplay = blocker.file + (blocker.line ? `:${blocker.line}` : '');
+      lines.push(`             ${colors.accent}${truncate(fileDisplay, 50)}${ansi.reset}`);
+    }
     
-    // If we have findings but score is still 100, something's wrong - recalculate more aggressively
-    if (findings.length > 0 && calculatedScore === 100 && deductions === 0) {
-      // All findings were info or unknown - still deduct something
-      return Math.max(50, 100 - (findings.length * 0.1));
+    if (blocker.fix || blocker.fixSuggestion) {
+      lines.push(`             ${colors.success}→ ${truncate(blocker.fix || blocker.fixSuggestion, 50)}${ansi.reset}`);
     }
     
-    return Math.round(calculatedScore);
+    lines.push('');
   }
   
-  // Handle different input structures
-  if (result.verdict) {
-    // New unified output structure
-    if (typeof result.verdict === 'object') {
-      findings = result.findings || [];
-      
-      // Always recalculate score from findings to ensure accuracy
-      score = calculateScoreFromFindings(findings);
-      
-      // Only use provided score if it seems reasonable (not 100 when we have findings)
-      if (result.verdict.score && findings.length === 0) {
-        score = result.verdict.score;
-      } else if (result.verdict.score && result.verdict.score < score) {
-        // Use the lower (worse) score if provided score is worse
-        score = result.verdict.score;
-      }
-      
-      duration = result.timings?.total || result.duration || 0;
-      scannedFiles = result.timings?.filesScanned || result.scannedFiles || findings.length || 0;
-    } else {
-      // Legacy structure where verdict is just a string
-      findings = result.findings || [];
-      score = calculateScoreFromFindings(findings);
-      
-      // Fallback to verdict string if no findings
-      if (!score && findings.length === 0) {
-        const verdictStr = result.verdict;
-        if (verdictStr === 'PASS' || verdictStr === 'SHIP') score = 100;
-        else if (verdictStr === 'WARN') score = 70;
-        else if (verdictStr === 'FAIL' || verdictStr === 'BLOCK') score = 40;
-      }
-      
-      duration = result.timings?.total || result.duration || 0;
-      scannedFiles = result.timings?.filesScanned || result.scannedFiles || findings.length || 0;
-    }
-  } else {
-    // Direct structure
-    findings = result.findings || [];
-    score = calculateScoreFromFindings(findings);
-    
-    // Only use provided score if it seems reasonable
-    if (result.score && findings.length === 0) {
-      score = result.score;
-    } else if (result.score && result.score < score) {
-      score = result.score; // Use worse score
+  if (blockers.length > maxItems) {
+    lines.push(`  ${ansi.dim}... and ${blockers.length - maxItems} more blockers${ansi.reset}`);
+    lines.push('');
+  }
+  
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CATEGORY SUMMARY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function renderCategorySummary(findings) {
+  if (!findings || findings.length === 0) return '';
+  
+  // Group by category
+  const categories = {};
+  for (const f of findings) {
+    const cat = f.category || f.ruleId?.split('/')[0] || 'other';
+    if (!categories[cat]) {
+      categories[cat] = { critical: 0, high: 0, medium: 0, low: 0, total: 0 };
     }
+    categories[cat].total++;
     
-    duration = result.duration || result.timings?.total || 0;
-    scannedFiles = result.scannedFiles || result.timings?.filesScanned || 0;
+    const sev = (f.severity || '').toLowerCase();
+    if (sev === 'critical' || sev === 'block') categories[cat].critical++;
+    else if (sev === 'high') categories[cat].high++;
+    else if (sev === 'medium' || sev === 'warn' || sev === 'warning') categories[cat].medium++;
+    else categories[cat].low++;
   }
-
-  const hasIssues = findings.length > 0;
-  const heapMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+  
   const lines = [];
-
-  // 1. OUTER FRAME TOP
-  lines.push(`${chalk.gray}${BOX.topLeft}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.topRight}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-
-  // 2. LOGO (Cyan if clean, Red if issues)
-  const logoColorCode = hasIssues ? chalk.red : chalk.cyan;
-  padLogoBlock(LOGO_SCAN, WIDTH - 2).forEach(line => {
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${logoColorCode}${line}${chalk.reset}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  });
-  
-  const subTitle = hasIssues ? 'INTEGRITY SCAN • ISSUES DETECTED' : 'INTEGRITY SCAN • CLEAN';
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.bold}${chalk.white}${subTitle}${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-
-  // 3. TELEMETRY
-  lines.push(`${chalk.gray}${BOX.teeRight}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.teeLeft}${chalk.reset}`);
-  const stats = `📡 TELEMETRY  │ ⏱  ${duration}ms  │ 📂 ${scannedFiles} Files  │ 📦 ${heapMB}MB`;
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(stats, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.teeRight}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.teeLeft}${chalk.reset}`);
-
-  if (!hasIssues) {
-    // -- CLEAN STATE --
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.green}✅  NO STATIC ISSUES FOUND${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  } else {
-    // -- ISSUES STATE --
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    const scoreBar = renderProgressBar(score, 20);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`HEALTH SCORE    [${scoreBar}] ${score} / 100`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-
-    // 4. FINDINGS SUMMARY BY CATEGORY
-    const categoryCounts = {};
-    findings.forEach(f => {
-      const cat = f.category || f.type || f.ruleId || 'Other';
-      categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
+  lines.push(renderSection('FINDINGS BY CATEGORY', '📁'));
+  lines.push('');
+  
+  const categoryIcons = {
+    ROUTE: '🔗',
+    AUTH: '🔐',
+    SECRET: '🔑',
+    BILLING: '💳',
+    MOCK: '🎭',
+    DEAD_UI: '👻',
+    FAKE_SUCCESS: '✨',
+    REALITY: '🔬',
+    QUALITY: '📋',
+    CONFIG: '⚙️',
+  };
+  
+  const sortedCategories = Object.entries(categories)
+    .sort((a, b) => {
+      // Sort by criticality: critical > high > medium > low
+      const aCrit = a[1].critical * 1000 + a[1].high * 100 + a[1].medium * 10;
+      const bCrit = b[1].critical * 1000 + b[1].high * 100 + b[1].medium * 10;
+      return bCrit - aCrit;
     });
+  
+  for (const [cat, counts] of sortedCategories) {
+    const icon = categoryIcons[cat.toUpperCase()] || '•';
+    const critStr = counts.critical > 0 ? `${colors.critical}${counts.critical}C${ansi.reset} ` : '';
+    const highStr = counts.high > 0 ? `${colors.high}${counts.high}H${ansi.reset} ` : '';
+    const medStr = counts.medium > 0 ? `${colors.medium}${counts.medium}M${ansi.reset} ` : '';
+    const lowStr = counts.low > 0 ? `${colors.low}${counts.low}L${ansi.reset}` : '';
     
-    const categoryLabels = {
-      'EnvContract': '🔐 Env',
-      'MissingRoute': '🔗 Routes',
-      'GhostAuth': '🛡️ Auth',
-      'FakeSuccess': '⚠️ Fake',
-      'MockData': '🎭 Mocks',
-      'Secrets': '🔑 Secrets',
-      'ConsoleLog': '📝 Logs',
-      'TodoFixme': '📋 TODOs',
-      'CodeQuality': '✨ Quality',
-      'Security': '⚡ Security',
-      'Performance': '⚡ Perf',
-    };
-    
-    const summaryItems = Object.entries(categoryCounts)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 6)
-      .map(([cat, count]) => {
-        const label = categoryLabels[cat] || cat;
-        return `${label}: ${chalk.bold}${count}${chalk.reset}`;
-      });
-    
-    if (summaryItems.length > 0) {
-      // Simple left-aligned format with consistent spacing
-      const indent = '  ';
-      
-      // Always split into 2 rows of 3 for clean alignment
-      const row1 = summaryItems.slice(0, 3).join('   ');
-      const row2 = summaryItems.slice(3, 6).join('   ');
-      
-      lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${indent}${chalk.dim}FINDINGS:${chalk.reset} ${row1}${' '.repeat(Math.max(0, WIDTH - row1.length - 14))}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-      if (row2) {
-        lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${indent}${' '.repeat(10)}${row2}${' '.repeat(Math.max(0, WIDTH - row2.length - 14))}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-      }
-      lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    }
-
-    // 5. FINDINGS TABLE
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter('DETECTED VULNERABILITIES (STATIC)', WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    lines.push(`  ${icon} ${cat.padEnd(15)} ${ansi.dim}${String(counts.total).padStart(3)} total${ansi.reset}  ${critStr}${highStr}${medStr}${lowStr}`);
+  }
+  
+  return lines.join('\n');
+}
 
-    // Table Construction - Fixed alignment with proper spacing
-    const C1 = COL_1, C2 = COL_2, C3 = COL_3;
-    const tableContentWidth = C1 + C2 + C3 + 7; // 7 = borders (3 vertical + 4 spaces)
-    const tableLeftPad = Math.floor((WIDTH - 2 - tableContentWidth) / 2);
-    const tablePad = ' '.repeat(Math.max(1, tableLeftPad)); // At least 1 space padding
-    
-    // Table borders without padding (we'll add padding when inserting into frame)
-    const tTop = `${BOX.tTopLeft}${BOX.tHorizontal.repeat(C1)}${BOX.tTeeTop}${BOX.tHorizontal.repeat(C2)}${BOX.tTeeTop}${BOX.tHorizontal.repeat(C3)}${BOX.tTopRight}`;
-    const tMid = `${BOX.tTeeLeft}${BOX.tHorizontal.repeat(C1)}${BOX.tTee}${BOX.tHorizontal.repeat(C2)}${BOX.tTee}${BOX.tHorizontal.repeat(C3)}${BOX.tTeeRight}`;
-    const tBot = `${BOX.tBottomLeft}${BOX.tHorizontal.repeat(C1)}${BOX.tTeeBottom}${BOX.tHorizontal.repeat(C2)}${BOX.tTeeBottom}${BOX.tHorizontal.repeat(C3)}${BOX.tBottomRight}`;
+// ═══════════════════════════════════════════════════════════════════════════════
+// FULL SCAN OUTPUT
+// ═══════════════════════════════════════════════════════════════════════════════
 
-    // Calculate right padding to fill the line
-    const totalTableWidth = tablePad.length + tableContentWidth;
-    const rightPad = WIDTH - 2 - totalTableWidth;
-    const rightPadStr = ' '.repeat(Math.max(0, rightPad));
+function formatScanOutput(result, options = {}) {
+  const { verbose = false, json = false } = options;
+  
+  if (json) {
+    return JSON.stringify(result, null, 2);
+  }
+  
+  const { verdict, findings = [], layers = [], coverage, breakdown, timings = {} } = result;
+  
+  // Count findings by severity
+  const severityCounts = {
+    critical: findings.filter(f => f.severity === 'critical' || f.severity === 'BLOCK').length,
+    high: findings.filter(f => f.severity === 'high').length,
+    medium: findings.filter(f => f.severity === 'medium' || f.severity === 'WARN' || f.severity === 'warning').length,
+    low: findings.filter(f => f.severity === 'low' || f.severity === 'INFO' || f.severity === 'info').length,
+  };
+  
+  // Calculate score
+  const score = verdict?.score ?? calculateScore(severityCounts);
+  const verdictStatus = verdict?.verdict || (severityCounts.critical > 0 ? 'BLOCK' : severityCounts.high > 0 ? 'WARN' : 'SHIP');
+  
+  const lines = [];
+  
+  // Score card
+  lines.push(renderScoreCard(score, {
+    verdict: verdictStatus,
+    findings: severityCounts,
+    duration: timings.total,
+    cached: result.cached,
+  }));
+  
+  // Blockers (critical + high severity findings)
+  const blockers = findings.filter(f => 
+    f.severity === 'critical' || f.severity === 'BLOCK' || f.severity === 'high'
+  );
+  lines.push(renderBlockers(blockers));
+  
+  // Category summary
+  if (findings.length > 0) {
+    lines.push(renderCategorySummary(findings));
+  }
+  
+  // Verbose output
+  if (verbose) {
+    // Coverage map
+    if (coverage) {
+      lines.push('');
+      lines.push(renderCoverageMap(coverage));
+    }
     
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${tablePad}${chalk.gray}${tTop}${chalk.reset}${rightPadStr}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    const header = `${tablePad}${BOX.tVertical}${padRight(' SEVERITY', C1)}${BOX.tVertical}${padRight(' TYPE', C2)}${BOX.tVertical}${padRight(' FINDING', C3)}${BOX.tVertical}`;
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${chalk.bold}${header}${chalk.reset}${rightPadStr}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${tablePad}${chalk.gray}${tMid}${chalk.reset}${rightPadStr}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-
-    // Rows - map findings to display format (show top 10)
-    const topItems = findings.slice(0, 10);
-    topItems.forEach(item => {
-      // Handle different finding structures
-      const severityText = item.severity === 'critical' || item.severity === 'BLOCK' || item.category === 'critical' 
-        ? '🛑 CRIT  ' 
-        : item.severity === 'warning' || item.severity === 'WARN' || item.category === 'warning'
-        ? '🟡 WARN  '
-        : '🟡 WARN  ';
-      
-      const severityColor = item.severity === 'critical' || item.severity === 'BLOCK' || item.category === 'critical' 
-        ? chalk.red 
-        : chalk.yellow;
-      
-      const severity = `${severityColor}${severityText}${chalk.reset}`;
-      
-      // Map category to readable type
-      const categoryMap = {
-        'EnvContract': 'EnvVar',
-        'MissingRoute': 'Route',
-        'GhostAuth': 'Auth',
-        'FakeSuccess': 'FakeSuccess',
-        'MockData': 'MockData',
-        'Secrets': 'Secret',
-        'ConsoleLog': 'Console',
-        'TodoFixme': 'TODO',
-      };
-      const typeName = categoryMap[item.category] || item.category || item.type || item.ruleId || 'Unknown';
-      const type = padRight(' ' + typeName, C2);
-      
-      // Truncate description if too long
-      let desc = item.message || item.title || item.description || '';
-      if (desc.length > C3 - 1) {
-        desc = desc.substring(0, C3 - 4) + '...';
-      }
-      desc = padRight(' ' + desc, C3);
-      
-      const row = `${tablePad}${chalk.gray}${BOX.tVertical}${chalk.reset}${padRight(severity, C1)}${chalk.gray}${BOX.tVertical}${chalk.reset}${type}${chalk.gray}${BOX.tVertical}${chalk.reset}${desc}${chalk.gray}${BOX.tVertical}${chalk.reset}`;
-      lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${row}${rightPadStr}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-    });
-
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${tablePad}${chalk.gray}${tBot}${chalk.reset}${rightPadStr}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    // Breakdown
+    if (breakdown) {
+      lines.push('');
+      lines.push(renderBreakdown(breakdown));
+    }
     
-    // Show count if more findings exist
-    if (findings.length > 10) {
-      lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.dim}... and ${findings.length - 10} more findings${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    // Layers
+    if (layers.length > 0) {
+      lines.push('');
+      lines.push(renderLayers(layers));
     }
     
-    lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+    // All findings
+    if (findings.length > 0) {
+      lines.push('');
+      lines.push(renderFindingsList(findings, { maxItems: 20, groupBySeverity: true }));
+    }
   }
-
-  // 6. UPSELL SECTION - Autofix & Mission Packs
-  lines.push(`${chalk.gray}${BOX.teeRight}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.teeLeft}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  
-  // Autofix Upsell
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.bold}${chalk.cyan}🚀 AUTO-FIX AVAILABLE${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.dim}Fix ${findings.length} issues automatically with AI-powered autofix${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`Run ${chalk.cyan}vibecheck scan --autofix${chalk.reset} to apply fixes`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
   
-  // Mission Packs Upsell
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.bold}${chalk.magenta}📦 MISSION PACKS${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.dim}Get AI-generated fix plans grouped by feature area${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`Run ${chalk.cyan}vibecheck fix --packs${chalk.reset} to generate mission packs`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  // Timing summary
+  if (timings.total) {
+    lines.push('');
+    lines.push(`  ${ansi.dim}Completed in ${formatDuration(timings.total)}${ansi.reset}`);
+  }
   
-  // Upgrade CTA
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${chalk.bold}★ Upgrade for unlimited scans + auto-fix${chalk.reset}  →  ${chalk.cyan}https://vibecheckai.dev${chalk.reset}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+  lines.push('');
+  return lines.join('\n');
+}
 
-  // BOTTOM FRAME
-  lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-  lines.push(`${chalk.gray}${BOX.bottomLeft}${BOX.horizontal.repeat(WIDTH - 2)}${BOX.bottomRight}${chalk.reset}`);
+// ═══════════════════════════════════════════════════════════════════════════════
+// SCORE CALCULATION
+// ═══════════════════════════════════════════════════════════════════════════════
 
-  return lines.join('\n');
+function calculateScore(severityCounts) {
+  const deductions = 
+    (severityCounts.critical || 0) * 25 +
+    (severityCounts.high || 0) * 15 +
+    (severityCounts.medium || 0) * 5 +
+    (severityCounts.low || 0) * 1;
+  
+  return Math.max(0, 100 - deductions);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// ADDITIONAL EXPORTS (for compatibility with runScan.js)
+// EXIT CODE DETERMINATION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-// Exit codes
 const EXIT_CODES = {
-  SHIP: 0,
-  WARN: 1,
-  BLOCK: 2,
-  ERROR: 1,
-  MISCONFIG: 3,
-  INTERNAL: 1,
-};
-
-// Severity weights for scoring
-const SEVERITY_WEIGHTS = {
-  critical: 25,
-  high: 15,
-  medium: 5,
-  low: 1,
-  info: 0,
+  SUCCESS: 0,
+  WARNING: 1,
+  FAILURE: 2,
+  ERROR: 3,
 };
 
-/**
- * Calculate overall score from severity counts
- */
-function calculateScore(severityCounts, totalFindings = 0) {
-  if (totalFindings === 0) return 100;
-  
-  const deductions =
-    (severityCounts.critical || 0) * SEVERITY_WEIGHTS.critical +
-    (severityCounts.high || 0) * SEVERITY_WEIGHTS.high +
-    (severityCounts.medium || 0) * SEVERITY_WEIGHTS.medium +
-    (severityCounts.low || 0) * SEVERITY_WEIGHTS.low;
-  
-  // Cap deductions at 100
-  const score = Math.max(0, 100 - deductions);
-  return Math.round(score);
-}
-
-/**
- * Get exit code from verdict
- */
 function getExitCode(verdict) {
-  if (!verdict) return EXIT_CODES.BLOCK;
-  const v = typeof verdict === 'object' ? verdict.verdict : verdict;
-  if (v === 'SHIP' || v === 'PASS') return EXIT_CODES.SHIP;
-  if (v === 'WARN') return EXIT_CODES.WARN;
-  return EXIT_CODES.BLOCK;
+  if (!verdict) return EXIT_CODES.ERROR;
+  
+  const status = verdict.verdict || verdict;
+  
+  switch (status) {
+    case 'PASS':
+    case 'SHIP':
+      return EXIT_CODES.SUCCESS;
+    case 'WARN':
+      return EXIT_CODES.WARNING;
+    case 'FAIL':
+    case 'BLOCK':
+      return EXIT_CODES.FAILURE;
+    default:
+      return EXIT_CODES.ERROR;
+  }
 }
 
-/**
- * Print error message
- */
+// ═══════════════════════════════════════════════════════════════════════════════
+// ERROR DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
 function printError(error, context = '') {
-  const isConfig = error.message && (
-    error.message.includes('config') || 
-    error.message.includes('missing') ||
-    error.message.includes('not found')
-  );
-  const exitCode = isConfig ? EXIT_CODES.MISCONFIG : EXIT_CODES.INTERNAL;
+  const prefix = context ? `${context}: ` : '';
+  
+  console.error('');
+  console.error(`  ${colors.error}${icons.error}${ansi.reset} ${ansi.bold}${prefix}${error.message || error}${ansi.reset}`);
   
-  console.error(`${chalk.red}✗ Error${chalk.reset}`);
-  if (context) console.error(`  ${chalk.dim}${context}${chalk.reset}`);
-  console.error(`  ${error.message || error}`);
-  if (error.stack && process.env.VIBECHECK_DEBUG) {
-    console.error(`${chalk.dim}${error.stack}${chalk.reset}`);
+  if (error.code) {
+    console.error(`  ${ansi.dim}Error code: ${error.code}${ansi.reset}`);
   }
   
-  return exitCode;
+  if (error.suggestion || error.fix) {
+    console.error(`  ${colors.success}${icons.arrowRight}${ansi.reset} ${error.suggestion || error.fix}`);
+  }
+  
+  if (error.docs || error.helpUrl) {
+    console.error(`  ${ansi.dim}See: ${error.docs || error.helpUrl}${ansi.reset}`);
+  }
+  
+  console.error('');
+  
+  // Return appropriate exit code
+  if (error.code === 'VALIDATION_ERROR') return EXIT_CODES.FAILURE;
+  if (error.code === 'LIMIT_EXCEEDED') return EXIT_CODES.WARNING;
+  return EXIT_CODES.ERROR;
 }
 
-/**
- * Format SARIF output (placeholder - full implementation in report-engine.js)
- */
+// ═══════════════════════════════════════════════════════════════════════════════
+// SARIF OUTPUT
+// ═══════════════════════════════════════════════════════════════════════════════
+
 function formatSARIF(findings, options = {}) {
-  // Basic SARIF structure - full implementation should be in report-engine.js
-  return JSON.stringify({
-    version: "2.1.0",
-    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema.json",
+  const { projectPath = '.', version = '1.0.0' } = options;
+  
+  const rules = new Map();
+  const results = [];
+  
+  for (const f of findings) {
+    const ruleId = f.ruleId || f.id || `vibecheck/${f.category || 'general'}`;
+    
+    if (!rules.has(ruleId)) {
+      rules.set(ruleId, {
+        id: ruleId,
+        name: f.category || 'general',
+        shortDescription: { text: f.title || f.message },
+        defaultConfiguration: {
+          level: sarifLevel(f.severity),
+        },
+        helpUri: 'https://vibecheck.dev/docs/rules/' + ruleId,
+      });
+    }
+    
+    const result = {
+      ruleId,
+      level: sarifLevel(f.severity),
+      message: { text: f.message || f.title },
+      locations: [],
+    };
+    
+    if (f.file) {
+      result.locations.push({
+        physicalLocation: {
+          artifactLocation: { uri: f.file },
+          region: f.line ? { startLine: f.line, startColumn: f.column || 1 } : undefined,
+        },
+      });
+    }
+    
+    if (f.fix) {
+      result.fixes = [{ description: { text: f.fix } }];
+    }
+    
+    results.push(result);
+  }
+  
+  return {
+    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+    version: '2.1.0',
     runs: [{
       tool: {
         driver: {
-          name: "vibecheck",
-          version: options.version || "1.0.0"
-        }
-      },
-      results: findings.map((f, i) => ({
-        ruleId: f.ruleId || f.category || `rule-${i}`,
-        message: {
-          text: f.message || f.title || ""
+          name: 'vibecheck',
+          version,
+          informationUri: 'https://vibecheck.dev',
+          rules: Array.from(rules.values()),
         },
-        level: f.severity === 'critical' ? 'error' : f.severity === 'warning' ? 'warning' : 'note',
-        locations: f.file ? [{
-          physicalLocation: {
-            artifactLocation: {
-              uri: f.file
-            },
-            region: f.line ? {
-              startLine: f.line
-            } : undefined
-          }
-        }] : []
-      }))
-    }]
-  }, null, 2);
-}
-
-// Placeholder functions for compatibility
-function renderCoverageMap(coverageMap) {
-  return ''; // Implement if needed
-}
-
-function renderBreakdown(breakdown) {
-  return ''; // Implement if needed
-}
-
-function renderBlockers(blockers) {
-  return ''; // Implement if needed
+      },
+      results,
+      invocations: [{
+        executionSuccessful: true,
+        endTimeUtc: new Date().toISOString(),
+      }],
+    }],
+  };
 }
 
-function renderLayers(layers) {
-  return ''; // Implement if needed
+function sarifLevel(severity) {
+  const levels = {
+    critical: 'error',
+    BLOCK: 'error',
+    high: 'error',
+    medium: 'warning',
+    WARN: 'warning',
+    warning: 'warning',
+    low: 'note',
+    INFO: 'note',
+    info: 'none',
+  };
+  return levels[severity] || 'warning';
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// ENHANCED OUTPUT (with charts and Pro upselling)
+// EXPORTS
 // ═══════════════════════════════════════════════════════════════════════════════
 
-let enhancedOutput;
-try {
-  enhancedOutput = require('./scan-output-enhanced');
-} catch (e) {
-  enhancedOutput = null;
-}
-
-/**
- * Format scan output with enhanced visuals (charts, upsell)
- * Falls back to standard output if enhanced module not available
- */
-function formatScanOutputEnhanced(result, options = {}) {
-  if (enhancedOutput && !options.legacy) {
-    enhancedOutput.renderEnhancedScanOutput(result, options);
-    return ''; // Output is printed directly
-  }
-  return formatScanOutput(result, options);
-}
-
-/**
- * Get Pro upsell prompt for current context
- */
-function getProUpsellPrompt(context, data = {}) {
-  if (enhancedOutput) {
-    return enhancedOutput.getProPrompt(context, data);
-  }
-  return null;
-}
-
-/**
- * Render inline Pro upsell
- */
-function renderProUpsell(context, data = {}) {
-  if (enhancedOutput) {
-    return enhancedOutput.renderInlineProPrompt(context, data);
-  }
-  return '';
-}
-
-module.exports = { 
+module.exports = {
+  // Main formatters
   formatScanOutput,
-  formatScanOutputEnhanced,
-  calculateScore,
-  getExitCode,
-  printError,
   formatSARIF,
-  EXIT_CODES,
+  
+  // Component renderers
+  renderLayers,
   renderCoverageMap,
   renderBreakdown,
   renderBlockers,
-  renderLayers,
-  // Pro upsell
-  getProUpsellPrompt,
-  renderProUpsell,
-};
+  renderCategorySummary,
+  
+  // Utilities
+  calculateScore,
+  getExitCode,
+  printError,
+  EXIT_CODES,
+};