repo-wrapped 0.0.6 → 0.0.9

package/dist/features/commit-quality/analyzer.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCommitQuality = analyzeCommitQuality;
+exports.getQualityRating = getQualityRating;
+exports.getQualityLevel = getQualityLevel;
+const analyzerContextBuilder_1 = require("../../utils/analyzerContextBuilder");
+const CONVENTIONAL_COMMIT_REGEX = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?!?:\s.+/;
+const CODE_HYGIENE_PATTERNS = {
+    quickFix: /fix(ed)?\s+(typo|spelling|grammar)/i,
+    workInProgress: /\bwip\b|work in progress/i,
+    oops: /oops|whoops|my bad/i,
+    profanity: /\b(damn|shit|fuck|crap)\b/i,
+    vague: /^(test|testing|fix|update|change|refactor)s?$/i,
+    singleChar: /^.$/
+};
+const ISSUE_PATTERNS = [
+    /#\d+/, // GitHub: #123
+    /[A-Z]+-\d+/, // JIRA: PROJ-123
+    /closes?\s+#\d+/i, // Closes #123
+    /fixes?\s+#\d+/i, // Fixes #123
+    /resolves?\s+#\d+/i // Resolves #123
+];
+const IMPERATIVE_STARTERS = [
+    'add', 'fix', 'update', 'remove', 'delete', 'create', 'implement', 'refactor',
+    'improve', 'optimize', 'enhance', 'change', 'move', 'rename', 'extract',
+    'merge', 'bump', 'revert', 'document', 'test', 'upgrade', 'downgrade'
+];
+function analyzeCommitQuality(ctxOrCommits, options = {}) {
+    // Normalize to internal variables
+    let commits;
+    let skipBodyCheck;
+    if ((0, analyzerContextBuilder_1.isAnalyzerContext)(ctxOrCommits)) {
+        commits = ctxOrCommits.commits;
+        skipBodyCheck = (0, analyzerContextBuilder_1.getOption)(ctxOrCommits, 'skipBodyCheck', false);
+    }
+    else {
+        commits = ctxOrCommits;
+        skipBodyCheck = options.skipBodyCheck ?? false;
+    }
+    if (commits.length === 0) {
+        return getEmptyQuality();
+    }
+    let totalSubjectLength = 0;
+    let tooShort = 0;
+    let tooLong = 0;
+    let withPeriod = 0;
+    let imperativeMood = 0;
+    let withBody = 0;
+    let totalBodyLength = 0;
+    let wellFormattedBody = 0;
+    let conventionalCount = 0;
+    let withIssueRef = 0;
+    let totalIssueRefs = 0;
+    const typeMap = new Map();
+    const scopeSet = new Set();
+    let breakingChanges = 0;
+    // Code hygiene metrics
+    let quickFix = 0;
+    let workInProgress = 0;
+    let oops = 0;
+    let profanity = 0;
+    let vague = 0;
+    let singleChar = 0;
+    commits.forEach(commit => {
+        const lines = commit.message.split('\n').map(l => l.trim()).filter(l => l);
+        const subject = lines[0] || '';
+        const body = lines.slice(1).join('\n').trim();
+        // Subject analysis
+        totalSubjectLength += subject.length;
+        if (subject.length < 10)
+            tooShort++;
+        if (subject.length > 72)
+            tooLong++;
+        if (subject.endsWith('.'))
+            withPeriod++;
+        if (startsWithImperative(subject))
+            imperativeMood++;
+        // Body analysis
+        if (body.length > 20) {
+            withBody++;
+            totalBodyLength += body.length;
+            if (isWellFormatted(body))
+                wellFormattedBody++;
+        }
+        // Conventional commits
+        const conventionalMatch = subject.match(CONVENTIONAL_COMMIT_REGEX);
+        if (conventionalMatch) {
+            conventionalCount++;
+            const type = conventionalMatch[1];
+            typeMap.set(type, (typeMap.get(type) || 0) + 1);
+            const scope = conventionalMatch[2];
+            if (scope) {
+                scopeSet.add(scope.replace(/[()]/g, ''));
+            }
+            if (conventionalMatch[0].includes('!') || body.toLowerCase().includes('breaking change')) {
+                breakingChanges++;
+            }
+        }
+        // Issue references
+        const issueRefs = countIssueReferences(commit.message);
+        if (issueRefs > 0) {
+            withIssueRef++;
+            totalIssueRefs += issueRefs;
+        }
+        // Code hygiene patterns
+        if (CODE_HYGIENE_PATTERNS.quickFix.test(commit.message))
+            quickFix++;
+        if (CODE_HYGIENE_PATTERNS.workInProgress.test(commit.message))
+            workInProgress++;
+        if (CODE_HYGIENE_PATTERNS.oops.test(commit.message))
+            oops++;
+        if (CODE_HYGIENE_PATTERNS.profanity.test(commit.message))
+            profanity++;
+        if (CODE_HYGIENE_PATTERNS.vague.test(subject))
+            vague++;
+        if (CODE_HYGIENE_PATTERNS.singleChar.test(subject))
+            singleChar++;
+    });
+    // Calculate scores
+    const avgSubjectLength = totalSubjectLength / commits.length;
+    const subjectScore = calculateSubjectScore(avgSubjectLength, tooShort, tooLong, withPeriod, imperativeMood, commits.length);
+    const avgBodyLength = withBody > 0 ? totalBodyLength / withBody : 0;
+    const bodyScore = skipBodyCheck ? 10 : calculateBodyScore(withBody, wellFormattedBody, commits.length);
+    const conventionAdherence = (conventionalCount / commits.length) * 100;
+    const conventionScore = (conventionAdherence / 10);
+    const issueRefScore = (withIssueRef / commits.length) * 10;
+    const overallScore = (subjectScore + bodyScore + conventionScore + issueRefScore) / 4;
+    // Type distribution
+    const typeDistribution = {
+        features: typeMap.get('feat') || 0,
+        fixes: typeMap.get('fix') || 0,
+        docs: typeMap.get('docs') || 0,
+        refactors: typeMap.get('refactor') || 0,
+        tests: typeMap.get('test') || 0,
+        chores: typeMap.get('chore') || 0,
+        other: commits.length - conventionalCount
+    };
+    // Generate improvements
+    const improvements = generateRecommendations({
+        totalCommits: commits.length,
+        withBody,
+        conventionAdherence,
+        tooLong,
+        withIssueRef,
+        typeDistribution,
+        skipBodyCheck
+    });
+    return {
+        overallScore,
+        totalCommits: commits.length,
+        subjectQuality: {
+            score: subjectScore,
+            avgLength: Math.round(avgSubjectLength),
+            tooShort,
+            tooLong,
+            withPeriod,
+            imperativeMood
+        },
+        bodyQuality: {
+            score: bodyScore,
+            withBody,
+            avgBodyLength: Math.round(avgBodyLength),
+            wellFormatted: wellFormattedBody
+        },
+        conventionalCommits: {
+            adherence: conventionAdherence,
+            types: Object.fromEntries(typeMap),
+            scopes: Array.from(scopeSet),
+            breakingChanges
+        },
+        issueReferences: {
+            withReferences: withIssueRef,
+            patterns: extractIssuePatterns(commits),
+            avgReferencesPerCommit: totalIssueRefs / commits.length
+        },
+        codeHygiene: {
+            quickFixes: quickFix,
+            workInProgress,
+            oops,
+            profanity,
+            vague,
+            singleChar
+        },
+        typeDistribution,
+        improvements
+    };
+}
+function startsWithImperative(subject) {
+    const firstWord = subject.toLowerCase().split(/[\s:(]/)[0];
+    // Check conventional commit prefix
+    if (CONVENTIONAL_COMMIT_REGEX.test(subject)) {
+        const afterColon = subject.split(':')[1]?.trim().toLowerCase();
+        if (afterColon) {
+            const afterColonFirstWord = afterColon.split(/[\s:(]/)[0];
+            return IMPERATIVE_STARTERS.includes(afterColonFirstWord);
+        }
+    }
+    return IMPERATIVE_STARTERS.includes(firstWord);
+}
+function isWellFormatted(body) {
+    const lines = body.split('\n');
+    // Check if most lines are under 80 characters
+    const longLines = lines.filter(l => l.length > 80).length;
+    const wellFormattedRatio = 1 - (longLines / lines.length);
+    // Check for proper paragraphs (blank lines between sections)
+    const hasProperParagraphs = body.includes('\n\n');
+    return wellFormattedRatio >= 0.8 || hasProperParagraphs;
+}
+function countIssueReferences(message) {
+    let count = 0;
+    ISSUE_PATTERNS.forEach(pattern => {
+        const matches = message.match(new RegExp(pattern, 'g'));
+        if (matches)
+            count += matches.length;
+    });
+    return count;
+}
+function extractIssuePatterns(commits) {
+    const patterns = new Set();
+    commits.forEach(commit => {
+        ISSUE_PATTERNS.forEach(pattern => {
+            const matches = commit.message.match(new RegExp(pattern, 'g'));
+            if (matches) {
+                matches.forEach(match => patterns.add(match));
+            }
+        });
+    });
+    return Array.from(patterns).slice(0, 10); // Return top 10 patterns
+}
+function calculateSubjectScore(avgLength, tooShort, tooLong, withPeriod, imperativeMood, total) {
+    let score = 10;
+    // Length penalty
+    if (avgLength < 20)
+        score -= 1;
+    if (avgLength > 60)
+        score -= 1;
+    // Too short/long penalty
+    const tooShortRatio = tooShort / total;
+    const tooLongRatio = tooLong / total;
+    score -= tooShortRatio * 2;
+    score -= tooLongRatio * 2;
+    // Period penalty
+    const periodRatio = withPeriod / total;
+    score -= periodRatio * 1;
+    // Imperative mood bonus
+    const imperativeRatio = imperativeMood / total;
+    if (imperativeRatio < 0.5)
+        score -= 2;
+    else if (imperativeRatio < 0.7)
+        score -= 1;
+    return Math.max(0, Math.min(10, score));
+}
+function calculateBodyScore(withBody, wellFormatted, total) {
+    const bodyRatio = withBody / total;
+    const formattedRatio = withBody > 0 ? wellFormatted / withBody : 0;
+    let score = 0;
+    // Body presence (up to 6 points)
+    score += bodyRatio * 6;
+    // Formatting quality (up to 4 points)
+    score += formattedRatio * 4;
+    return Math.max(0, Math.min(10, score));
+}
+function generateRecommendations(data) {
+    const tips = [];
+    // Body recommendations (skip if body check is disabled)
+    if (!data.skipBodyCheck) {
+        const bodyRatio = data.withBody / data.totalCommits;
+        if (bodyRatio < 0.3) {
+            tips.push('Add commit bodies to explain "why" not just "what"');
+        }
+        else if (bodyRatio < 0.5) {
+            tips.push('Try adding more detailed commit descriptions');
+        }
+    }
+    // Convention recommendations
+    if (data.conventionAdherence < 50) {
+        tips.push('Consider adopting Conventional Commits format');
+    }
+    else if (data.conventionAdherence < 70) {
+        tips.push('Increase conventional commit usage for better changelog generation');
+    }
+    // Length recommendations
+    if (data.tooLong > data.totalCommits * 0.1) {
+        tips.push('Keep subject lines under 72 characters');
+    }
+    // Issue reference recommendations
+    const issueRefRatio = data.withIssueRef / data.totalCommits;
+    if (issueRefRatio < 0.3) {
+        tips.push('Link commits to issues/tickets for better traceability');
+    }
+    // Test recommendations
+    const testRatio = data.typeDistribution.tests / data.totalCommits;
+    if (testRatio < 0.05) {
+        tips.push('Add more test commits - aim for 10-15% test coverage');
+    }
+    // Refactor recommendations
+    const refactorRatio = data.typeDistribution.refactors / data.totalCommits;
+    if (refactorRatio < 0.05) {
+        tips.push('Schedule regular refactoring - aim for 10-15% refactor commits');
+    }
+    // Balance recommendations
+    const featureFixRatio = data.typeDistribution.features / (data.typeDistribution.fixes || 1);
+    if (featureFixRatio > 3) {
+        tips.push('High feature/fix ratio - consider addressing technical debt');
+    }
+    return tips;
+}
+function getEmptyQuality() {
+    return {
+        overallScore: 0,
+        totalCommits: 0,
+        subjectQuality: {
+            score: 0,
+            avgLength: 0,
+            tooShort: 0,
+            tooLong: 0,
+            withPeriod: 0,
+            imperativeMood: 0
+        },
+        bodyQuality: {
+            score: 0,
+            withBody: 0,
+            avgBodyLength: 0,
+            wellFormatted: 0
+        },
+        conventionalCommits: {
+            adherence: 0,
+            types: {},
+            scopes: [],
+            breakingChanges: 0
+        },
+        issueReferences: {
+            withReferences: 0,
+            patterns: [],
+            avgReferencesPerCommit: 0
+        },
+        codeHygiene: {
+            quickFixes: 0,
+            workInProgress: 0,
+            oops: 0,
+            profanity: 0,
+            vague: 0,
+            singleChar: 0
+        },
+        typeDistribution: {
+            features: 0,
+            fixes: 0,
+            docs: 0,
+            refactors: 0,
+            tests: 0,
+            chores: 0,
+            other: 0
+        },
+        improvements: []
+    };
+}
+function getQualityRating(score) {
+    if (score >= 9)
+        return '⭐⭐⭐⭐⭐';
+    if (score >= 7.5)
+        return '⭐⭐⭐⭐';
+    if (score >= 6)
+        return '⭐⭐⭐';
+    if (score >= 4)
+        return '⭐⭐';
+    return '⭐';
+}
+function getQualityLevel(score) {
+    if (score >= 9)
+        return 'Excellent';
+    if (score >= 7.5)
+        return 'Good';
+    if (score >= 6)
+        return 'Fair';
+    if (score >= 4)
+        return 'Needs Improvement';
+    return 'Poor';
+}