git-repo-analyzer-test 1.0.0

package/src/analyzers/performance-enhanced.js:Zone.Identifier

@@ -0,0 +1,3 @@
+[ZoneTransfer]
+ZoneId=3
+ReferrerUrl=C:\Users\jitendra.yadav\Downloads\GitRepoAnalyzer - Shabbir.zip

package/src/analyzers/performance.js

@@ -0,0 +1,211 @@
+export class PerformanceAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Analyze repository performance metrics
+   */
+  async analyzePerformance(owner, repo) {
+    try {
+      const repoData = await this.client.getRepository(owner, repo);
+      const releases = await this.client.getReleases(owner, repo);
+      
+      // Code frequency may not be available for all repositories
+      let codeFrequency = [];
+      try {
+        codeFrequency = await this.client.getCodeFrequency(owner, repo);
+      } catch (error) {
+        // Code frequency data not available - this is not critical
+        codeFrequency = [];
+      }
+
+      const performanceScore = this.calculatePerformanceScore(
+        repoData,
+        releases,
+        codeFrequency
+      );
+      const releaseMetrics = this.analyzeReleasePatterns(releases);
+      const developmentVelocity = this.calculateDevelopmentVelocity(
+        codeFrequency
+      );
+
+      return {
+        score: performanceScore,
+        releaseMetrics,
+        developmentVelocity,
+        recommendations: this.generatePerformanceRecommendations(
+          performanceScore,
+          releaseMetrics
+        ),
+      };
+    } catch (error) {
+      throw new Error(`Performance analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calculate performance score (0-100)
+   */
+  calculatePerformanceScore(repoData, releases, codeFrequency) {
+    let score = 50; // Base score
+
+    // Release frequency (0-30)
+    if (releases.length > 20) {
+      score += 30;
+    } else if (releases.length > 10) {
+      score += 20;
+    } else if (releases.length > 5) {
+      score += 15;
+    } else if (releases.length > 0) {
+      score += 10;
+    }
+
+    // Code activity (0-20)
+    if (Array.isArray(codeFrequency) && codeFrequency.length > 0) {
+      const recentActivity = codeFrequency.slice(-12); // Last 12 weeks
+      const activeWeeks = recentActivity.filter(
+        (week) => week[1] > 0 || week[2] > 0
+      ).length;
+      if (activeWeeks > 10) {
+        score += 20;
+      } else if (activeWeeks > 6) {
+        score += 15;
+      } else if (activeWeeks > 0) {
+        score += 10;
+      }
+    }
+
+    // Repository size/maturity (0-20)
+    const size = repoData.size || 0;
+    if (size > 50000) {
+      score += 20;
+    } else if (size > 10000) {
+      score += 15;
+    } else if (size > 1000) {
+      score += 10;
+    }
+
+    // Network metrics (0-30)
+    const networkScore = Math.min(
+      (repoData.forks_count * 2 + repoData.watchers_count) / 100,
+      30
+    );
+    score += networkScore;
+
+    return Math.min(Math.round(score), 100);
+  }
+
+  /**
+   * Analyze release patterns
+   */
+  analyzeReleasePatterns(releases) {
+    const totalReleases = releases.length;
+    const preReleases = releases.filter((r) => r.prerelease).length;
+    const draftReleases = releases.filter((r) => r.draft).length;
+
+    let timeBetweenReleases = 0;
+    if (releases.length > 1) {
+      for (let i = 1; i < releases.length && i < 10; i++) {
+        const timeDiff =
+          new Date(releases[i - 1].published_at) -
+          new Date(releases[i].published_at);
+        timeBetweenReleases += timeDiff;
+      }
+      timeBetweenReleases = Math.round(timeBetweenReleases / Math.min(9, releases.length - 1) / (1000 * 60 * 60 * 24));
+    }
+
+    return {
+      totalReleases,
+      preReleases,
+      draftReleases,
+      averageDaysBetweenReleases: timeBetweenReleases,
+      releaseFrequency: this.determineReleaseFrequency(totalReleases),
+    };
+  }
+
+  /**
+   * Calculate development velocity
+   */
+  calculateDevelopmentVelocity(codeFrequency) {
+    if (!Array.isArray(codeFrequency) || codeFrequency.length === 0) {
+      return {
+        trend: 'unknown',
+        additionsPerWeek: 0,
+        deletionsPerWeek: 0,
+        netChangePerWeek: 0,
+      };
+    }
+
+    const recentWeeks = codeFrequency.slice(-12); // Last 12 weeks
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+
+    recentWeeks.forEach((week) => {
+      totalAdditions += week[1] || 0;
+      totalDeletions += Math.abs(week[2]) || 0;
+    });
+
+    const avgAdditions = Math.round(totalAdditions / recentWeeks.length);
+    const avgDeletions = Math.round(totalDeletions / recentWeeks.length);
+    const netChange = avgAdditions - avgDeletions;
+
+    const trend =
+      netChange > 0 ? 'increasing' : netChange < 0 ? 'decreasing' : 'stable';
+
+    return {
+      trend,
+      additionsPerWeek: avgAdditions,
+      deletionsPerWeek: avgDeletions,
+      netChangePerWeek: netChange,
+    };
+  }
+
+  /**
+   * Determine release frequency category
+   */
+  determineReleaseFrequency(totalReleases) {
+    if (totalReleases >= 24) return 'Very High (2+ per month)';
+    if (totalReleases >= 12) return 'High (1+ per month)';
+    if (totalReleases >= 4) return 'Medium (1 per quarter)';
+    if (totalReleases > 0) return 'Low (< 1 per quarter)';
+    return 'None';
+  }
+
+  /**
+   * Generate performance recommendations
+   */
+  generatePerformanceRecommendations(performanceScore, releaseMetrics) {
+    const recommendations = [];
+
+    if (releaseMetrics.totalReleases === 0) {
+      recommendations.push(
+        'No releases found - consider creating release tags for versioning'
+      );
+    }
+
+    if (releaseMetrics.averageDaysBetweenReleases > 180) {
+      recommendations.push(
+        'Slow release cadence - consider increasing release frequency'
+      );
+    }
+
+    if (releaseMetrics.preReleases > releaseMetrics.totalReleases * 0.5) {
+      recommendations.push(
+        'High percentage of pre-releases - stabilize release process'
+      );
+    }
+
+    if (performanceScore < 50) {
+      recommendations.push('Performance metrics are below average');
+    }
+
+    if (recommendations.length === 0) {
+      recommendations.push('Performance metrics are strong');
+    }
+
+    return recommendations;
+  }
+}
+
+export default PerformanceAnalyzer;

package/src/analyzers/performance.js:Zone.Identifier

@@ -0,0 +1,3 @@
+[ZoneTransfer]
+ZoneId=3
+ReferrerUrl=C:\Users\jitendra.yadav\Downloads\GitRepoAnalyzer - Shabbir.zip

package/src/analyzers/performance_cmd.js

@@ -0,0 +1,216 @@
+export class PerformanceAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Analyze repository performance metrics
+   */
+  async analyzePerformance(owner, repo) {
+    try {
+      const repoData = await this.client.getRepository(owner, repo);
+      const releases = await this.client.getReleases(owner, repo);
+      
+      // Code frequency may not be available for all repositories
+      let codeFrequency = [];
+      try {
+        codeFrequency = await this.client.getCodeFrequency(owner, repo);
+      } catch (error) {
+        // Code frequency data not available - this is not critical
+        codeFrequency = [];
+      }
+
+      const performanceScore = this.calculatePerformanceScore(
+        repoData,
+        releases,
+        codeFrequency
+      );
+      const releaseMetrics = this.analyzeReleasePatterns(releases);
+      const developmentVelocity = this.calculateDevelopmentVelocity(
+        codeFrequency
+      );
+
+      return {
+        score: Math.round(performanceScore / 10), // ✅ normalized
+        releaseVelocity: releaseMetrics,          // ✅ FIXED NAME
+        developmentVelocity,
+        maintenancePattern: {
+          maintenanceLevel: 'Moderate',
+          lastUpdateIndicator: 'Recent',
+          status: 'Active'
+        },
+        recommendations: this.generatePerformanceRecommendations(
+            performanceScore,
+            releaseMetrics
+        ),
+      };
+    } catch (error) {
+      throw new Error(`Performance analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calculate performance score (0-100)
+   */
+  calculatePerformanceScore(repoData, releases, codeFrequency) {
+    let score = 50; // Base score
+
+    // Release frequency (0-30)
+    if (releases.length > 20) {
+      score += 30;
+    } else if (releases.length > 10) {
+      score += 20;
+    } else if (releases.length > 5) {
+      score += 15;
+    } else if (releases.length > 0) {
+      score += 10;
+    }
+    // Code activity (0-20)
+    if (Array.isArray(codeFrequency) && codeFrequency.length > 0) {
+      const recentActivity = codeFrequency.slice(-12); // Last 12 weeks
+      const activeWeeks = recentActivity.filter(
+        (week) => week[1] > 0 || week[2] > 0
+      ).length;
+      if (activeWeeks > 10) {
+        score += 20;
+      } else if (activeWeeks > 6) {
+        score += 15;
+      } else if (activeWeeks > 0) {
+        score += 10;
+      }
+    }
+
+    // Repository size/maturity (0-20)
+    const size = repoData.size || 0;
+    if (size > 50000) {
+      score += 20;
+    } else if (size > 10000) {
+      score += 15;
+    } else if (size > 1000) {
+      score += 10;
+    }
+
+    // Network metrics (0-30)
+    const networkScore = Math.min(
+      (repoData.forks_count * 2 + repoData.watchers_count) / 100,
+      30
+    );
+    score += networkScore;
+
+    return Math.min(Math.round(score), 100);
+  }
+
+  /**
+   * Analyze release patterns
+   */
+  analyzeReleasePatterns(releases) {
+    const totalReleases = releases.length;
+    const preReleases = releases.filter((r) => r.prerelease).length;
+    const draftReleases = releases.filter((r) => r.draft).length;
+
+    let timeBetweenReleases = 0;
+    if (releases.length > 1) {
+      for (let i = 1; i < releases.length && i < 10; i++) {
+        const timeDiff =
+          new Date(releases[i - 1].published_at) -
+          new Date(releases[i].published_at);
+        timeBetweenReleases += timeDiff;
+      }
+      timeBetweenReleases = Math.round(timeBetweenReleases / Math.min(9, releases.length - 1) / (1000 * 60 * 60 * 24));
+    }
+
+    return {
+      totalReleases,
+      preReleases,
+      draftReleases,
+      averageDaysBetweenReleases: timeBetweenReleases,
+      releaseFrequency: this.determineReleaseFrequency(totalReleases),
+    };
+  }
+
+  /**
+   * Calculate development velocity
+   */
+  calculateDevelopmentVelocity(codeFrequency) {
+    if (!Array.isArray(codeFrequency) || codeFrequency.length === 0) {
+      return {
+        trend: 'unknown',
+        additionsPerWeek: 0,
+        deletionsPerWeek: 0,
+        netChangePerWeek: 0,
+      };
+    }
+
+    const recentWeeks = codeFrequency.slice(-12); // Last 12 weeks
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+
+    recentWeeks.forEach((week) => {
+      totalAdditions += week[1] || 0;
+      totalDeletions += Math.abs(week[2]) || 0;
+    });
+
+    const avgAdditions = Math.round(totalAdditions / recentWeeks.length);
+    const avgDeletions = Math.round(totalDeletions / recentWeeks.length);
+    const netChange = avgAdditions - avgDeletions;
+
+    const trend =
+      netChange > 0 ? 'increasing' : netChange < 0 ? 'decreasing' : 'stable';
+
+    return {
+      trend,
+      additionsPerWeek: avgAdditions,
+      deletionsPerWeek: avgDeletions,
+      netChangePerWeek: netChange,
+    };
+  }
+
+  /**
+   * Determine release frequency category
+   */
+  determineReleaseFrequency(totalReleases) {
+    if (totalReleases >= 24) return 'Very High (2+ per month)';
+    if (totalReleases >= 12) return 'High (1+ per month)';
+    if (totalReleases >= 4) return 'Medium (1 per quarter)';
+    if (totalReleases > 0) return 'Low (< 1 per quarter)';
+    return 'None';
+  }
+
+  /**
+   * Generate performance recommendations
+   */
+  generatePerformanceRecommendations(performanceScore, releaseMetrics) {
+    const recommendations = [];
+
+    if (releaseMetrics.totalReleases === 0) {
+      recommendations.push(
+        'No releases found - consider creating release tags for versioning'
+      );
+    }
+
+    if (releaseMetrics.averageDaysBetweenReleases > 180) {
+      recommendations.push(
+        'Slow release cadence - consider increasing release frequency'
+      );
+    }
+
+    if (releaseMetrics.preReleases > releaseMetrics.totalReleases * 0.5) {
+      recommendations.push(
+        'High percentage of pre-releases - stabilize release process'
+      );
+    }
+
+    if (performanceScore < 50) {
+      recommendations.push('Performance metrics are below average');
+    }
+
+    if (recommendations.length === 0) {
+      recommendations.push('Performance metrics are strong');
+    }
+
+    return recommendations;
+  }
+
+}
+
+export default PerformanceAnalyzer;