vibecodingmachine-core 2025.12.25-25 → 2026.1.22-1441

package/src/health-tracking/health-reporter.js

@@ -0,0 +1,331 @@
+/**
+ * Health Reporter
+ * 
+ * Formats IDE health data for display in CLI and Electron UI.
+ * Provides summaries and recommendations based on health metrics.
+ */
+
+/**
+ * Formats IDE health data for different display contexts
+ */
+class HealthReporter {
+  /**
+   * Create health reporter
+   */
+  constructor() {
+    this.ideNames = {
+      'cursor': 'Cursor',
+      'vscode': 'VS Code',
+      'windsurf': 'Windsurf',
+      'cline': 'Cline',
+      'github-copilot': 'GitHub Copilot',
+      'amazon-q': 'Amazon Q',
+      'replit': 'Replit',
+      'antigravity': 'Antigravity',
+      'kiro': 'Kiro'
+    };
+
+    this.ideIcons = {
+      'cursor': '🖥️',
+      'vscode': '💻',
+      'windsurf': '🌊',
+      'cline': '🤖',
+      'github-copilot': '🐙',
+      'amazon-q': '🔷',
+      'replit': '🔧',
+      'antigravity': '🚀',
+      'kiro': '⚡'
+    };
+  }
+
+  /**
+   * Format inline health counters for IDE list display
+   * @static
+   * @param {Object} metrics - Health metrics for a single IDE
+   * @returns {string} Formatted as "+N -M", "+N", or "-M" (hides zeros)
+   */
+  static formatInlineCounters(metrics) {
+    if (!metrics || (!metrics.successCount && !metrics.failureCount)) {
+      return '';
+    }
+
+    const successCount = metrics.successCount || 0;
+    const failureCount = metrics.failureCount || 0;
+
+    const parts = [];
+    if (successCount > 0) parts.push(`+${successCount}`);
+    if (failureCount > 0) parts.push(`-${failureCount}`);
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Format health metrics for CLI display
+   * @param {Object} metrics - IDE health metrics (ideId -> metrics)
+   * @param {Date} [now] - Reference time for relative timestamps
+   * @returns {string} Formatted string for CLI output
+   */
+  formatForCLI(metrics, now = new Date()) {
+    if (!metrics || Object.keys(metrics).length === 0) {
+      return 'No IDE health data available';
+    }
+
+    let output = '\n📊 IDE Health Metrics\n';
+    output += '─'.repeat(50) + '\n\n';
+
+    for (const [ideId, ideMetrics] of Object.entries(metrics)) {
+      const ideName = this.ideNames[ideId] || ideId;
+      const icon = this.ideIcons[ideId] || '🔧';
+      
+      output += `${icon}  ${ideName}\n`;
+      output += `  Success Rate: ${this._formatSuccessRate(ideMetrics.successRate)}\n`;
+      output += `  Interactions: ${ideMetrics.totalInteractions || 0}\n`;
+      output += `  Avg Response: ${this.formatResponseTime(ideMetrics.averageResponseTime)}\n`;
+      output += `  Health: ${this._formatHealthStatus(ideMetrics)}\n`;
+      
+      if (ideMetrics.lastSuccess) {
+        output += `  Last Success: ${this.formatTimestamp(ideMetrics.lastSuccess, now)}\n`;
+      }
+      
+      if (ideMetrics.lastFailure) {
+        output += `  Last Failure: ${this.formatTimestamp(ideMetrics.lastFailure, now)}\n`;
+      }
+      
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Format health metrics for Electron UI
+   * @param {Object} metrics - IDE health metrics (ideId -> metrics)
+   * @param {Date} [now] - Reference time for relative timestamps
+   * @returns {Object} Formatted data for Electron UI
+   */
+  formatForElectron(metrics, now = new Date()) {
+    const formatted = {};
+
+    for (const [ideId, ideMetrics] of Object.entries(metrics)) {
+      const ideName = this.ideNames[ideId] || ideId;
+      const icon = this.ideIcons[ideId] || '🔧';
+      
+      formatted[ideId] = {
+        id: ideId,
+        name: ideName,
+        icon,
+        successCount: ideMetrics.successCount || 0,
+        failureCount: ideMetrics.failureCount || 0,
+        successRate: this._formatSuccessRate(ideMetrics.successRate),
+        averageResponseTime: this.formatResponseTime(ideMetrics.averageResponseTime),
+        currentTimeout: this.formatResponseTime(ideMetrics.currentTimeout),
+        status: this.getHealthStatus(ideMetrics),
+        lastSuccess: this.formatTimestamp(ideMetrics.lastSuccess, now),
+        lastFailure: this.formatTimestamp(ideMetrics.lastFailure, now),
+        totalInteractions: ideMetrics.totalInteractions || 0,
+        recentInteractions: this._formatRecentInteractions(ideMetrics.recentInteractions || [])
+      };
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Generate overall health summary
+   * @param {Object} metrics - IDE health metrics (ideId -> metrics)
+   * @returns {Object} Summary statistics
+   */
+  generateSummary(metrics) {
+    if (!metrics || Object.keys(metrics).length === 0) {
+      return {
+        totalIDEs: 0,
+        healthyIDEs: 0,
+        problematicIDEs: 0,
+        totalInteractions: 0,
+        overallSuccessRate: 0,
+        averageResponseTime: 0,
+        recommendedIDE: null
+      };
+    }
+
+    const ideEntries = Object.entries(metrics);
+    const totalIDEs = ideEntries.length;
+    let healthyIDEs = 0;
+    let problematicIDEs = 0;
+    let totalInteractions = 0;
+    let totalSuccesses = 0;
+    let totalFailures = 0;
+    let weightedResponseTime = 0;
+    let totalResponseTimeWeight = 0;
+
+    // Find recommended IDE
+    let recommendedIDE = null;
+    let bestSuccessRate = 0;
+    let minInteractionsForRecommendation = 10;
+
+    for (const [ideId, ideMetrics] of ideEntries) {
+      const status = this.getHealthStatus(ideMetrics);
+      
+      if (status === 'healthy') {
+        healthyIDEs++;
+      } else if (status === 'warning' || status === 'critical') {
+        problematicIDEs++;
+      }
+
+      totalInteractions += ideMetrics.totalInteractions || 0;
+      totalSuccesses += ideMetrics.successCount || 0;
+      totalFailures += ideMetrics.failureCount || 0;
+
+      // Calculate weighted average response time
+      if (ideMetrics.averageResponseTime > 0 && (ideMetrics.totalInteractions || 0) > 0) {
+        weightedResponseTime += ideMetrics.averageResponseTime * (ideMetrics.totalInteractions || 0);
+        totalResponseTimeWeight += (ideMetrics.totalInteractions || 0);
+      }
+
+      // Find recommended IDE (highest success rate with sufficient data)
+      if ((ideMetrics.totalInteractions || 0) >= minInteractionsForRecommendation) {
+        if (ideMetrics.successRate > bestSuccessRate) {
+          bestSuccessRate = ideMetrics.successRate;
+          recommendedIDE = ideId;
+        }
+      }
+    }
+
+    const overallSuccessRate = totalSuccesses + totalFailures > 0 
+      ? totalSuccesses / (totalSuccesses + totalFailures) 
+      : 0;
+
+    const averageResponseTime = totalResponseTimeWeight > 0 
+      ? weightedResponseTime / totalResponseTimeWeight 
+      : 0;
+
+    return {
+      totalIDEs,
+      healthyIDEs,
+      problematicIDEs,
+      totalInteractions,
+      overallSuccessRate: this._formatSuccessRate(overallSuccessRate),
+      averageResponseTime,
+      recommendedIDE
+    };
+  }
+
+  /**
+   * Format response time in human-readable format
+   * @param {number|null} responseTime - Response time in milliseconds
+   * @returns {string} Formatted response time
+   */
+  formatResponseTime(responseTime) {
+    if (responseTime === null || responseTime === undefined || responseTime === 0) {
+      return responseTime === 0 ? '0ms' : 'N/A';
+    }
+
+    if (responseTime < 1000) {
+      return `${Math.round(responseTime)}ms`;
+    } else if (responseTime < 60000) {
+      return `${(responseTime / 1000).toFixed(1)}s`;
+    } else if (responseTime < 3600000) {
+      return `${(responseTime / 60000).toFixed(1)}m`;
+    } else {
+      return `${(responseTime / 3600000).toFixed(1)}h`;
+    }
+  }
+
+  /**
+   * Format timestamp relative to now
+   * @param {string|null} timestamp - ISO timestamp
+   * @param {Date} [now] - Reference time
+   * @returns {string} Relative time (e.g., "5m ago", "2h ago")
+   */
+  formatTimestamp(timestamp, now = new Date()) {
+    if (!timestamp) {
+      return 'Never';
+    }
+
+    const then = new Date(timestamp);
+    const diff = now - then; // Difference in milliseconds
+
+    if (diff < 60000) { // Less than 1 minute
+      return 'just now';
+    } else if (diff < 3600000) { // Less than 1 hour
+      return `${Math.floor(diff / 60000)}m ago`;
+    } else if (diff < 86400000) { // Less than 1 day
+      return `${Math.floor(diff / 3600000)}h ago`;
+    } else {
+      return `${Math.floor(diff / 86400000)}d ago`;
+    }
+  }
+
+  /**
+   * Get health status for an IDE
+   * @param {Object} metrics - IDE health metrics
+   * @returns {string} Health status ('healthy', 'warning', 'critical', 'no-data')
+   */
+  getHealthStatus(metrics) {
+    if (!metrics.totalInteractions || metrics.totalInteractions === 0) {
+      return 'no-data';
+    }
+
+    if (metrics.consecutiveFailures === 0) {
+      return 'healthy';
+    } else if (metrics.consecutiveFailures <= 3) {
+      return 'warning';
+    } else {
+      return 'critical';
+    }
+  }
+
+  /**
+   * Format success rate as percentage
+   * @private
+   * @param {number} successRate - Success rate (0-1)
+   * @returns {string} Formatted percentage
+   */
+  _formatSuccessRate(successRate) {
+    if (successRate === null || successRate === undefined || successRate === 0) {
+      return '0%';
+    }
+    return `${(successRate * 100).toFixed(1)}%`;
+  }
+
+  /**
+   * Format health status with emoji
+   * @private
+   * @param {Object} metrics - IDE health metrics
+   * @returns {string} Formatted status with emoji
+   */
+  _formatHealthStatus(metrics) {
+    const status = this.getHealthStatus(metrics);
+    
+    switch (status) {
+      case 'healthy':
+        return '✅ Healthy';
+      case 'warning':
+        return `⚠️  ${metrics.consecutiveFailures} consecutive failures`;
+      case 'critical':
+        return `🚨 ${metrics.consecutiveFailures} consecutive failures`;
+      case 'no-data':
+        return '📊 No data';
+      default:
+        return '❓ Unknown';
+    }
+  }
+
+  /**
+   * Format recent interactions for display
+   * @private
+   * @param {Array} interactions - Recent interaction array
+   * @returns {Array} Formatted interactions
+   */
+  _formatRecentInteractions(interactions) {
+    return interactions.slice(-5).map(interaction => ({
+      timestamp: interaction.timestamp,
+      outcome: interaction.outcome,
+      displayTime: this.formatResponseTime(interaction.responseTime),
+      requirementId: interaction.requirementId,
+      errorMessage: interaction.errorMessage
+    }));
+  }
+}
+
+module.exports = { HealthReporter };