git-repo-analyzer-test 1.0.0

package/src/analyzers/quality-enhanced.js

@@ -0,0 +1,386 @@
+/**
+ * Enhanced Code Quality Analyzer
+ * Provides detailed insights on code quality metrics against standards
+ */
+export class CodeQualityAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Comprehensive code quality analysis
+   */
+  async analyzeCodeQuality(owner, repo) {
+    try {
+      const [repoData, languages, commits] = await Promise.all([
+        this.client.getRepository(owner, repo),
+        this.client.getLanguages(owner, repo),
+        this.client.getCommits(owner, repo, { perPage: 100 }),
+      ]);
+
+      const issues = this.identifyCodeQualityIssues(repoData, languages);
+      const score = this.calculateQualityScore(repoData, issues);
+      const rating = this.getRating(score);
+
+      return {
+        score,
+        rating,
+        metrics: {
+          stars: repoData.stargazers_count || 0,
+          forks: repoData.forks_count || 0,
+          watchers: repoData.watchers_count || 0,
+          openIssues: repoData.open_issues_count || 0,
+          hasWiki: repoData.has_wiki,
+          hasPages: repoData.has_pages,
+          languages: Object.keys(languages).length,
+          primaryLanguage: repoData.language,
+          lastUpdate: repoData.updated_at,
+          daysInactive: this.getDaysSinceUpdate(repoData.updated_at),
+          description: repoData.description,
+          topics: repoData.topics || [],
+          license: repoData.license?.name || 'None',
+          isArchived: repoData.archived,
+          size: repoData.size,
+        },
+        issues,
+        recommendations: this.generateQualityRecommendations(issues),
+        details: {
+          codeStandards: this.analyzeCodeStandards(repoData, languages),
+          libraryAudit: this.auditLibraries(repoData),
+          documentationQuality: this.assessDocumentation(repoData),
+          maintenanceStatus: this.assessMaintenanceStatus(repoData, commits),
+        },
+      };
+    } catch (error) {
+      throw new Error(`Code quality analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Identify specific code quality issues
+   */
+  identifyCodeQualityIssues(repoData, languages) {
+    const issues = [];
+
+    // Issue 1: Outdated or archived repository
+    if (repoData.archived) {
+      issues.push({
+        type: 'ARCHIVED_REPOSITORY',
+        severity: 'HIGH',
+        message: 'Repository is archived and no longer maintained',
+        location: 'Repository Status',
+        impact: 'No updates or security patches expected',
+        recommendation: 'Consider using an actively maintained fork or alternative',
+      });
+    }
+
+    // Issue 2: No license
+    if (!repoData.license) {
+      issues.push({
+        type: 'NO_LICENSE',
+        severity: 'MEDIUM',
+        message: 'Repository has no license defined',
+        location: 'LICENSE file',
+        impact: 'Legal and usage clarity issues for contributors',
+        recommendation: 'Add a LICENSE file (MIT, Apache 2.0, GPL, etc.)',
+      });
+    }
+
+    // Issue 3: Stale repository (>1 year inactive)
+    const daysSinceUpdate = this.getDaysSinceUpdate(repoData.updated_at);
+    if (daysSinceUpdate > 365) {
+      issues.push({
+        type: 'STALE_CODEBASE',
+        severity: 'MEDIUM',
+        message: `Repository not updated for ${daysSinceUpdate} days`,
+        location: 'Last commit/update',
+        impact: 'Potential security vulnerabilities, outdated dependencies',
+        recommendation: 'Regular maintenance and dependency updates needed',
+      });
+    }
+
+    // Issue 4: High number of open issues
+    if (repoData.open_issues_count > 100) {
+      issues.push({
+        type: 'UNRESOLVED_ISSUES',
+        severity: 'MEDIUM',
+        message: `${repoData.open_issues_count} open issues`,
+        location: 'Issues tracker',
+        impact: 'Code quality concerns, bug backlog',
+        recommendation: 'Implement issue triage and prioritization strategy',
+      });
+    }
+
+    // Issue 5: Lack of documentation
+    if (!repoData.has_wiki && !repoData.has_pages && !repoData.description) {
+      issues.push({
+        type: 'POOR_DOCUMENTATION',
+        severity: 'MEDIUM',
+        message: 'Insufficient documentation for code clarity',
+        location: 'README, Wiki, GitHub Pages',
+        impact: 'Hard to understand code purpose and usage',
+        recommendation: 'Add comprehensive README.md, API documentation, examples',
+      });
+    }
+
+    // Issue 6: Too many languages (indicates scattered codebase)
+    const languageCount = Object.keys(languages).length;
+    if (languageCount > 8) {
+      issues.push({
+        type: 'EXCESSIVE_LANGUAGES',
+        severity: 'LOW',
+        message: `Using ${languageCount} different programming languages`,
+        location: 'Various file types across repo',
+        impact: 'Maintenance complexity, inconsistent code standards',
+        recommendation: 'Consider consolidating to core languages only',
+      });
+    }
+
+    // Issue 7: No primary language detected
+    if (!repoData.language) {
+      issues.push({
+        type: 'NO_PRIMARY_LANGUAGE',
+        severity: 'LOW',
+        message: 'No primary programming language identified',
+        location: 'Repository structure',
+        impact: 'Unclear project type and technical stack',
+        recommendation: 'Ensure majority of code is in a single language',
+      });
+    }
+
+    // Issue 8: Large repository (code smell)
+    if (repoData.size > 500000) {
+      issues.push({
+        type: 'LARGE_REPOSITORY',
+        severity: 'LOW',
+        message: `Repository size is ${Math.round(repoData.size / 1024)} MB`,
+        location: 'Overall repository',
+        impact: 'Slow clone times, harder to navigate',
+        recommendation: 'Consider splitting into multiple repositories or removing artifacts',
+      });
+    }
+
+    return issues;
+  }
+
+  /**
+   * Analyze code standards compliance
+   */
+  analyzeCodeStandards(repoData, languages) {
+    const languageList = Object.keys(languages);
+    const standards = {
+      hasLinter: this.hasLinterConfiguration(repoData),
+      hasFormatter: this.hasFormatterConfiguration(repoData),
+      hasTests: this.hasTestSetup(repoData),
+      hasBuildProcess: this.hasBuildConfiguration(repoData),
+      hasCICD: this.hasCICDConfiguration(repoData),
+      primaryLanguages: languageList.slice(0, 3),
+      languageDetails: this.getLanguageDetails(languageList),
+    };
+    return standards;
+  }
+
+  /**
+   * Audit dependencies and libraries
+   */
+  auditLibraries(repoData) {
+    const hasPackageJson = repoData.topics?.includes('npm') || 
+                          repoData.language === 'JavaScript' ||
+                          repoData.language === 'TypeScript';
+    const hasPyproject = repoData.topics?.includes('python') || 
+                        repoData.language === 'Python';
+    const hasGemfile = repoData.language === 'Ruby';
+
+    return {
+      dependencyManagement: {
+        npm: hasPackageJson,
+        python: hasPyproject,
+        ruby: hasGemfile,
+        other: !hasPackageJson && !hasPyproject && !hasGemfile,
+      },
+      recommendations: [
+        'Regular dependency updates recommended',
+        'Use dependency scanning tools (npm audit, pip-audit)',
+        'Keep frameworks and libraries up to date',
+        'Monitor security advisories for used libraries',
+      ],
+    };
+  }
+
+  /**
+   * Assess documentation quality
+   */
+  assessDocumentation(repoData) {
+    const score = {
+      readme: repoData.description ? 2 : 0,
+      wiki: repoData.has_wiki ? 2 : 0,
+      pages: repoData.has_pages ? 2 : 0,
+      license: repoData.license ? 2 : 0,
+      changelog: 0, // Would need file scanning
+      contributing: 0, // Would need file scanning
+    };
+    const total = Object.values(score).reduce((a, b) => a + b, 0);
+    return {
+      score: total,
+      maxScore: 12,
+      percentage: Math.round((total / 12) * 100),
+      details: score,
+    };
+  }
+
+  /**
+   * Assess repository maintenance status
+   */
+  assessMaintenanceStatus(repoData, commits) {
+    const daysSinceUpdate = this.getDaysSinceUpdate(repoData.updated_at);
+    let status = 'ACTIVE';
+    let points = 10;
+
+    if (daysSinceUpdate > 365) {
+      status = 'INACTIVE';
+      points = 2;
+    } else if (daysSinceUpdate > 180) {
+      status = 'DORMANT';
+      points = 4;
+    } else if (daysSinceUpdate > 30) {
+      status = 'MODERATE';
+      points = 7;
+    }
+
+    return {
+      status,
+      points,
+      daysSinceUpdate,
+      commitFrequency: commits.length > 0 ? 'Active' : 'None',
+      recommendations:
+        status === 'ACTIVE'
+          ? ['Maintain current update frequency']
+          : ['Resume active maintenance', 'Update dependencies', 'Address open issues'],
+    };
+  }
+
+  /**
+   * Helper: Get days since last update
+   */
+  getDaysSinceUpdate(lastUpdate) {
+    const lastUpdateDate = new Date(lastUpdate);
+    const daysSince = Math.floor((new Date() - lastUpdateDate) / (1000 * 60 * 60 * 24));
+    return daysSince;
+  }
+
+  /**
+   * Helper: Check for linter configuration
+   */
+  hasLinterConfiguration(repoData) {
+    return repoData.topics?.some((t) =>
+      ['eslint', 'pylint', 'rubocop', 'prettier'].includes(t)
+    );
+  }
+
+  /**
+   * Helper: Check for formatter configuration
+   */
+  hasFormatterConfiguration(repoData) {
+    return repoData.topics?.some((t) =>
+      ['prettier', 'black', 'rustfmt'].includes(t)
+    );
+  }
+
+  /**
+   * Helper: Check for test setup
+   */
+  hasTestSetup(repoData) {
+    return repoData.topics?.some((t) =>
+      ['testing', 'jest', 'pytest', 'rspec', 'vitest'].includes(t)
+    );
+  }
+
+  /**
+   * Helper: Check for build configuration
+   */
+  hasBuildConfiguration(repoData) {
+    return repoData.topics?.some((t) =>
+      ['webpack', 'gradle', 'maven', 'cargo', 'rust'].includes(t)
+    );
+  }
+
+  /**
+   * Helper: Check for CI/CD configuration
+   */
+  hasCICDConfiguration(repoData) {
+    return repoData.topics?.some((t) =>
+      ['github-actions', 'ci', 'cd', 'travis', 'gitlab-ci'].includes(t)
+    );
+  }
+
+  /**
+   * Helper: Get language details
+   */
+  getLanguageDetails(languages) {
+    const languageMap = {
+      JavaScript: 'Dynamic, web-focused',
+      TypeScript: 'Typed JavaScript, enterprise',
+      Python: 'Scripting, data science, automation',
+      Java: 'Enterprise, large-scale systems',
+      Go: 'Concurrent, cloud-native',
+      Rust: 'Systems, performance-critical',
+      'C++': 'Performance, systems programming',
+      'C#': 'Enterprise, .NET ecosystem',
+      Ruby: 'Rapid development, web frameworks',
+      PHP: 'Web backend, rapid deployment',
+    };
+    return languages.map((lang) => ({
+      language: lang,
+      description: languageMap[lang] || 'General purpose',
+    }));
+  }
+
+  /**
+   * Calculate quality score
+   */
+  calculateQualityScore(repoData, issues) {
+    let score = 100;
+
+    // Deduct points for issues
+    issues.forEach((issue) => {
+      if (issue.severity === 'HIGH') score -= 20;
+      else if (issue.severity === 'MEDIUM') score -= 10;
+      else if (issue.severity === 'LOW') score -= 3;
+    });
+
+    // Add bonus points for good practices
+    if (repoData.has_wiki) score += 2;
+    if (repoData.has_pages) score += 2;
+    if (repoData.license) score += 3;
+    if (repoData.stargazers_count > 1000) score += 5;
+
+    return Math.max(0, Math.min(100, score));
+  }
+
+  /**
+   * Generate recommendations
+   */
+  generateQualityRecommendations(issues) {
+    return issues.map((issue) => ({
+      priority: issue.severity,
+      issue: issue.message,
+      location: issue.location,
+      action: issue.recommendation,
+    }));
+  }
+
+  /**
+   * 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 CodeQualityAnalyzer;

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

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

package/src/analyzers/quality.js

@@ -0,0 +1,92 @@
+import { GitHubClient } from '../github/client.js';
+
+export class QualityAnalyzer {
+  constructor(githubClient) {
+    this.client = githubClient;
+  }
+
+  /**
+   * Analyze code quality metrics
+   */
+  async analyzeCodeQuality(owner, repo) {
+    if (!owner || !repo) {
+      throw new Error('Owner and repo are required');
+    }
+
+    try {
+      console.info(`Analyzing repo: ${owner}/${repo}`);
+
+      const [repoData, languages] = await Promise.all([
+        this.client.getRepository(owner, repo),
+        this.client.getLanguages(owner, repo),
+      ]);
+
+      const daysInactive = repoData.pushed_at
+          ? Math.floor((Date.now() - new Date(repoData.pushed_at)) / (1000 * 60 * 60 * 24))
+          : null;
+
+      return {
+        score: this.calculateQualityScore(repoData),
+        metrics: {
+          stars: repoData.stargazers_count || 0,
+          forks: repoData.forks_count || 0,
+          watchers: repoData.watchers_count || 0,
+          openIssues: repoData.open_issues_count || 0,
+          hasWiki: repoData.has_wiki || false,
+          hasPages: repoData.has_pages || false,
+          languageCount: languages ? Object.keys(languages).length : 0,
+          primaryLanguage: repoData.language,
+          lastUpdate: repoData.updated_at,
+          daysInactive,
+          description: repoData.description,
+          topics: repoData.topics || [],
+        },
+      };
+
+    } catch (error) {
+      console.error('QualityAnalyzer Error:', error);
+      throw error;
+    }
+  }
+  /**
+   * Calculate overall quality score (0-100)
+   */
+  calculateQualityScore(repoData) {
+    let score = 50; // Base score
+
+    // Stars contribution (0-15)
+    score += Math.min(repoData.stargazers_count / 1000, 15);
+
+    // Forks contribution (0-10)
+    score += Math.min(repoData.forks_count / 500, 10);
+
+    // Issues contribution (0-10)
+    const issueScore = Math.max(10 - repoData.open_issues_count / 100, 0);
+    score += issueScore;
+
+    // Documentation (0-10)
+    if (repoData.has_wiki || repoData.description) {
+      score += 5;
+    }
+    if (repoData.has_pages) {
+      score += 5;
+    }
+
+    // Activity (0-10)
+    const lastUpdate = new Date(repoData.updated_at);
+    const daysSinceUpdate = Math.floor(
+      (new Date() - lastUpdate) / (1000 * 60 * 60 * 24)
+    );
+    if (daysSinceUpdate < 30) {
+      score += 10;
+    } else if (daysSinceUpdate < 90) {
+      score += 7;
+    } else if (daysSinceUpdate < 365) {
+      score += 3;
+    }
+
+    return Math.min(Math.round(score), 100);
+  }
+}
+
+export default QualityAnalyzer;

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

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