git-repo-analyzer-test 1.0.0

package/src/report/generator.js

@@ -0,0 +1,459 @@
+import { table } from 'table';
+import chalk from 'chalk';
+
+export class ReportGenerator {
+  /**
+   * Generate comprehensive analysis report
+   */
+  static generateReport(repoName, analysis) {
+    const summary = this.generateSummary(analysis);
+    const report = {
+      timestamp: new Date().toISOString(),
+      repository: repoName,
+      summary,
+      /** Project overall: single score (0–10), rating (A+–F), and 0–100 scale for display */
+      overall: {
+        score: summary.overallScore,
+        score100: summary.overallScore100,
+        rating: summary.overallRating,
+      },
+      detailed: analysis,
+    };
+
+    return report;
+  }
+
+  /**
+   * Generate text-based report for console output
+   */
+  static generateTextReport(repoName, analysis) {
+    let output = '';
+
+    output += chalk.bold.cyan(`\n📊 GitHub Repository Analysis Report\n`);
+    output += chalk.gray(`Repository: ${repoName}\n`);
+    output += chalk.gray(`Generated: ${new Date().toLocaleString()}\n`);
+
+    // Overall Score
+    output += this.generateOverallScore(analysis);
+
+    // Quality Section (skip if Sonar-only run)
+    if (analysis.quality) output += this.generateQualitySection(analysis.quality);
+
+    // Security Section (skip if Sonar-only run)
+    if (analysis.security) output += this.generateSecuritySection(analysis.security);
+
+    // SonarCloud Section (always in final report)
+    if (analysis.sonarCloud) {
+      output += this.generateSonarCloudSection(analysis.sonarCloud);
+    } else {
+      output += chalk.bold.cyan(`\n📊 SonarCloud Code Quality\n`);
+      output += chalk.gray('Unavailable. Add SONAR_TOKEN and analyze a repo that exists on SonarCloud to include in the report.\n');
+    }
+
+    // Code Review Section (skip if Sonar-only run)
+    if (analysis.codeReview) output += this.generateCodeReviewSection(analysis.codeReview);
+
+    // Performance Section (skip if Sonar-only run)
+    if (analysis.performance) output += this.generatePerformanceSection(analysis.performance);
+
+    // Summary & Recommendations
+    output += this.generateSummarySection(analysis);
+
+    return output;
+  }
+
+  /**
+   * Generate overall score visualization (includes SonarCloud when available).
+   * Supports Sonar-only runs when quality, security, codeReview, performance are undefined.
+   */
+  static generateOverallScore(analysis) {
+    const scores = [];
+    if (analysis.quality?.score != null) scores.push(analysis.quality.score);
+    if (analysis.security?.score != null) scores.push(analysis.security.score);
+    if (analysis.codeReview?.score != null) scores.push(analysis.codeReview.score);
+    if (analysis.performance?.score != null) scores.push(analysis.performance.score);
+    if (analysis.sonarCloud?.available && analysis.sonarCloud.score != null) {
+      scores.push(analysis.sonarCloud.score);
+    }
+    if (scores.length === 0) {
+      return chalk.bold.yellow('\n🎯 Project Overall: Not available (no scores from any analyzer)\n');
+    }
+    const overallScore10 = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const overallScore = Math.round(overallScore10);
+    const overallRating = this.getRating(overallScore);
+
+    let output = chalk.bold.yellow(`\n🎯 Project Overall: ${overallScore}/10 (${overallRating})\n`);
+    output += this.getScoreBar(Math.round(overallScore10 * 10)) + '\n';
+
+    return output;
+  }
+
+  /**
+   * Generate quality analysis section
+   */
+  static generateQualitySection(quality) {
+    let output = chalk.bold.cyan(`\n⭐ Code Quality Analysis\n`);
+    output += `Score: ${chalk.green(quality.score + '/10')} - Rating: ${chalk.bold(quality.rating)}\n\n`;
+
+    if (quality.issues && quality.issues.length > 0) {
+      output += chalk.bold(`Found ${quality.issues.length} Issue(s):\n`);
+      const issuesData = [['Severity', 'Type', 'Location', 'Recommendation']];
+      
+      quality.issues.forEach((issue) => {
+        issuesData.push([
+          issue.severity,
+          issue.type,
+          issue.location,
+          issue.recommendation.substring(0, 50) + '...',
+        ]);
+      });
+      
+      output += table(issuesData) + '\n';
+    }
+
+    if (quality.recommendations && quality.recommendations.length > 0) {
+      output += chalk.bold(`Recommendations:\n`);
+      quality.recommendations.forEach((rec, idx) => {
+        output += `${idx + 1}. ${rec.action}\n`;
+      });
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate security section
+   */
+  static generateSecuritySection(security) {
+    let output = chalk.bold.red(`\n🔒 Security & Vulnerabilities Analysis\n`);
+    output += `Score: ${chalk.green(security.score + '/10')} - Rating: ${chalk.bold(security.rating)}\n`;
+    output += `Risk Level: ${this.getRiskLevelColor(security.riskLevel)(security.riskLevel)}\n\n`;
+
+    if (security.owasp10Vulnerabilities && security.owasp10Vulnerabilities.length > 0) {
+      output += chalk.bold(`OWASP Top 10 Findings (${security.owasp10Vulnerabilities.length}):\n`);
+      
+      security.owasp10Vulnerabilities.forEach((vuln) => {
+        output += chalk.bold(`\n${vuln.rank}: ${vuln.title}\n`);
+        output += `Severity: ${this.getSeverityColor(vuln.severity)(vuln.severity)}\n`;
+        output += `Location: ${vuln.location}\n`;
+        output += `Description: ${vuln.description}\n`;
+        
+        if (vuln.remediation && vuln.remediation.length > 0) {
+          output += chalk.yellow(`Remediation:\n`);
+          vuln.remediation.forEach((step, idx) => {
+            output += `  ${idx + 1}. ${step}\n`;
+          });
+        }
+      });
+      output += '\n';
+    }
+
+    if (security.recommendations && security.recommendations.length > 0) {
+      output += chalk.bold(`Recommendations:\n`);
+      security.recommendations.forEach((rec, idx) => {
+        output += `${idx + 1}. [${rec.priority}] ${rec.title}: ${rec.action}\n`;
+      });
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate code review section
+   */
+  static generateCodeReviewSection(codeReview) {
+    let output = chalk.bold.cyan(`\n👥 Code Review & Collaboration Analysis\n`);
+    output += `Score: ${chalk.green(codeReview.score + '/10')} - Rating: ${chalk.bold(codeReview.rating)}\n\n`;
+
+    const metricsData = [
+      ['Metric', 'Value'],
+      ['Total PRs', codeReview.reviewMetrics.totalPullRequests.toString()],
+      ['Merged PRs', codeReview.reviewMetrics.mergedPullRequests.toString()],
+      ['Open PRs', codeReview.reviewMetrics.openPullRequests.toString()],
+      ['Closure Rate', codeReview.reviewMetrics.prClosureRate + '%'],
+      ['Avg Review Time', codeReview.reviewMetrics.averageReviewTimeHours + ' hours'],
+      ['Contributors', codeReview.collaborationMetrics.contributors.toString()],
+    ];
+
+    output += table(metricsData) + '\n';
+
+    if (codeReview.codingStyle && codeReview.codingStyle.commitConventionAdherence) {
+      const adherence = codeReview.codingStyle.commitConventionAdherence;
+      output += chalk.bold(`Commit Convention Adherence:\n`);
+      output += `${adherence.percentage}% follow conventional format (${adherence.conventional}/${adherence.total})\n`;
+      output += `Status: ${adherence.status}\n\n`;
+    }
+
+    if (codeReview.recommendations && codeReview.recommendations.length > 0) {
+      output += chalk.bold(`Recommendations:\n`);
+      codeReview.recommendations.forEach((rec, idx) => {
+        output += `${idx + 1}. [${rec.priority}] ${rec.category}: ${rec.action}\n`;
+      });
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate performance section
+   */
+  static generatePerformanceSection(performance) {
+    let output = chalk.bold.cyan(`\n⚡ Performance & Release Velocity\n`);
+    output += `Score: ${chalk.green(performance.score + '/10')} - Rating: ${chalk.bold(performance.rating)}\n\n`;
+
+    const metricsData = [
+      ['Metric', 'Value'],
+      ['Total Releases', performance.releaseVelocity.totalReleases.toString()],
+      ['Releases/Year', performance.releaseVelocity.averageReleasesPerYear.toString()],
+      ['Release Cadence', performance.releaseVelocity.releaseCadence],
+      ['Days Since Last Release', performance.releaseVelocity.daysSinceLastRelease?.toString() || 'N/A'],
+      ['Total Commits', performance.developmentVelocity.totalCommits.toString()],
+      ['Maintenance Level', performance.maintenancePattern.maintenanceLevel],
+    ];
+
+    output += table(metricsData) + '\n';
+
+    if (performance.maintenancePattern) {
+      output += chalk.bold(`Maintenance Status:\n`);
+      output += `Level: ${performance.maintenancePattern.maintenanceLevel}\n`;
+      output += `Last Update: ${performance.maintenancePattern.lastUpdateIndicator}\n`;
+      output += `Status: ${performance.maintenancePattern.status}\n\n`;
+    }
+
+    if (performance.recommendations && performance.recommendations.length > 0) {
+      output += chalk.bold(`Recommendations:\n`);
+      performance.recommendations.forEach((rec, idx) => {
+        output += `${idx + 1}. [${rec.priority}] ${rec.category}: ${rec.action}\n`;
+      });
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate summary section. Supports Sonar-only runs (undefined quality/security/codeReview/performance).
+   */
+  static generateSummarySection(analysis) {
+    let output = chalk.bold.cyan(`\n📋 Summary\n`);
+
+    const summary = this.generateSummary(analysis);
+    const summaryData = [['Category', 'Score', 'Rating', 'Status']];
+    if (analysis.quality) {
+      summaryData.push(['Code Quality', (summary.qualityScore != null ? summary.qualityScore + '/10' : 'Not available'), analysis.quality.rating || 'Not available', 'Complete']);
+    }
+    if (analysis.security) {
+      summaryData.push(['Security', (summary.securityScore != null ? summary.securityScore + '/10' : 'Not available'), analysis.security.rating || 'Not available', analysis.security.riskLevel || 'Not available']);
+    }
+    if (analysis.codeReview) {
+      summaryData.push(['Collaboration', (summary.collaborationScore != null ? summary.collaborationScore + '/10' : 'Not available'), analysis.codeReview.rating || 'Not available', 'Complete']);
+    }
+    if (analysis.performance) {
+      summaryData.push(['Performance', (summary.performanceScore != null ? summary.performanceScore + '/10' : 'Not available'), analysis.performance.rating || 'Not available', analysis.performance.maintenancePattern?.maintenanceLevel ?? 'Not available']);
+    }
+    if (analysis.sonarCloud) {
+      const sc = analysis.sonarCloud;
+      const scScore = sc.available && sc.score != null ? sc.score + '/10' : 'Not available';
+      const scRating = sc.rating || 'Not available';
+      const scStatus = sc.available ? (sc.qualityGate?.status || 'Complete') : (sc.unavailableReason || 'Not available');
+      summaryData.push(['SonarCloud', scScore, scRating, scStatus]);
+    }
+    output += table(summaryData) + '\n';
+    output += chalk.bold.green(`\n✓ Analysis Complete\n`);
+
+    return output;
+  }
+
+  /**
+   * Generate summary statistics (includes SonarCloud when available for final report).
+   * Supports Sonar-only runs when quality, security, codeReview, performance are undefined.
+   */
+  static generateSummary(analysis) {
+    const scores = [];
+    if (analysis.quality?.score != null) scores.push(analysis.quality.score);
+    if (analysis.security?.score != null) scores.push(analysis.security.score);
+    if (analysis.codeReview?.score != null) scores.push(analysis.codeReview.score);
+    if (analysis.performance?.score != null) scores.push(analysis.performance.score);
+    if (analysis.sonarCloud?.available && analysis.sonarCloud.score != null) {
+      scores.push(analysis.sonarCloud.score);
+    }
+    if (scores.length === 0) {
+      return {
+        qualityScore: null,
+        securityScore: null,
+        collaborationScore: null,
+        performanceScore: null,
+        sonarCloudScore: null,
+        overallScore: null,
+        overallRating: null,
+        overallScore100: null,
+        healthStatus: 'Unavailable',
+      };
+    }
+    const overallScore10 = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const overallScore = Math.round(overallScore10);
+    const overallRating = this.getRating(overallScore);
+    return {
+      qualityScore: analysis.quality?.score ?? null,
+      securityScore: analysis.security?.score ?? null,
+      collaborationScore: analysis.codeReview?.score ?? null,
+      performanceScore: analysis.performance?.score ?? null,
+      sonarCloudScore: analysis.sonarCloud?.available && analysis.sonarCloud.score != null ? analysis.sonarCloud.score : null,
+      overallScore,
+      overallRating,
+      overallScore100: Math.round(overallScore10 * 10),
+      healthStatus: overallScore >= 9 ? 'Excellent' : overallScore >= 7 ? 'Good' : overallScore >= 5 ? 'Fair' : 'Poor',
+    };
+  }
+
+  /**
+   * Helper: Get rating from score
+   */
+  static getRating(score) {
+    const n = Number(score);
+    if (Number.isNaN(n)) return 'Unavailable';
+    if (n >= 9) return 'A+';
+    if (n >= 8) return 'A';
+    if (n >= 7) return 'B+';
+    if (n >= 6) return 'B';
+    if (n >= 5) return 'C+';
+    if (n >= 4) return 'C';
+    return 'F';
+  }
+
+  /**
+   * Helper: Get score bar visualization
+   */
+  static getScoreBar(percentage) {
+    // Ensure percentage is in valid range
+    percentage = Math.max(0, Math.min(percentage, 100));
+    
+    const filled = Math.max(0, Math.min(Math.round(percentage / 5), 20));
+    const empty = Math.max(0, 20 - filled);
+    const bar = '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, empty));
+    
+    let color = chalk.green;
+    if (percentage < 40) color = chalk.red;
+    else if (percentage < 60) color = chalk.yellow;
+    else if (percentage < 80) color = chalk.cyan;
+
+    return color(`[${bar}] ${Math.round(percentage)}%`);
+  }
+
+  /**
+   * Helper: Get severity color
+   */
+  static getSeverityColor(severity) {
+    switch (severity) {
+      case 'CRITICAL':
+        return chalk.bgRed.white;
+      case 'HIGH':
+        return chalk.red;
+      case 'MEDIUM':
+        return chalk.yellow;
+      case 'LOW':
+        return chalk.green;
+      default:
+        return chalk.gray;
+    }
+  }
+
+  /**
+   * Helper: Get risk level color
+   */
+  static getRiskLevelColor(riskLevel) {
+    switch (riskLevel) {
+      case 'CRITICAL':
+        return chalk.bgRed.white;
+      case 'HIGH':
+        return chalk.red;
+      case 'MEDIUM':
+        return chalk.yellow;
+      case 'LOW':
+        return chalk.green;
+      default:
+        chalk.gray;
+    }
+  }
+
+  /**
+   * Generate SonarCloud code quality section.
+   * Data is our combined summary from free-plan APIs (quality gate + measures/component); no single "Overall Code" API.
+   */
+  static generateSonarCloudSection(sonarData) {
+    let output = '';
+    output += chalk.bold.cyan(`\n📊 SonarCloud Code Quality (from API: Quality Gate + metrics)\n`);
+    if (!sonarData.available) {
+      output += chalk.gray(`Unavailable. ${sonarData.unavailableReason || 'Configure SONAR_TOKEN and add project on SonarCloud.'}\n`);
+      return output;
+    }
+    const summary = sonarData.overallSummary;
+    if (summary) {
+      output += chalk.gray(`Overall: ${summary.status === 'Passed' ? chalk.green(summary.status) : summary.status === 'Failed' ? chalk.red(summary.status) : summary.status}\n`);
+    }
+    output += chalk.gray(`Score: ${sonarData.score != null ? sonarData.score + '/10' : 'Not available'} - Rating: ${sonarData.rating || 'Not available'}\n`);
+    // output += chalk.gray(`Quality Gate: ${sonarData.qualityGate?.status === 'OK' ? chalk.green('Passed') : sonarData.qualityGate?.status === 'ERROR' ? chalk.red('Failed') : 'Unknown'}\n`);
+    if (sonarData.projectKey) output += chalk.gray(`Project: ${sonarData.projectKey}\n`);
+    const m = sonarData.metrics || {};
+    const metricsData = [
+      ['Metric', 'Value'],
+      ['Lines of Code', (m.ncloc ?? m.lines ?? 0).toString()],
+      ['Bugs', (m.bugs ?? 0).toString()],
+      ['Vulnerabilities', (m.vulnerabilities ?? 0).toString()],
+      // ['Code Smells', (m.codeSmells ?? 0).toString()],
+      ['Security Hotspots', (m.securityHotspots ?? 0).toString()],
+      ['Duplication', (m.duplicatedLinesDensity != null ? m.duplicatedLinesDensity + '%' : 'N/A')],
+      ['Coverage', m.coverage != null ? m.coverage + '%' : 'N/A'],
+      ['Complexity', (m.complexity ?? 0).toString()],
+    ];
+    output += table(metricsData) + '\n';
+
+    if (sonarData.issues?.items?.length > 0) {
+      output += chalk.bold(`Issues (first 5 of ${sonarData.issues.total} total):\n`);
+      sonarData.issues.items.slice(0, 5).forEach((issue) => {
+        output += `  [${issue.severity}] ${issue.type}: ${issue.message?.substring(0, 60)}...\n`;
+      });
+      output += '\n';
+    }
+    if (sonarData.recommendations?.length > 0) {
+      output += chalk.bold(`Recommendations:\n`);
+      sonarData.recommendations.forEach((rec, idx) => {
+        output += `${idx + 1}. [${rec.priority}] ${rec.category}: ${rec.action}\n`;
+      });
+    }
+    return output;
+  }
+
+  /**
+   * Convert CVSS score to severity level
+   */
+  static cvssToSeverity(cvss) {
+    if (cvss >= 9) return 'CRITICAL';
+    if (cvss >= 7) return 'HIGH';
+    if (cvss >= 4) return 'MEDIUM';
+    return 'LOW';
+  }
+
+  /**
+   * Get color function for severity
+   */
+  static getSeverityColor(severity) {
+    switch (severity?.toUpperCase()) {
+      case 'CRITICAL':
+        return chalk.bgRed.white;
+      case 'HIGH':
+        return chalk.red;
+      case 'MEDIUM':
+        return chalk.yellow;
+      case 'LOW':
+        return chalk.green;
+      default:
+        return chalk.gray;
+    }
+  }
+}
+
+export default ReportGenerator;