git-repo-analyzer-test 1.0.0

package/src/analyzers/codeReview.js

@@ -0,0 +1,171 @@
+export class CodeReviewAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Analyze code review practices and metrics
+   */
+  async analyzeCodeReview(owner, repo) {
+    try {
+      const [pullRequests, commits, contributors] = await Promise.all([
+        this.client.getPullRequests(owner, repo, { state: 'all' }),
+        this.client.getCommits(owner, repo, { perPage: 100 }),
+        this.client.getContributors(owner, repo),
+      ]);
+
+      const reviewMetrics = this.calculateReviewMetrics(pullRequests);
+      const commitMetrics = this.analyzeCommitPatterns(commits);
+      const collaborationScore = this.calculateCollaborationScore(
+        pullRequests,
+        contributors
+      );
+
+      return {
+        score: collaborationScore,
+        reviewMetrics,
+        commitMetrics,
+        contributors: contributors.length,
+        recommendations: this.generateCodeReviewRecommendations(reviewMetrics),
+      };
+    } catch (error) {
+      throw new Error(`Code review analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calculate code 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;
+
+    let totalReviewTime = 0;
+    let reviewedPRs = 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++;
+      }
+    });
+
+    const avgReviewTimeHours =
+      reviewedPRs > 0 ? Math.round(totalReviewTime / reviewedPRs / (1000 * 60 * 60)) : 0;
+
+    return {
+      totalPullRequests: totalPRs,
+      closedPullRequests: closedPRs,
+      openPullRequests: openPRs,
+      mergedPullRequests: mergedPRs,
+      averageReviewTimeHours: avgReviewTimeHours,
+      prClosureRate:
+        totalPRs > 0 ? Math.round((closedPRs / totalPRs) * 100) : 0,
+    };
+  }
+
+  /**
+   * Analyze commit patterns
+   */
+  analyzeCommitPatterns(commits) {
+    const totalCommits = commits.length;
+    const authorSet = new Set();
+    let totalChanges = 0;
+
+    commits.forEach((commit) => {
+      if (commit.author) {
+        authorSet.add(commit.author.login);
+      }
+      if (commit.commit?.message) {
+        // Simple heuristic for change size based on message
+        totalChanges += commit.commit.message.length;
+      }
+    });
+
+    return {
+      totalCommits,
+      uniqueAuthors: authorSet.size,
+      averageCommitSize: totalCommits > 0 ? Math.round(totalChanges / totalCommits) : 0,
+      commitFrequency: totalCommits > 0 ? 'Active' : 'Inactive',
+    };
+  }
+
+  /**
+   * Calculate collaboration score (0-100)
+   */
+  calculateCollaborationScore(pullRequests, contributors) {
+    let score = 50; // Base score
+
+    // Multiple contributors (0-20)
+    score += Math.min(contributors.length * 2, 20);
+
+    // PR activity (0-20)
+    const totalPRs = pullRequests.length;
+    score += Math.min(totalPRs / 5, 20);
+
+    // PR closure rate (0-20)
+    const closedPRs = pullRequests.filter((pr) => pr.state === 'closed').length;
+    const closureRate = totalPRs > 0 ? (closedPRs / totalPRs) * 100 : 0;
+    if (closureRate > 80) {
+      score += 20;
+    } else if (closureRate > 50) {
+      score += 15;
+    } else if (closureRate > 20) {
+      score += 10;
+    }
+
+    // Recent PR activity (0-20)
+    const recentPRs = pullRequests.filter((pr) => {
+      const prDate = new Date(pr.created_at);
+      const daysSince = Math.floor((new Date() - prDate) / (1000 * 60 * 60 * 24));
+      return daysSince < 30;
+    });
+
+    if (recentPRs.length > 0) {
+      score += Math.min(recentPRs.length * 5, 20);
+    }
+
+    return Math.min(score, 100);
+  }
+
+  /**
+   * Generate code review recommendations
+   */
+  generateCodeReviewRecommendations(reviewMetrics) {
+    const recommendations = [];
+
+    if (reviewMetrics.openPullRequests > 10) {
+      recommendations.push(
+        'High number of open PRs - focus on code review velocity'
+      );
+    }
+
+    if (reviewMetrics.averageReviewTimeHours > 48) {
+      recommendations.push(
+        'Review time is slow - consider implementing faster review processes'
+      );
+    }
+
+    if (reviewMetrics.prClosureRate < 50) {
+      recommendations.push('Low PR closure rate - address stale pull requests');
+    }
+
+    if (reviewMetrics.totalPullRequests === 0) {
+      recommendations.push(
+        'No pull requests found - encourage using PR workflow'
+      );
+    }
+
+    if (recommendations.length === 0) {
+      recommendations.push('Code review process looks healthy');
+    }
+
+    return recommendations;
+  }
+}
+
+export default CodeReviewAnalyzer;

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

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

package/src/analyzers/documentation-enhanced.js

@@ -0,0 +1,137 @@
+/**
+ * Documentation & repo health analyzer
+ * Checks for README, LICENSE, CONTRIBUTING, SECURITY.md, CODE_OF_CONDUCT, docs, .github support
+ */
+
+export class DocumentationAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  async analyzeDocumentation(owner, repo) {
+    const root = await this.client.getRepositoryContents(owner, repo, '');
+    const fileNames = (root || []).map((f) => (f.name || '').toLowerCase());
+
+    const hasReadme = fileNames.some(
+      (n) => n === 'readme' || n === 'readme.md' || n === 'readme.txt' || n.startsWith('readme.')
+    );
+    const hasLicense = fileNames.some(
+      (n) => n === 'license' || n === 'license.md' || n === 'license.txt' || n.startsWith('license.')
+    );
+    const hasContributing = fileNames.some(
+      (n) =>
+        n === 'contributing' ||
+        n === 'contributing.md' ||
+        n === 'contributing.txt' ||
+        n.startsWith('contributing.')
+    );
+    const hasSecurity = fileNames.some(
+      (n) => n === 'security.md' || n === 'security.txt' || n.startsWith('security.')
+    );
+    const hasCodeOfConduct = fileNames.some(
+      (n) =>
+        n === 'code_of_conduct.md' ||
+        n === 'code_of_conduct.txt' ||
+        n === 'codeofconduct' ||
+        n.startsWith('code_of_conduct.')
+    );
+    const hasDocs = fileNames.some((n) => n === 'docs');
+
+    let githubFiles = [];
+    try {
+      githubFiles = await this.client.getRepositoryContents(owner, repo, '.github');
+      if (!Array.isArray(githubFiles)) githubFiles = [githubFiles];
+    } catch {
+      // no .github folder
+    }
+    const githubNames = githubFiles.map((f) => (f.name || '').toLowerCase());
+    const hasWorkflows = githubNames.some((n) => n === 'workflows');
+    const hasIssueTemplate =
+      githubNames.some((n) => n === 'issue_template.md' || n === 'issue_template') ||
+      githubNames.some((n) => n === 'issues');
+    const hasPrTemplate =
+      githubNames.some((n) => n === 'pull_request_template.md' || n === 'pull_request_template');
+
+    const checks = {
+      readme: hasReadme,
+      license: hasLicense,
+      contributing: hasContributing,
+      security: hasSecurity,
+      codeOfConduct: hasCodeOfConduct,
+      docsFolder: hasDocs,
+      workflows: hasWorkflows,
+      issueTemplate: hasIssueTemplate,
+      prTemplate: hasPrTemplate,
+    };
+
+    const score = this.calculateScore(checks);
+    const rating = this.getRating(score);
+
+    return {
+      score,
+      rating,
+      checks,
+      recommendations: this.getRecommendations(checks),
+      summary: this.getSummary(checks),
+    };
+  }
+
+  calculateScore(checks) {
+    let s = 0;
+    if (checks.readme) s += 2;
+    if (checks.license) s += 2;
+    if (checks.contributing) s += 1.5;
+    if (checks.security) s += 1.5;
+    if (checks.codeOfConduct) s += 0.5;
+    if (checks.docsFolder) s += 1;
+    if (checks.workflows) s += 0.5;
+    if (checks.issueTemplate) s += 0.5;
+    if (checks.prTemplate) s += 0.5;
+    return Math.min(10, Math.round(s * 10) / 10);
+  }
+
+  getRating(score) {
+    if (score >= 9) return 'A+';
+    if (score >= 8) return 'A';
+    if (score >= 7) return 'B+';
+    if (score >= 6) return 'B';
+    if (score >= 5) return 'C+';
+    if (score >= 4) return 'C';
+    return 'F';
+  }
+
+  getSummary(checks) {
+    const present = [];
+    const missing = [];
+    [
+      ['readme', 'README'],
+      ['license', 'LICENSE'],
+      ['contributing', 'CONTRIBUTING'],
+      ['security', 'SECURITY.md'],
+      ['codeOfConduct', 'Code of Conduct'],
+      ['docsFolder', 'docs/'],
+      ['workflows', 'GitHub Actions'],
+      ['issueTemplate', 'Issue template'],
+      ['prTemplate', 'PR template'],
+    ].forEach(([key, label]) => {
+      if (checks[key]) present.push(label);
+      else missing.push(label);
+    });
+    return { present, missing };
+  }
+
+  getRecommendations(checks) {
+    const recs = [];
+    if (!checks.readme) recs.push({ priority: 'HIGH', title: 'Add a README', action: 'Create README.md with project overview, setup, and usage.' });
+    if (!checks.license) recs.push({ priority: 'HIGH', title: 'Add a LICENSE', action: 'Add a LICENSE file to clarify reuse and distribution terms.' });
+    if (!checks.contributing) recs.push({ priority: 'MEDIUM', title: 'Add CONTRIBUTING', action: 'Add CONTRIBUTING.md to guide contributors.' });
+    if (!checks.security) recs.push({ priority: 'MEDIUM', title: 'Add SECURITY.md', action: 'Document how to report security issues.' });
+    if (!checks.codeOfConduct) recs.push({ priority: 'LOW', title: 'Add Code of Conduct', action: 'Consider adding CODE_OF_CONDUCT.md for community guidelines.' });
+    if (!checks.docsFolder && checks.readme) recs.push({ priority: 'LOW', title: 'Add docs/ folder', action: 'Add a docs/ directory for detailed documentation.' });
+    if (!checks.issueTemplate) recs.push({ priority: 'LOW', title: 'Issue template', action: 'Add .github/ISSUE_TEMPLATE to standardize issue reports.' });
+    if (!checks.prTemplate) recs.push({ priority: 'LOW', title: 'PR template', action: 'Add .github/PULL_REQUEST_TEMPLATE.md for consistent PRs.' });
+    return recs;
+  }
+}
+
+export default DocumentationAnalyzer;