git-repo-analyzer-test 1.0.0

package/src/analyzers/codeReview-enhanced.js

@@ -0,0 +1,599 @@
+/**
+ * Enhanced Code Review & Collaboration Analyzer
+ * Analyzes coding style, practices, and collaboration patterns
+ */
+export class CodeReviewAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Comprehensive code review and collaboration analysis
+   */
+  async analyzeCodeReviewPractices(owner, repo) {
+    try {
+      const [pullRequests, commits, contributors, languages] = await Promise.all([
+        this.client.getPullRequests(owner, repo, { state: 'all' }),
+        this.client.getCommits(owner, repo, { perPage: 100 }),
+        this.client.getContributors(owner, repo),
+        this.client.getLanguages(owner, repo),
+      ]);
+
+      const reviewMetrics = this.calculateReviewMetrics(pullRequests);
+      const codingStyle = this.analyzeCodingStyle(commits, languages);
+      const collaborationScore = this.calculateCollaborationScore(
+        pullRequests,
+        contributors
+      );
+      const score = collaborationScore;
+      const rating = this.getRating(score);
+
+      return {
+        score,
+        rating,
+        reviewMetrics,
+        codingStyle,
+        collaborationMetrics: {
+          contributors: contributors.length,
+          activeContributors: this.getActiveContributors(contributors),
+          coreTeamSize: this.identifyCoreTeam(contributors),
+          diversityIndex: this.calculateTeamDiversity(contributors),
+        },
+        reviewPractices: this.assessReviewPractices(pullRequests),
+        recommendations: this.generateCollaborationRecommendations(
+          reviewMetrics,
+          codingStyle,
+          pullRequests
+        ),
+        details: {
+          prAnalysis: this.analyzePullRequestPatterns(pullRequests),
+          commitAnalysis: this.analyzeCommitPatterns(commits),
+          teamDynamics: this.analyzeTeamDynamics(pullRequests, contributors),
+          codeStandards: this.assessCodingStandards(languages),
+        },
+      };
+    } catch (error) {
+      throw new Error(`Code review analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calculate review metrics
+   */
+  calculateReviewMetrics(pullRequests) {
+    const totalPRs = pullRequests.length;
+    const closedPRs = pullRequests.filter((pr) => pr.state === 'closed').length;
+    const openPRs = pullRequests.filter((pr) => pr.state === 'open').length;
+    const mergedPRs = pullRequests.filter((pr) => pr.merged_at).length;
+    const draftPRs = pullRequests.filter((pr) => pr.draft).length;
+
+    let totalReviewTime = 0;
+    let reviewedPRs = 0;
+    let averageComments = 0;
+    let prWithApprovals = 0;
+
+    pullRequests.forEach((pr) => {
+      if (pr.merged_at && pr.created_at) {
+        const timeToMerge = new Date(pr.merged_at) - new Date(pr.created_at);
+        totalReviewTime += timeToMerge;
+        reviewedPRs++;
+      }
+      averageComments += pr.comments || 0;
+
+      // Estimate approvals (GitHub doesn't provide this directly via API)
+      if (pr.review_comments && pr.review_comments > 0) {
+        prWithApprovals++;
+      }
+    });
+
+    const avgReviewTimeHours =
+      reviewedPRs > 0 ? Math.round(totalReviewTime / reviewedPRs / (1000 * 60 * 60)) : 0;
+    const avgCommentsPerPR =
+      totalPRs > 0 ? (averageComments / totalPRs).toFixed(1) : 0;
+    const closureRate = totalPRs > 0 ? Math.round((closedPRs / totalPRs) * 100) : 0;
+    const approvalRate =
+      totalPRs > 0 ? Math.round((prWithApprovals / totalPRs) * 100) : 0;
+
+    return {
+      totalPullRequests: totalPRs,
+      closedPullRequests: closedPRs,
+      openPullRequests: openPRs,
+      mergedPullRequests: mergedPRs,
+      draftPullRequests: draftPRs,
+      averageReviewTimeHours: avgReviewTimeHours,
+      averageCommentsPerPR: avgCommentsPerPR,
+      prClosureRate: closureRate,
+      prApprovalRate: approvalRate,
+      reviewQuality: this.assessReviewQuality(avgReviewTimeHours, avgCommentsPerPR),
+    };
+  }
+
+  /**
+   * Analyze coding style
+   */
+  analyzeCodingStyle(commits, languages) {
+    const primaryLanguages = Object.keys(languages)
+      .sort((a, b) => languages[b] - languages[a])
+      .slice(0, 3);
+
+    const commitMessages = commits.map((c) => c.commit?.message || '');
+    const conventionalCommits = commitMessages.filter(
+      (msg) =>
+        /^(feat|fix|docs|style|refactor|perf|test|chore)(\(.+\))?:/i.test(msg)
+    ).length;
+
+    const avgMessageLength =
+      commitMessages.length > 0
+        ? Math.round(commitMessages.reduce((a, b) => a + b.length, 0) / commitMessages.length)
+        : 0;
+
+    return {
+      primaryLanguages,
+      commitConventionAdherence: {
+        total: commits.length,
+        conventional: conventionalCommits,
+        percentage:
+          commits.length > 0
+            ? Math.round((conventionalCommits / commits.length) * 100)
+            : 0,
+        status:
+          commits.length > 0 && (conventionalCommits / commits.length) > 0.7
+            ? 'GOOD'
+            : 'NEEDS_IMPROVEMENT',
+      },
+      commitMessageQuality: {
+        averageLength: avgMessageLength,
+        status: avgMessageLength > 30 && avgMessageLength < 100 ? 'GOOD' : 'IMPROVE',
+        recommendation:
+          avgMessageLength < 30
+            ? 'Commit messages too short, add more context'
+            : avgMessageLength > 100
+              ? 'Commit messages too long, be more concise'
+              : 'Commit message length is good',
+      },
+      recommendations: [
+        'Use conventional commits (feat:, fix:, docs:, etc.)',
+        'Write descriptive commit messages',
+        'Reference issues in commits (#123)',
+        'Keep commits focused and atomic',
+        'Avoid merge commits, use rebase',
+      ],
+    };
+  }
+
+  /**
+   * Calculate collaboration score
+   */
+  calculateCollaborationScore(pullRequests, contributors) {
+    let score = 50;
+
+    // Multiple contributors (0-20 points)
+    score += Math.min(contributors.length * 2, 20);
+
+    // PR activity (0-20 points)
+    const totalPRs = pullRequests.length;
+    score += Math.min(totalPRs / 5, 20);
+
+    // PR closure rate (0-15 points)
+    const closedPRs = pullRequests.filter((pr) => pr.state === 'closed').length;
+    const closureRate = totalPRs > 0 ? (closedPRs / totalPRs) * 100 : 0;
+    if (closureRate > 80) {
+      score += 15;
+    } else if (closureRate > 60) {
+      score += 12;
+    } else if (closureRate > 40) {
+      score += 8;
+    } else if (closureRate > 0) {
+      score += 3;
+    }
+
+    // Review quality (0-15 points)
+    let avgReviewTime = 0;
+    pullRequests.forEach((pr) => {
+      if (pr.merged_at && pr.created_at) {
+        const timeToMerge = new Date(pr.merged_at) - new Date(pr.created_at);
+        avgReviewTime += timeToMerge;
+      }
+    });
+    const reviewedCount = pullRequests.filter((pr) => pr.merged_at).length;
+    avgReviewTime =
+      reviewedCount > 0 ? Math.round(avgReviewTime / reviewedCount / (1000 * 60 * 60)) : 0;
+
+    if (avgReviewTime < 24) {
+      score += 15;
+    } else if (avgReviewTime < 72) {
+      score += 12;
+    } else if (avgReviewTime < 168) {
+      score += 8;
+    } else {
+      score += 3;
+    }
+
+    return Math.min(score, 100);
+  }
+
+  /**
+   * Assess review practices
+   */
+  assessReviewPractices(pullRequests) {
+    const hasRequiredReviews = pullRequests.some((pr) => pr.requested_reviewers?.length > 0);
+    const hasCodeOwners = pullRequests.some((pr) => pr.labels?.some((l) => l.name === 'codeowners'));
+    const hasCIIntegration = pullRequests.some(
+      (pr) => pr.statuses_url && pr.review_comments > 0
+    );
+
+    const reviewComments = pullRequests
+      .filter((pr) => pr.merged_at)
+      .map((pr) => pr.review_comments || 0);
+    const avgReviewComments =
+      reviewComments.length > 0
+        ? Math.round(reviewComments.reduce((a, b) => a + b, 0) / reviewComments.length)
+        : 0;
+
+    return {
+      hasRequiredReviews,
+      hasCodeOwners,
+      hasCIIntegration,
+      averageReviewComments: avgReviewComments,
+      status: hasRequiredReviews && avgReviewComments > 2 ? 'STRONG' : 'NEEDS_IMPROVEMENT',
+      recommendations: [
+        'Require pull request reviews before merging',
+        'Use CODEOWNERS file for automated reviewer assignment',
+        'Set minimum number of required approvals',
+        'Dismiss stale review approvals on push',
+        'Require status checks to pass',
+      ],
+    };
+  }
+
+  /**
+   * Analyze pull request patterns
+   */
+  analyzePullRequestPatterns(pullRequests) {
+    const patterns = {
+      totalPRs: pullRequests.length,
+      averagePRSize: this.calculateAveragePRSize(pullRequests),
+      largestPR: this.findLargestPR(pullRequests),
+      smallestPR: this.findSmallestPR(pullRequests),
+      prsByStatus: {
+        merged: pullRequests.filter((pr) => pr.merged_at).length,
+        closed: pullRequests.filter((pr) => pr.state === 'closed' && !pr.merged_at).length,
+        open: pullRequests.filter((pr) => pr.state === 'open').length,
+        draft: pullRequests.filter((pr) => pr.draft).length,
+      },
+      recommendations: [
+        'Keep PRs small and focused (200-400 lines)',
+        'Avoid large batch PRs (>1000 lines)',
+        'Aim for quick review cycles (< 24 hours)',
+        'Require descriptive PR titles and descriptions',
+        'Link related issues in PR descriptions',
+      ],
+    };
+    return patterns;
+  }
+
+  /**
+   * Analyze commit patterns
+   */
+  analyzeCommitPatterns(commits) {
+    const authors = new Set();
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+
+    commits.forEach((commit) => {
+      if (commit.author) {
+        authors.add(commit.author.login);
+      }
+    });
+
+    return {
+      totalCommits: commits.length,
+      uniqueAuthors: authors.size,
+      averageCommitsPerAuthor:
+        authors.size > 0 ? Math.round(commits.length / authors.size) : 0,
+      commitFrequency: this.determineCommitFrequency(commits),
+      recommendations: [
+        'Maintain regular commit cadence',
+        'Encourage atomic, focused commits',
+        'Use meaningful commit messages',
+        'Sign commits for security',
+        'Leverage squash commits for PRs',
+      ],
+    };
+  }
+
+  /**
+   * Analyze team dynamics
+   */
+  analyzeTeamDynamics(pullRequests, contributors) {
+    const reviewerFrequency = {};
+    const authorFrequency = {};
+
+    pullRequests.forEach((pr) => {
+      if (pr.user) {
+        authorFrequency[pr.user.login] = (authorFrequency[pr.user.login] || 0) + 1;
+      }
+    });
+
+    return {
+      topContributors: Object.entries(authorFrequency)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([author, count]) => ({ author, contributionCount: count })),
+      totalContributors: contributors.length,
+      teamSize: this.categorizTeamSize(contributors.length),
+      collaborationHealth: this.assessCollaborationHealth(pullRequests, contributors),
+      recommendations: [
+        'Distribute review responsibilities',
+        'Mentor junior developers',
+        'Rotate code review duties',
+        'Document review standards',
+        'Celebrate contributions',
+      ],
+    };
+  }
+
+  /**
+   * Assess coding standards
+   */
+  assessCodingStandards(languages) {
+    const standards = {};
+    Object.keys(languages).forEach((lang) => {
+      standards[lang] = this.getStandardsForLanguage(lang);
+    });
+
+    return {
+      primaryLanguageStandards: standards,
+      commonIssues: [
+        'Inconsistent naming conventions',
+        'Missing type hints/annotations',
+        'Inadequate error handling',
+        'Lack of input validation',
+        'Insufficient code comments',
+      ],
+      recommendations: [
+        'Implement linting rules (ESLint, Pylint, etc.)',
+        'Use formatters (Prettier, Black, etc.)',
+        'Define code style guide',
+        'Enforce naming conventions',
+        'Use static analysis tools',
+      ],
+    };
+  }
+
+  /**
+   * Helper: Calculate average PR size
+   */
+  calculateAveragePRSize(pullRequests) {
+    const sizes = pullRequests
+      .map((pr) => (pr.additions || 0) + (pr.deletions || 0))
+      .filter((size) => size > 0);
+    return sizes.length > 0 ? Math.round(sizes.reduce((a, b) => a + b, 0) / sizes.length) : 0;
+  }
+
+  /**
+   * Helper: Find largest PR
+   */
+  findLargestPR(pullRequests) {
+    let largest = 0;
+    let largestPR = null;
+    pullRequests.forEach((pr) => {
+      const size = (pr.additions || 0) + (pr.deletions || 0);
+      if (size > largest) {
+        largest = size;
+        largestPR = { number: pr.number, size, title: pr.title };
+      }
+    });
+    return largestPR;
+  }
+
+  /**
+   * Helper: Find smallest PR
+   */
+  findSmallestPR(pullRequests) {
+    let smallest = Infinity;
+    let smallestPR = null;
+    pullRequests.forEach((pr) => {
+      const size = (pr.additions || 0) + (pr.deletions || 0);
+      if (size > 0 && size < smallest) {
+        smallest = size;
+        smallestPR = { number: pr.number, size, title: pr.title };
+      }
+    });
+    return smallestPR;
+  }
+
+  /**
+   * Helper: Assess review quality
+   */
+  assessReviewQuality(avgReviewTime, avgComments) {
+    if (avgReviewTime < 24 && avgComments > 2) {
+      return 'EXCELLENT';
+    }
+    if (avgReviewTime < 72 && avgComments > 1) {
+      return 'GOOD';
+    }
+    if (avgReviewTime < 168) {
+      return 'ACCEPTABLE';
+    }
+    return 'NEEDS_IMPROVEMENT';
+  }
+
+  /**
+   * Helper: Get active contributors
+   */
+  getActiveContributors(contributors) {
+    return contributors.filter((c) => (c.contributions || 0) > 10).length;
+  }
+
+  /**
+   * Helper: Identify core team
+   */
+  identifyCoreTeam(contributors) {
+    const topContributions = contributors
+      .map((c) => c.contributions || 0)
+      .sort((a, b) => b - a)
+      .slice(0, 3);
+    return topContributions.reduce((a, b) => a + b, 0);
+  }
+
+  /**
+   * Helper: Calculate team diversity
+   */
+  calculateTeamDiversity(contributors) {
+    return Math.min(contributors.length / 5, 10); // Score out of 10
+  }
+
+  /**
+   * Helper: Determine commit frequency
+   */
+  determineCommitFrequency(commits) {
+    if (commits.length === 0) return 'None';
+    if (commits.length > 500) return 'Very High';
+    if (commits.length > 100) return 'High';
+    if (commits.length > 20) return 'Moderate';
+    return 'Low';
+  }
+
+  /**
+   * Helper: Categorize team size
+   */
+  categorizTeamSize(count) {
+    if (count === 1) return 'Solo';
+    if (count <= 3) return 'Small';
+    if (count <= 10) return 'Medium';
+    if (count <= 50) return 'Large';
+    return 'Enterprise';
+  }
+
+  /**
+   * Helper: Assess collaboration health
+   */
+  assessCollaborationHealth(pullRequests, contributors) {
+    const avgPRsPerContributor = pullRequests.length / (contributors.length || 1);
+    if (avgPRsPerContributor > 5) return 'EXCELLENT';
+    if (avgPRsPerContributor > 2) return 'GOOD';
+    if (avgPRsPerContributor > 0) return 'FAIR';
+    return 'NEEDS_IMPROVEMENT';
+  }
+
+  /**
+   * Helper: Get standards for language
+   */
+  getStandardsForLanguage(language) {
+    const languageStandards = {
+      JavaScript: {
+        linter: 'ESLint',
+        formatter: 'Prettier',
+        testFramework: 'Jest, Mocha',
+        style: 'Google JavaScript Style Guide',
+      },
+      Python: {
+        linter: 'Pylint, Flake8',
+        formatter: 'Black',
+        testFramework: 'pytest',
+        style: 'PEP 8',
+      },
+      TypeScript: {
+        linter: 'ESLint',
+        formatter: 'Prettier',
+        testFramework: 'Jest',
+        style: 'Google TypeScript Style Guide',
+      },
+      Java: {
+        linter: 'Checkstyle',
+        formatter: 'Google Java Format',
+        testFramework: 'JUnit, Mockito',
+        style: 'Google Java Style Guide',
+      },
+      'C++': {
+        linter: 'Clang-Tidy',
+        formatter: 'Clang-Format',
+        testFramework: 'Google Test',
+        style: 'Google C++ Style Guide',
+      },
+      Go: {
+        linter: 'GolangCI-Lint',
+        formatter: 'gofmt',
+        testFramework: 'testing package',
+        style: 'Effective Go',
+      },
+    };
+
+    return languageStandards[language] || {
+      linter: 'Not specified',
+      formatter: 'Not specified',
+      testFramework: 'Not specified',
+      style: 'Check community standards',
+    };
+  }
+
+  /**
+   * Generate collaboration recommendations
+   */
+  generateCollaborationRecommendations(reviewMetrics, codingStyle, pullRequests) {
+    const recommendations = [];
+
+    if (reviewMetrics.prClosureRate < 60) {
+      recommendations.push({
+        category: 'PR Management',
+        issue: 'Low PR closure rate',
+        action: 'Implement weekly triage meetings for stale PRs',
+        priority: 'HIGH',
+      });
+    }
+
+    if (reviewMetrics.averageReviewTimeHours > 72) {
+      recommendations.push({
+        category: 'Review Efficiency',
+        issue: 'Slow review turnaround',
+        action: 'Establish review SLAs (e.g., 24-hour response time)',
+        priority: 'HIGH',
+      });
+    }
+
+    if (codingStyle.commitConventionAdherence.percentage < 70) {
+      recommendations.push({
+        category: 'Coding Standards',
+        issue: 'Inconsistent commit messages',
+        action: 'Enforce conventional commits with husky/commitlint',
+        priority: 'MEDIUM',
+      });
+    }
+
+    if (reviewMetrics.averageCommentsPerPR < 2) {
+      recommendations.push({
+        category: 'Code Quality',
+        issue: 'Insufficient review comments',
+        action: 'Encourage thorough code reviews, use checklists',
+        priority: 'MEDIUM',
+      });
+    }
+
+    return recommendations.length > 0
+      ? recommendations
+      : [
+          {
+            category: 'Maintenance',
+            issue: 'Keep up the good work',
+            action: 'Maintain current practices',
+            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 CodeReviewAnalyzer;

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

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