vibecodingmachine-cli 2026.2.20-436 → 2026.2.26-1642

package/src/commands/check-compliance.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Command for Checking Compliance
+ * 
+ * Provides command-line interface for checking file size compliance
+ * and constitutional adherence across the codebase.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { program } = require('commander');
+
+// Import core modules
+const { LineLimitValidator } = require('../../../core/src/validation/line-limit-validator');
+const { ConstitutionValidator } = require('../../../core/src/validation/constitution-validator');
+const ComplianceReporter = require('../../../core/src/validation/compliance-reporter');
+// const FileMonitor = require('../../../core/src/monitoring/file-monitor');
+const { AlertSystem } = require('../../../core/src/monitoring/alert-system');
+
+// Configuration
+const DEFAULT_CONFIG = {
+  maxFileSize: 555,
+  warningThreshold: 500,
+  criticalThreshold: 800,
+  allowedFileTypes: ['js', 'jsx', 'ts', 'tsx', 'md', 'json'],
+  excludedPaths: [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.vscode',
+    '.idea',
+    '.cursor',
+    '.windsurf',
+    'vendor',
+    'bower_components'
+  ]
+};
+
+/**
+ * Colors for console output
+ */
+const COLORS = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m'
+};
+
+/**
+ * Color output helper
+ */
+function colorLog(color, message) {
+  console.log(`${COLORS[color]}${message}${COLORS.reset}`);
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Format duration
+ */
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+/**
+ * Get all files in directory recursively
+ */
+async function getAllFiles(dirPath, options = {}) {
+  const files = [];
+  
+  const scanDir = (dir) => {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory()) {
+          // Skip excluded directories
+          if (!options.excludedPaths?.some(pattern => fullPath.includes(pattern))) {
+            scanDir(fullPath);
+          }
+        } else if (entry.isFile()) {
+          // Check file extension
+          const ext = path.extname(fullPath).slice(1);
+          if (options.allowedFileTypes?.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      if (!options.quiet) {
+        colorLog('yellow', `⚠️  Warning: Cannot read directory ${dir}: ${error.message}`);
+      }
+    }
+  };
+  
+  scanDir(dirPath);
+  return files;
+}
+
+/**
+ * Validate single file
+ */
+async function validateFile(filePath, validators, options) {
+  const results = {
+    filePath,
+    lineCount: 0,
+    fileSize: 0,
+    lineLimitValidation: null,
+    constitutionalValidation: null,
+    hasViolations: false,
+    hasWarnings: false
+  };
+  
+  try {
+    if (!fs.existsSync(filePath)) {
+      return results;
+    }
+    
+    // Get file stats
+    const fileStats = fs.statSync(filePath);
+    results.fileSize = fileStats.size;
+    
+    // Read file content
+    const content = fs.readFileSync(filePath, 'utf8');
+    results.lineCount = content.split('\n').length;
+    
+    // Line limit validation
+    if (validators.lineLimit) {
+      results.lineLimitValidation = validators.lineLimit.validateFile(filePath);
+    }
+    
+    // Constitutional validation
+    if (validators.constitution && options.enableConstitutional) {
+      results.constitutionalValidation = validators.constitution.validateFile(filePath);
+    }
+    
+    // Determine violation/warning status
+    results.hasViolations = !results.lineLimitValidation?.isValid || 
+                          (results.constitutionalValidation?.some(r => r.severity === 'critical' || r.severity === 'error'));
+    
+    results.hasWarnings = results.lineLimitValidation?.violation?.type === 'warning' ||
+                         (results.constitutionalValidation?.some(r => r.severity === 'warning'));
+    
+  } catch (error) {
+    results.error = error.message;
+  }
+  
+  return results;
+}
+
+/**
+ * Validate multiple files
+ */
+async function validateFiles(filePaths, validators, options) {
+  const results = [];
+  const startTime = Date.now();
+  
+  if (options.parallel) {
+    // Process files in parallel
+    const promises = filePaths.map(filePath => validateFile(filePath, validators, options));
+    const settled = await Promise.allSettled(promises);
+    
+    for (const result of settled) {
+      if (result.status === 'fulfilled') {
+        results.push(result.value);
+      } else {
+        if (!options.quiet) {
+          colorLog('red', `❌  Error processing file: ${result.reason.message}`);
+        }
+      }
+    }
+  } else {
+    // Process files sequentially
+    for (const filePath of filePaths) {
+      try {
+        const result = await validateFile(filePath, validators, options);
+        results.push(result);
+        
+        if (options.progress && filePaths.length > 10) {
+          const progress = (results.length / filePaths.length * 100).toFixed(1);
+          process.stdout.write(`\rProgress: ${progress}% (${results.length}/${filePaths.length})`);
+        }
+      } catch (error) {
+        if (!options.quiet) {
+          colorLog('red', `❌  Error validating ${filePath}: ${error.message}`);
+        }
+      }
+    }
+    
+    if (options.progress && filePaths.length > 10) {
+      console.log(''); // New line after progress
+    }
+  }
+  
+  const duration = Date.now() - startTime;
+  return { results, duration };
+}
+
+/**
+ * Print validation summary
+ */
+function printSummary(results, duration, options) {
+  const totalFiles = results.length;
+  const compliantFiles = results.filter(r => !r.hasViolations && !r.hasWarnings).length;
+  const warningFiles = results.filter(r => r.hasWarnings && !r.hasViolations).length;
+  const violationFiles = results.filter(r => r.hasViolations).length;
+  
+  const totalLines = results.reduce((sum, r) => sum + r.lineCount, 0);
+  const totalSize = results.reduce((sum, r) => sum + r.fileSize, 0);
+  
+  console.log('\n' + COLORS.bold + 'Compliance Summary' + COLORS.reset);
+  console.log('─'.repeat(50));
+  
+  // Basic stats
+  console.log(`📁 Files analyzed: ${COLORS.cyan}${totalFiles}${COLORS.reset}`);
+  console.log(`✅ Compliant files: ${COLORS.green}${compliantFiles}${COLORS.reset}`);
+  console.log(`⚠️  Warning files: ${COLORS.yellow}${warningFiles}${COLORS.reset}`);
+  console.log(`❌ Violation files: ${COLORS.red}${violationFiles}${COLORS.reset}`);
+  
+  // Compliance rate
+  const complianceRate = totalFiles > 0 ? (compliantFiles / totalFiles * 100) : 100;
+  const complianceColor = complianceRate >= 90 ? 'green' : complianceRate >= 70 ? 'yellow' : 'red';
+  console.log(`📊 Compliance rate: ${COLORS[complianceColor]}${complianceRate.toFixed(1)}%${COLORS.reset}`);
+  
+  // File stats
+  console.log(`📏 Total lines: ${COLORS.cyan}${totalLines.toLocaleString()}${COLORS.reset}`);
+  console.log(`💾 Total size: ${COLORS.cyan}${formatBytes(totalSize)}${COLORS.reset}`);
+  console.log(`⏱️  Analysis time: ${COLORS.blue}${formatDuration(duration)}${COLORS.reset}`);
+  
+  // Average stats
+  if (totalFiles > 0) {
+    const avgLines = Math.round(totalLines / totalFiles);
+    const avgSize = Math.round(totalSize / totalFiles);
+    console.log(`📈 Average lines/file: ${COLORS.cyan}${avgLines}${COLORS.reset}`);
+    console.log(`📈 Average size/file: ${COLORS.cyan}${formatBytes(avgSize)}${COLORS.reset}`);
+  }
+  
+  return {
+    totalFiles,
+    compliantFiles,
+    warningFiles,
+    violationFiles,
+    complianceRate,
+    totalLines,
+    totalSize,
+    duration
+  };
+}
+
+/**
+ * Print violations
+ */
+function printViolations(results, options) {
+  const violatingFiles = results.filter(r => r.hasViolations);
+  
+  if (violatingFiles.length === 0) {
+    colorLog('green', '\n🎉 No violations found!');
+    return;
+  }
+  
+  console.log('\n' + COLORS.bold + 'Violations' + COLORS.reset);
+  console.log('─'.repeat(50));
+  
+  for (const file of violatingFiles.sort((a, b) => b.lineCount - a.lineCount)) {
+    console.log(`\n${COLORS.red}❌ ${file.filePath}${COLORS.reset}`);
+    console.log(`   Lines: ${file.lineCount}`);
+    
+    // Line limit violations
+    if (file.lineLimitValidation && !file.lineLimitValidation.isValid) {
+      const violation = file.lineLimitValidation.violation;
+      if (violation) {
+        console.log(`   ${COLORS.red}Line limit violation: ${violation.message}${COLORS.reset}`);
+        console.log(`   Excess: ${violation.excessLines} lines (${violation.percentageOverLimit}% over)`);
+      } else {
+        console.log(`   ${COLORS.red}Line limit violation: File exceeds size limit${COLORS.reset}`);
+      }
+    }
+    
+    // Constitutional violations
+    if (file.constitutionalValidation) {
+      const criticalIssues = file.constitutionalValidation.filter(r => r.severity === 'critical');
+      const errorIssues = file.constitutionalValidation.filter(r => r.severity === 'error');
+      
+      for (const issue of criticalIssues) {
+        console.log(`   ${COLORS.red}🚨 Critical (${issue.category}): ${issue.message}${COLORS.reset}`);
+      }
+      
+      for (const issue of errorIssues) {
+        console.log(`   ${COLORS.red}❌ Error (${issue.category}): ${issue.message}${COLORS.reset}`);
+      }
+    }
+  }
+}
+
+/**
+ * Print warnings
+ */
+function printWarnings(results, options) {
+  const warningFiles = results.filter(r => r.hasWarnings && !r.hasViolations);
+  
+  if (warningFiles.length === 0) {
+    return;
+  }
+  
+  console.log('\n' + COLORS.bold + 'Warnings' + COLORS.reset);
+  console.log('─'.repeat(50));
+  
+  for (const file of warningFiles.sort((a, b) => b.lineCount - a.lineCount)) {
+    console.log(`\n${COLORS.yellow}⚠️  ${file.filePath}${COLORS.reset}`);
+    console.log(`   Lines: ${file.lineCount}`);
+    
+    // Line limit warnings
+    if (file.lineLimitValidation?.violation?.type === 'warning') {
+      console.log(`   ${COLORS.yellow}Approaching limit: ${file.lineLimitValidation.violation.message}${COLORS.reset}`);
+    }
+    
+    // Constitutional warnings
+    if (file.constitutionalValidation) {
+      const warningIssues = file.constitutionalValidation.filter(r => r.severity === 'warning');
+      
+      for (const issue of warningIssues) {
+        console.log(`   ${COLORS.yellow}⚠️  Warning (${issue.category}): ${issue.message}${COLORS.reset}`);
+      }
+    }
+  }
+}
+
+/**
+ * Print top files
+ */
+function printTopFiles(results, options) {
+  const topFiles = results
+    .sort((a, b) => b.lineCount - a.lineCount)
+    .slice(0, options.top || 10);
+  
+  console.log('\n' + COLORS.bold + `Top ${topFiles.length} Files by Size` + COLORS.reset);
+  console.log('─'.repeat(50));
+  
+  for (let i = 0; i < topFiles.length; i++) {
+    const file = topFiles[i];
+    const status = file.hasViolations ? '❌' : file.hasWarnings ? '⚠️' : '✅';
+    const statusColor = file.hasViolations ? 'red' : file.hasWarnings ? 'yellow' : 'green';
+    
+    console.log(`${i + 1}. ${COLORS[statusColor]}${status}${COLORS.reset} ${file.filePath}`);
+    console.log(`   ${file.lineCount} lines • ${formatBytes(file.fileSize)}`);
+  }
+}
+
+/**
+ * Generate and save report
+ */
+async function generateReport(results, options) {
+  if (!options.report) {
+    return;
+  }
+  
+  try {
+    const reporter = new ComplianceReporter({
+      outputDir: path.dirname(options.report),
+      formats: [path.extname(options.report).slice(1) || 'json']
+    });
+    
+    const reportResult = await reporter.generateReport(results, {
+      title: 'CLI Compliance Report',
+      includeMetrics: true,
+      includeRecommendations: true
+    });
+    
+    colorLog('green', `\n📄 Report saved to: ${reportResult.files[0].filePath}`);
+    
+  } catch (error) {
+    colorLog('red', `❌  Failed to generate report: ${error.message}`);
+  }
+}
+
+/**
+ * Main check compliance function
+ */
+async function checkCompliance(options) {
+  const startTime = Date.now();
+  
+  try {
+    // Initialize validators
+    const validators = {
+      lineLimit: new LineLimitValidator({
+        maxLines: options.maxFileSize,
+        warningThreshold: options.warningThreshold,
+        criticalThreshold: options.criticalThreshold
+      })
+    };
+    
+    if (options.enableConstitutional) {
+      validators.constitution = new ConstitutionValidator();
+    }
+    
+    // Get files to validate
+    colorLog('cyan', `🔍 Scanning ${options.path || 'current directory'} for files...`);
+    const files = await getAllFiles(options.path || process.cwd(), {
+      allowedFileTypes: options.fileTypes,
+      excludedPaths: options.excludedPaths,
+      quiet: options.quiet
+    });
+    
+    if (files.length === 0) {
+      colorLog('yellow', '⚠️  No files found to validate');
+      return;
+    }
+    
+    colorLog('cyan', `📁 Found ${files.length} files to validate`);
+    
+    // Validate files
+    const { results, duration } = await validateFiles(files, validators, options);
+    
+    // Print results
+    const summary = printSummary(results, duration, options);
+    
+    if (options.violations || options.verbose) {
+      printViolations(results, options);
+    }
+    
+    if (options.warnings || options.verbose) {
+      printWarnings(results, options);
+    }
+    
+    if (options.top) {
+      printTopFiles(results, options);
+    }
+    
+    // Generate report if requested
+    await generateReport(results, options);
+    
+    // Exit with appropriate code
+    if (summary.violationFiles > 0) {
+      if (!options.quiet) {
+        colorLog('red', `\n❌  Compliance check failed with ${summary.violationFiles} violations`);
+      }
+      process.exit(1);
+    } else if (summary.warningFiles > 0 && !options.warningsAllowed) {
+      if (!options.quiet) {
+        colorLog('yellow', `\n⚠️  Compliance check passed with ${summary.warningFiles} warnings`);
+      }
+      process.exit(2);
+    } else {
+      if (!options.quiet) {
+        colorLog('green', `\n✅  Compliance check passed successfully!`);
+      }
+      process.exit(0);
+    }
+    
+  } catch (error) {
+    colorLog('red', `❌  Compliance check failed: ${error.message}`);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Setup CLI program
+ */
+function setupProgram() {
+  program
+    .name('check-compliance')
+    .description('Check file size compliance and constitutional adherence')
+    .version('1.0.0');
+  
+  program
+    .argument('[path]', 'Path to check (default: current directory)')
+    .option('-m, --max-file-size <number>', 'Maximum file size in lines', String(DEFAULT_CONFIG.maxFileSize))
+    .option('-w, --warning-threshold <number>', 'Warning threshold in lines', String(DEFAULT_CONFIG.warningThreshold))
+    .option('-c, --critical-threshold <number>', 'Critical threshold in lines', String(DEFAULT_CONFIG.criticalThreshold))
+    .option('-t, --file-types <types>', 'File types to check (comma-separated)', DEFAULT_CONFIG.allowedFileTypes.join(','))
+    .option('-e, --exclude <paths>', 'Paths to exclude (comma-separated)', DEFAULT_CONFIG.excludedPaths.join(','))
+    .option('--enable-constitutional', 'Enable constitutional compliance checking', false)
+    .option('--parallel', 'Process files in parallel', false)
+    .option('--progress', 'Show progress bar', false)
+    .option('--violations', 'Show only violations', false)
+    .option('--warnings', 'Show warnings', false)
+    .option('--warnings-allowed', 'Allow warnings (exit code 0)', false)
+    .option('--top <number>', 'Show top N files by size', '10')
+    .option('--report <path>', 'Generate report file')
+    .option('--verbose', 'Verbose output', false)
+    .option('--quiet', 'Quiet mode', false)
+    .action(async (path, options) => {
+      // Parse options
+      options.path = path;
+      options.maxFileSize = parseInt(options.maxFileSize);
+      options.warningThreshold = parseInt(options.warningThreshold);
+      options.criticalThreshold = parseInt(options.criticalThreshold);
+      options.fileTypes = options.fileTypes.split(',').map(t => t.trim());
+      options.excludedPaths = options.exclude.split(',').map(p => p.trim());
+      options.top = parseInt(options.top);
+      
+      await checkCompliance(options);
+    });
+  
+  program.parse();
+}
+
+// Run if called directly
+if (require.main === module) {
+  setupProgram();
+}
+
+module.exports = {
+  checkCompliance,
+  getAllFiles,
+  validateFile,
+  validateFiles,
+  printSummary,
+  printViolations,
+  printWarnings,
+  printTopFiles,
+  generateReport
+};

package/src/commands/continuous-scan.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Continuous Scan CLI Command
+ * 
+ * This command runs continuous compliance scanning to identify files
+ * exceeding the 555-line limit and generates refactoring tasks.
+ */
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const { ContinuousScanner } = require('../../../core/src/monitoring/continuous-scanner');
+const taskListUpdater = require('../../../core/src/task-generation/task-list-updater');
+const complianceReporter = require('../../../core/src/validation/compliance-reporter');
+
+program
+  .name('continuous-scan')
+  .description('Run continuous compliance scanning for file size violations')
+  .option('-w, --watch', 'Run in watch mode for continuous monitoring')
+  .option('-o, --output <file>', 'Output report to file', 'continuous-scan-report.json')
+  .option('-t, --tasks', 'Generate refactoring tasks for violations')
+  .option('-v, --verbose', 'Verbose output with detailed information')
+  .option('--threshold <lines>', 'Line count threshold (default: 555)', '555')
+  .action(async (options) => {
+    try {
+      console.log(chalk.blue('🔍 Starting continuous compliance scan...'));
+      
+      // Initialize scanner
+      const scanner = new ContinuousScanner({
+        maxFileSize: parseInt(options.threshold),
+        enableFileWatching: options.watch
+      });
+      
+      // Set up event handlers
+      scanner.events.on('scan_completed', (data) => {
+        const violations = data.violations || [];
+        
+        if (violations.length === 0) {
+          console.log(chalk.green('✅ No file size violations found!'));
+          return;
+        }
+        
+        console.log(chalk.yellow(`⚠️  Found ${violations.length} files exceeding ${options.threshold} lines:`));
+        
+        // Display violations
+        violations.forEach((violation, index) => {
+          const severity = violation.lineCount > 1000 ? chalk.red('CRITICAL') : 
+                          violation.lineCount > 750 ? chalk.orange('HIGH') : 
+                          chalk.yellow('MEDIUM');
+          
+          console.log(`${index + 1}. ${violation.filePath} - ${violation.lineCount} lines ${severity}`);
+          
+          if (options.verbose) {
+            console.log(`   File size: ${(violation.fileSize / 1024).toFixed(2)} KB`);
+          }
+        });
+        
+        // Generate tasks if requested
+        if (options.tasks) {
+          console.log(chalk.blue('\n📋 Generating refactoring tasks...'));
+          // Task generation would be implemented here
+          console.log(chalk.yellow('⚠️  Task generation not yet implemented'));
+        }
+        
+        // Generate report
+        if (options.output) {
+          const report = {
+            timestamp: new Date().toISOString(),
+            violations: violations,
+            stats: data.stats || {}
+          };
+          require('fs').writeFileSync(options.output, JSON.stringify(report, null, 2));
+          console.log(chalk.blue(`📄 Report saved to: ${options.output}`));
+        }
+        
+        // Summary statistics
+        console.log(chalk.blue('\n📊 Scan Summary:'));
+        console.log(`Violations found: ${violations.length}`);
+        if (data.stats && data.stats.filesScanned) {
+          console.log(`Total files scanned: ${data.stats.filesScanned}`);
+          console.log(`Compliance rate: ${((data.stats.filesScanned - violations.length) / data.stats.filesScanned * 100).toFixed(1)}%`);
+        }
+      });
+      
+      // Start scanning
+      scanner.start();
+      
+      if (options.watch) {
+        console.log(chalk.green('👀 Watching for file changes... Press Ctrl+C to stop'));
+        
+        // Set up additional event handlers for continuous monitoring
+        scanner.events.on('violations_found', ({ count, violations }) => {
+          console.log(chalk.yellow(`\n🚨 Violations found: ${count}`));
+        });
+        
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+          console.log(chalk.yellow('\n🛑 Stopping continuous scan...'));
+          scanner.stop();
+          console.log(chalk.green('✅ Continuous scan stopped'));
+          process.exit(0);
+        });
+        
+        // Keep process running
+        // The scanner will continue running in the background
+      } else {
+        // Run for a short time then stop
+        setTimeout(() => {
+          scanner.stop();
+        }, 5000);
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ Error during continuous scan:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/commands/ide.js

@@ -138,16 +138,28 @@ async function health(options = {}) {
     console.log(chalk.bold('\n📈 Successful IDEs:'));
     for (const result of successful) {
       const metrics = await healthTracker.getHealthMetrics(result.ide);
-      console.log(chalk.cyan(`  ${result.ide}:`), 
-                 chalk.gray(`${result.responseTime}ms`), 
-                 chalk.green(`(+${metrics.successCount} -${metrics.failureCount})`));
+      console.log(chalk.cyan(`  ${result.ide}:`));
+      console.log(chalk.gray(`    Response Time: ${result.responseTime}ms`));
+      console.log(chalk.gray(`    Success Rate: ${(metrics.successRate * 100).toFixed(1)}%`));
+      console.log(chalk.gray(`    Total Successes: ${metrics.successCount}`));
+      console.log(chalk.gray(`    Total Failures: ${metrics.failureCount}`));
+      console.log(chalk.gray(`    Avg Response Time: ${Math.round(metrics.averageResponseTime)}ms`));
+      console.log(chalk.gray(`    Consecutive Failures: ${metrics.consecutiveFailures}`));
     }
   }
 
   if ((failed.length > 0 || timeouts.length > 0) && verbose) {
     console.log(chalk.bold('\n⚠️  Problematic IDEs:'));
     for (const result of [...failed, ...timeouts]) {
-      console.log(chalk.red(`  ${result.ide}:`), chalk.gray(result.error || 'Timeout'));
+      const metrics = await healthTracker.getHealthMetrics(result.ide);
+      console.log(chalk.red(`  ${result.ide}:`));
+      console.log(chalk.gray(`    Response Time: ${result.responseTime}ms`));
+      console.log(chalk.gray(`    Error: ${result.error || 'Timeout'}`));
+      console.log(chalk.gray(`    Success Rate: ${(metrics.successRate * 100).toFixed(1)}%`));
+      console.log(chalk.gray(`    Total Successes: ${metrics.successCount}`));
+      console.log(chalk.gray(`    Total Failures: ${metrics.failureCount}`));
+      console.log(chalk.gray(`    Avg Response Time: ${Math.round(metrics.averageResponseTime)}ms`));
+      console.log(chalk.gray(`    Consecutive Failures: ${metrics.consecutiveFailures}`));
     }
   }