git-repo-analyzer-test 1.0.0

package/src/analyzers/performance-enhanced.js

@@ -0,0 +1,747 @@
+/**
+ * Enhanced Performance & Release Velocity Analyzer
+ * Analyzes release frequency, development velocity, and performance patterns
+ */
+export class PerformanceAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Comprehensive performance and release analysis
+   */
+  async analyzePerformance(owner, repo, repoData) {
+    try {
+      const [releases, commits, codeFrequency] = await Promise.all([
+        this.client.getReleases(owner, repo),
+        this.client.getCommits(owner, repo, { perPage: 100 }),
+        this.client.getCodeFrequency(owner, repo).catch(() => ({})),
+      ]);
+
+      const releaseVelocity = this.analyzeReleaseVelocity(releases);
+      const developmentVelocity = this.calculateDevelopmentVelocity(codeFrequency, commits);
+      const releaseQuality = this.assessReleaseQuality(releases, commits);
+      const maintenancePattern = this.analyzeMaintenancePattern(
+        commits,
+        releases,
+        repoData
+      );
+
+      const score = this.calculatePerformanceScore(
+        releaseVelocity,
+        developmentVelocity,
+        releaseQuality,
+        maintenancePattern
+      );
+      const rating = this.getRating(score);
+
+      return {
+        score,
+        rating,
+        releaseVelocity,
+        developmentVelocity,
+        releaseQuality,
+        maintenancePattern,
+        performanceMetrics: {
+          totalReleases: releases.length,
+          averageReleaseCycle: this.calculateAverageReleaseCycle(releases),
+          timeToFirstRelease: this.calculateTimeToFirstRelease(releases),
+          developmentActivityTrend: this.analyzeDevelopmentTrend(commits),
+          updateFrequency: this.assessUpdateFrequency(commits),
+        },
+        recommendations: this.generatePerformanceRecommendations(
+          releaseVelocity,
+          developmentVelocity,
+          maintenancePattern
+        ),
+        details: {
+          releasePatterns: this.analyzeReleasePatterns(releases),
+          commitPatterns: this.analyzeCommitPatterns(commits),
+          developmentHealth: this.assessDevelopmentHealth(commits, releases),
+          releaseCadence: this.analyzeReleaseCadence(releases),
+        },
+      };
+    } catch (error) {
+      throw new Error(`Performance analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Analyze release velocity
+   */
+  analyzeReleaseVelocity(releases) {
+    if (releases.length === 0) {
+      return {
+        totalReleases: 0,
+        preReleases: 0,
+        stableReleases: 0,
+        averageReleasesPerYear: 0,
+        averageReleasesPerMonth: 0,
+        releaseCadence: 'None - No releases yet',
+        velocity: 'STAGNANT',
+        status: 'NO_RELEASES',
+        recommendations: [
+          'Create initial release version',
+          'Establish release schedule',
+          'Use semantic versioning (semver)',
+          'Document release process',
+          'Consider beta/pre-release versions',
+        ],
+      };
+    }
+
+    const stableReleases = releases.filter((r) => !r.prerelease).length;
+    const preReleases = releases.filter((r) => r.prerelease).length;
+    const sortedReleases = releases.sort(
+      (a, b) => new Date(b.published_at) - new Date(a.published_at)
+    );
+
+    let releaseSpanDays = 0;
+    if (sortedReleases.length > 1) {
+      releaseSpanDays =
+        (new Date(sortedReleases[0].published_at) -
+          new Date(sortedReleases[sortedReleases.length - 1].published_at)) /
+        (1000 * 60 * 60 * 24);
+    }
+
+    const yearsActive = Math.max(releaseSpanDays / 365, 1);
+    const releasesPerYear = Math.round((releases.length / yearsActive) * 10) / 10;
+    const releasesPerMonth = Math.round((releasesPerYear / 12) * 10) / 10;
+
+    return {
+      totalReleases: releases.length,
+      stableReleases,
+      preReleases,
+      averageReleasesPerYear: releasesPerYear,
+      averageReleasesPerMonth: releasesPerMonth,
+      releaseCadence: this.determineReleaseCadence(releasesPerYear),
+      velocity: this.assessReleaseVelocity(releasesPerYear),
+      daysSinceLastRelease: this.calculateDaysSinceLastRelease(sortedReleases[0]),
+      status: this.assessReleaseStatus(sortedReleases[0]),
+      recommendations: [
+        'Maintain consistent release schedule',
+        'Use semantic versioning strictly',
+        'Automate release processes',
+        'Include release notes and changelogs',
+        'Tag releases in version control',
+      ],
+    };
+  }
+
+  /**
+   * Calculate development velocity
+   */
+  calculateDevelopmentVelocity(codeFrequency, commits) {
+    let additions = 0;
+    let deletions = 0;
+
+    // Handle codeFrequency - it's an array of [timestamp, additions, deletions]
+    if (Array.isArray(codeFrequency)) {
+      codeFrequency.forEach((item) => {
+        if (Array.isArray(item) && item.length === 3) {
+          additions += item[1] || 0;
+          deletions += item[2] || 0;
+        }
+      });
+    }
+
+    const netChanges = additions - Math.abs(deletions);
+    const commitCount = commits.length;
+    const avgLinesPerCommit = commitCount > 0 ? Math.round(netChanges / commitCount) : 0;
+
+    const recentCommits = commits.slice(0, 10);
+    let recentActivity = 0;
+    if (recentCommits.length > 0) {
+      const oldestRecent = new Date(recentCommits[recentCommits.length - 1].commit.author.date);
+      const newestRecent = new Date(recentCommits[0].commit.author.date);
+      const daysSinceLastCommit = (Date.now() - newestRecent) / (1000 * 60 * 60 * 24);
+      recentActivity = Math.max(0, Math.round((30 - daysSinceLastCommit) / 3) * 10);
+    }
+
+    return {
+      totalAdditions: additions,
+      totalDeletions: Math.abs(deletions),
+      netChanges,
+      totalCommits: commitCount,
+      averageLinesPerCommit: avgLinesPerCommit,
+      velocity: this.assessVelocityTrend(commits),
+      recentActivity,
+      activityLevel: this.assessActivityLevel(recentActivity, commitCount),
+      codeStability: this.assessCodeStability(additions, deletions),
+      recommendations: [
+        'Maintain steady development pace',
+        'Monitor code churn (high deletions)',
+        'Balance feature development with refactoring',
+        'Keep commits focused and atomic',
+        'Review large changes carefully',
+      ],
+    };
+  }
+
+  /**
+   * Assess release quality
+   */
+  assessReleaseQuality(releases, commits) {
+    const recentReleases = releases.slice(0, 5);
+    const avgAssetsPerRelease = Math.round(
+      recentReleases.reduce((sum, r) => sum + (r.assets?.length || 0), 0) /
+        (recentReleases.length || 1)
+    );
+
+    const releasesWithNotes = recentReleases.filter((r) => r.body && r.body.length > 50).length;
+    const notesQuality =
+      recentReleases.length > 0
+        ? Math.round((releasesWithNotes / recentReleases.length) * 100)
+        : 0;
+
+    return {
+      recentReleasesAnalyzed: recentReleases.length,
+      averageAssetsPerRelease: avgAssetsPerRelease,
+      releasesWithDocumentation: releasesWithNotes,
+      documentationPercentage: notesQuality,
+      documentationQuality:
+        notesQuality >= 80
+          ? 'EXCELLENT'
+          : notesQuality >= 60
+            ? 'GOOD'
+            : notesQuality >= 40
+              ? 'FAIR'
+              : 'NEEDS_IMPROVEMENT',
+      changelogPresence: this.hasChangelog(commits),
+      releaseAutomation: this.detectReleaseAutomation(releases),
+      recommendations: [
+        'Include comprehensive release notes',
+        'Document breaking changes clearly',
+        'Provide downloadable assets',
+        'Tag commits with version numbers',
+        'Consider automated release pipelines',
+      ],
+    };
+  }
+
+  /**
+   * Analyze maintenance pattern
+   */
+  analyzeMaintenancePattern(commits, releases, repoData) {
+    const allCommits = commits;
+    const sortedCommits = allCommits
+      .map((c) => new Date(c.commit.author.date))
+      .sort((a, b) => b - a);
+
+    const daysSinceLastCommit =
+      sortedCommits.length > 0 ? (Date.now() - sortedCommits[0]) / (1000 * 60 * 60 * 24) : Infinity;
+
+    const maintenanceLevel =
+      daysSinceLastCommit < 30
+        ? 'ACTIVE'
+        : daysSinceLastCommit < 90
+          ? 'MODERATE'
+          : daysSinceLastCommit < 180
+            ? 'DORMANT'
+            : 'INACTIVE';
+
+    return {
+      daysSinceLastCommit: Math.round(daysSinceLastCommit),
+      maintenanceLevel,
+      status: this.describeMaintenance(maintenanceLevel),
+      projectedMaintenanceHealth: this.projectMaintenanceHealth(
+        maintenanceLevel,
+        daysSinceLastCommit
+      ),
+      lastUpdateIndicator: this.formatTimeAgo(daysSinceLastCommit),
+      updateFrequency: this.analyzeUpdateFrequency(commits),
+      sustainability: this.assessSustainability(commits, releases, repoData),
+      recommendations: [
+        maintenanceLevel === 'ACTIVE' ? 'Keep up regular maintenance' : 'Increase maintenance effort',
+        'Respond to community issues promptly',
+        'Update dependencies regularly',
+        'Address security vulnerabilities quickly',
+        maintenanceLevel !== 'ACTIVE' ? 'Consider automation to reduce overhead' : 'Maintain current schedule',
+      ],
+    };
+  }
+
+  /**
+   * Calculate performance score
+   */
+  calculatePerformanceScore(releaseVelocity, developmentVelocity, releaseQuality, maintenancePattern) {
+    let score = 50; // Base score
+
+    // Release velocity (0-20 points)
+    const releasesPerYear = releaseVelocity.averageReleasesPerYear;
+    if (releasesPerYear >= 12) {
+      score += 20;
+    } else if (releasesPerYear >= 6) {
+      score += 15;
+    } else if (releasesPerYear >= 2) {
+      score += 10;
+    } else if (releasesPerYear > 0) {
+      score += 5;
+    }
+
+    // Development velocity (0-20 points)
+    if (developmentVelocity.commitCount > 1000) {
+      score += 20;
+    } else if (developmentVelocity.commitCount > 500) {
+      score += 15;
+    } else if (developmentVelocity.commitCount > 100) {
+      score += 10;
+    } else if (developmentVelocity.commitCount > 10) {
+      score += 5;
+    }
+
+    // Release quality (0-15 points)
+    if (releaseQuality.documentationPercentage >= 80) {
+      score += 15;
+    } else if (releaseQuality.documentationPercentage >= 60) {
+      score += 12;
+    } else if (releaseQuality.documentationPercentage >= 40) {
+      score += 8;
+    } else if (releaseQuality.documentationPercentage > 0) {
+      score += 4;
+    }
+
+    // Maintenance pattern (0-15 points)
+    if (maintenancePattern.maintenanceLevel === 'ACTIVE') {
+      score += 15;
+    } else if (maintenancePattern.maintenanceLevel === 'MODERATE') {
+      score += 10;
+    } else if (maintenancePattern.maintenanceLevel === 'DORMANT') {
+      score += 5;
+    }
+
+    // Recency bonus (0-10 points)
+    if (maintenancePattern.daysSinceLastCommit < 7) {
+      score += 10;
+    } else if (maintenancePattern.daysSinceLastCommit < 30) {
+      score += 8;
+    } else if (maintenancePattern.daysSinceLastCommit < 90) {
+      score += 5;
+    } else if (maintenancePattern.daysSinceLastCommit < 180) {
+      score += 2;
+    }
+
+    return Math.min(score, 100);
+  }
+
+  /**
+   * Helper: Determine release cadence
+   */
+  determineReleaseCadence(releasesPerYear) {
+    if (releasesPerYear >= 12) return 'Monthly or more frequent';
+    if (releasesPerYear >= 6) return 'Bi-monthly';
+    if (releasesPerYear >= 4) return 'Quarterly';
+    if (releasesPerYear >= 2) return 'Semi-annual';
+    if (releasesPerYear >= 1) return 'Annual';
+    return 'Irregular';
+  }
+
+  /**
+   * Helper: Assess release velocity
+   */
+  assessReleaseVelocity(releasesPerYear) {
+    if (releasesPerYear >= 12) return 'EXCELLENT';
+    if (releasesPerYear >= 6) return 'GOOD';
+    if (releasesPerYear >= 2) return 'FAIR';
+    if (releasesPerYear > 0) return 'SLOW';
+    return 'STAGNANT';
+  }
+
+  /**
+   * Helper: Calculate days since last release
+   */
+  calculateDaysSinceLastRelease(lastRelease) {
+    if (!lastRelease) return null;
+    return Math.round((Date.now() - new Date(lastRelease.published_at)) / (1000 * 60 * 60 * 24));
+  }
+
+  /**
+   * Helper: Assess release status
+   */
+  assessReleaseStatus(lastRelease) {
+    if (!lastRelease) return 'NO_RELEASES';
+    const daysSince = this.calculateDaysSinceLastRelease(lastRelease);
+    if (daysSince < 30) return 'RECENT';
+    if (daysSince < 90) return 'CURRENT';
+    if (daysSince < 180) return 'AGING';
+    return 'STALE';
+  }
+
+  /**
+   * Helper: Assess velocity trend
+   */
+  assessVelocityTrend(commits) {
+    const recentCommits = commits.slice(0, 50);
+    const olderCommits = commits.slice(50, 100);
+
+    const recentRate = recentCommits.length / Math.max(1, recentCommits.length);
+    const olderRate = olderCommits.length / Math.max(1, olderCommits.length);
+
+    if (recentRate > olderRate * 1.2) return 'ACCELERATING';
+    if (recentRate < olderRate * 0.8) return 'DECELERATING';
+    return 'STABLE';
+  }
+
+  /**
+   * Helper: Assess activity level
+   */
+  assessActivityLevel(recentActivity, totalCommits) {
+    if (recentActivity > 70 || totalCommits > 1000) return 'VERY_HIGH';
+    if (recentActivity > 50 || totalCommits > 500) return 'HIGH';
+    if (recentActivity > 30 || totalCommits > 100) return 'MODERATE';
+    if (recentActivity > 10 || totalCommits > 20) return 'LOW';
+    return 'MINIMAL';
+  }
+
+  /**
+   * Helper: Assess code stability
+   */
+  assessCodeStability(additions, deletions) {
+    if (additions === 0) return 'UNKNOWN';
+    const ratio = Math.abs(deletions) / additions;
+    if (ratio > 0.5) return 'UNSTABLE';
+    if (ratio > 0.3) return 'MODERATE';
+    return 'STABLE';
+  }
+
+  /**
+   * Helper: Calculate average release cycle
+   */
+  calculateAverageReleaseCycle(releases) {
+    if (releases.length < 2) return null;
+
+    const sortedReleases = releases
+      .sort((a, b) => new Date(b.published_at) - new Date(a.published_at))
+      .slice(0, 10);
+
+    let totalDays = 0;
+    for (let i = 0; i < sortedReleases.length - 1; i++) {
+      const timeDiff = new Date(sortedReleases[i].published_at) -
+        new Date(sortedReleases[i + 1].published_at);
+      totalDays += timeDiff / (1000 * 60 * 60 * 24);
+    }
+
+    return Math.round(totalDays / (sortedReleases.length - 1));
+  }
+
+  /**
+   * Helper: Calculate time to first release
+   */
+  calculateTimeToFirstRelease(releases) {
+    if (releases.length === 0) return null;
+    const firstRelease = releases[releases.length - 1];
+    return Math.round(
+      (Date.now() - new Date(firstRelease.published_at)) / (1000 * 60 * 60 * 24)
+    );
+  }
+
+  /**
+   * Helper: Analyze development trend
+   */
+  analyzeDevelopmentTrend(commits) {
+    const sortedCommits = commits
+      .map((c) => new Date(c.commit.author.date))
+      .sort((a, b) => b - a);
+
+    if (sortedCommits.length === 0) return 'UNKNOWN';
+
+    const recentDate = sortedCommits[0];
+    const fourWeeksAgo = new Date(recentDate - 28 * 24 * 60 * 60 * 1000);
+    const recentCommitCount = sortedCommits.filter((d) => d > fourWeeksAgo).length;
+
+    if (recentCommitCount > 10) return 'UPWARD';
+    if (recentCommitCount > 3) return 'STABLE';
+    if (recentCommitCount > 0) return 'DECLINING';
+    return 'STAGNANT';
+  }
+
+  /**
+   * Helper: Assess update frequency
+   */
+  assessUpdateFrequency(commits) {
+    if (commits.length === 0) return 'NEVER';
+    if (commits.length > 1000) return 'VERY_FREQUENT';
+    if (commits.length > 500) return 'FREQUENT';
+    if (commits.length > 100) return 'REGULAR';
+    if (commits.length > 20) return 'OCCASIONAL';
+    return 'RARE';
+  }
+
+  /**
+   * Helper: Analyze release patterns
+   */
+  analyzeReleasePatterns(releases) {
+    return {
+      totalReleases: releases.length,
+      preReleases: releases.filter((r) => r.prerelease).length,
+      drafts: releases.filter((r) => r.draft).length,
+      tags: releases.map((r) => r.tag_name),
+      recentReleases: releases.slice(0, 5).map((r) => ({
+        tag: r.tag_name,
+        date: r.published_at,
+        prerelease: r.prerelease,
+      })),
+    };
+  }
+
+  /**
+   * Helper: Analyze commit patterns
+   */
+  analyzeCommitPatterns(commits) {
+    const commitsByDay = {};
+    commits.forEach((c) => {
+      const date = new Date(c.commit.author.date).toISOString().split('T')[0];
+      commitsByDay[date] = (commitsByDay[date] || 0) + 1;
+    });
+
+    const avgCommitsPerDay = Object.keys(commitsByDay).length > 0
+      ? Math.round(commits.length / Object.keys(commitsByDay).length)
+      : 0;
+
+    return {
+      totalCommits: commits.length,
+      uniqueDays: Object.keys(commitsByDay).length,
+      averageCommitsPerDay: avgCommitsPerDay,
+      busyDays: Object.values(commitsByDay).filter((c) => c > 3).length,
+      quietDays: Object.values(commitsByDay).filter((c) => c === 1).length,
+    };
+  }
+
+  /**
+   * Helper: Assess development health
+   */
+  assessDevelopmentHealth(commits, releases) {
+    const healthFactors = {
+      commitActivity: commits.length > 100 ? 'GOOD' : commits.length > 20 ? 'FAIR' : 'POOR',
+      releaseActivity: releases.length > 5 ? 'GOOD' : releases.length > 1 ? 'FAIR' : 'POOR',
+      recentActivity: this.analyzeDevelopmentTrend(commits),
+    };
+
+    return healthFactors;
+  }
+
+  /**
+   * Helper: Analyze release cadence
+   */
+  analyzeReleaseCadence(releases) {
+    if (releases.length < 2) {
+      return {
+        status: 'INSUFFICIENT_DATA',
+        pattern: 'Not enough releases to determine pattern',
+      };
+    }
+
+    const sortedReleases = releases.sort(
+      (a, b) => new Date(b.published_at) - new Date(a.published_at)
+    );
+
+    const intervals = [];
+    for (let i = 0; i < Math.min(sortedReleases.length - 1, 5); i++) {
+      const interval = (new Date(sortedReleases[i].published_at) -
+        new Date(sortedReleases[i + 1].published_at)) /
+        (1000 * 60 * 60 * 24);
+      intervals.push(Math.round(interval));
+    }
+
+    const avgInterval = Math.round(intervals.reduce((a, b) => a + b, 0) / intervals.length);
+    const consistency = this.assessCadenceConsistency(intervals);
+
+    return {
+      averageIntervalDays: avgInterval,
+      pattern: this.determineReleaseCadence(365 / (avgInterval || 1)),
+      recentIntervals: intervals,
+      consistency,
+    };
+  }
+
+  /**
+   * Helper: Assess cadence consistency
+   */
+  assessCadenceConsistency(intervals) {
+    if (intervals.length < 2) return 'UNKNOWN';
+    const mean = intervals.reduce((a, b) => a + b) / intervals.length;
+    const variance = intervals.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / intervals.length;
+    const stdDev = Math.sqrt(variance);
+    const cv = stdDev / mean;
+
+    if (cv < 0.3) return 'CONSISTENT';
+    if (cv < 0.6) return 'MODERATE';
+    return 'IRREGULAR';
+  }
+
+  /**
+   * Helper: Has changelog
+   */
+  hasChangelog(commits) {
+    return commits.some((c) => c.commit.message.toLowerCase().includes('changelog'));
+  }
+
+  /**
+   * Helper: Detect release automation
+   */
+  detectReleaseAutomation(releases) {
+    return releases.some((r) => r.author?.login === 'github-actions' || r.author?.type === 'Bot');
+  }
+
+  /**
+   * Helper: Describe maintenance
+   */
+  describeMaintenance(level) {
+    const descriptions = {
+      ACTIVE: 'Repository is actively maintained with regular updates',
+      MODERATE: 'Repository is maintained but with lower frequency',
+      DORMANT: 'Repository has been inactive for several months',
+      INACTIVE: 'Repository appears to be abandoned',
+    };
+    return descriptions[level] || 'Unknown maintenance status';
+  }
+
+  /**
+   * Helper: Project maintenance health
+   */
+  projectMaintenanceHealth(level, daysSince) {
+    if (level === 'ACTIVE') {
+      return daysSince < 7 ? 'EXCELLENT' : daysSince < 30 ? 'GOOD' : 'FAIR';
+    }
+    if (level === 'MODERATE') return 'FAIR';
+    if (level === 'DORMANT') return 'POOR';
+    return 'CRITICAL';
+  }
+
+  /**
+   * Helper: Format time ago
+   */
+  formatTimeAgo(days) {
+    if (days < 1) return 'Today';
+    if (days < 7) return `${Math.round(days)} days ago`;
+    if (days < 30) return `${Math.round(days / 7)} weeks ago`;
+    if (days < 365) return `${Math.round(days / 30)} months ago`;
+    return `${Math.round(days / 365)} years ago`;
+  }
+
+  /**
+   * Helper: Analyze update frequency
+   */
+  analyzeUpdateFrequency(commits) {
+    if (commits.length === 0) return 'NEVER';
+
+    const sortedDates = commits
+      .map((c) => new Date(c.commit.author.date))
+      .sort((a, b) => b - a);
+
+    const firstDate = sortedDates[sortedDates.length - 1];
+    const lastDate = sortedDates[0];
+    const daysSpan = (lastDate - firstDate) / (1000 * 60 * 60 * 24);
+
+    if (daysSpan === 0) return 'SINGLE_COMMIT';
+    const frequency = Math.round((commits.length / daysSpan) * 365);
+
+    if (frequency > 200) return 'DAILY';
+    if (frequency > 50) return 'WEEKLY';
+    if (frequency > 12) return 'MONTHLY';
+    if (frequency > 4) return 'QUARTERLY';
+    return 'ANNUAL_OR_LESS';
+  }
+
+  /**
+   * Helper: Assess sustainability
+   */
+  assessSustainability(commits, releases, repoData) {
+    const factors = {
+      commitRate: commits.length > 100 ? 'SUSTAINABLE' : 'AT_RISK',
+      releaseRate: releases.length > 0 ? 'SUSTAINABLE' : 'AT_RISK',
+      documentation: repoData.description ? 'GOOD' : 'POOR',
+      license: repoData.license ? 'PRESENT' : 'MISSING',
+    };
+
+    const sustainableFactors = Object.values(factors).filter((f) => f.includes('SUSTAINABLE') || f === 'GOOD' || f === 'PRESENT').length;
+
+    return {
+      overallAssessment: sustainableFactors >= 3 ? 'SUSTAINABLE' : sustainableFactors >= 2 ? 'AT_RISK' : 'UNSUSTAINABLE',
+      factors,
+    };
+  }
+
+  /**
+   * Generate performance recommendations
+   */
+  generatePerformanceRecommendations(releaseVelocity, developmentVelocity, maintenancePattern) {
+    const recommendations = [];
+
+    if (releaseVelocity.velocity === 'STAGNANT') {
+      recommendations.push({
+        category: 'Release Strategy',
+        issue: 'No releases published',
+        action: 'Create first release and establish release schedule',
+        priority: 'CRITICAL',
+      });
+    } else if (releaseVelocity.velocity === 'SLOW') {
+      recommendations.push({
+        category: 'Release Strategy',
+        issue: 'Infrequent releases',
+        action: 'Increase release frequency to at least quarterly',
+        priority: 'HIGH',
+      });
+    }
+
+    if (developmentVelocity.commitCount < 10) {
+      recommendations.push({
+        category: 'Development Activity',
+        issue: 'Very low commit activity',
+        action: 'Increase development effort or this may be a dormant project',
+        priority: 'HIGH',
+      });
+    }
+
+    if (maintenancePattern.maintenanceLevel === 'DORMANT') {
+      recommendations.push({
+        category: 'Maintenance',
+        issue: 'Repository is dormant',
+        action: 'Resume maintenance or mark as archived',
+        priority: 'MEDIUM',
+      });
+    } else if (maintenancePattern.maintenanceLevel === 'INACTIVE') {
+      recommendations.push({
+        category: 'Maintenance',
+        issue: 'Repository appears abandoned',
+        action: 'Either resume maintenance or archive the repository',
+        priority: 'CRITICAL',
+      });
+    }
+
+    if (developmentVelocity.codeStability === 'UNSTABLE') {
+      recommendations.push({
+        category: 'Code Quality',
+        issue: 'High code churn',
+        action: 'Review code changes, stabilize APIs, reduce unnecessary refactoring',
+        priority: 'MEDIUM',
+      });
+    }
+
+    return recommendations.length > 0
+      ? recommendations
+      : [
+          {
+            category: 'Maintenance',
+            issue: 'Keep current pace',
+            action: 'Continue regular releases and maintenance',
+            priority: 'LOW',
+          },
+        ];
+  }
+
+  /**
+   * Get rating from score
+   */
+  getRating(score) {
+    if (score >= 90) return 'A+';
+    if (score >= 80) return 'A';
+    if (score >= 70) return 'B+';
+    if (score >= 60) return 'B';
+    if (score >= 50) return 'C+';
+    if (score >= 40) return 'C';
+    return 'F';
+  }
+}
+
+export default PerformanceAnalyzer;