repo-wrapped 0.0.2

package/dist/utils/commitQualityAnalyzer.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQualityLevel = exports.getQualityRating = exports.analyzeCommitQuality = void 0;
+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+/,
+    /[A-Z]+-\d+/,
+    /closes?\s+#\d+/i,
+    /fixes?\s+#\d+/i,
+    /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(commits, options = {}) {
+    const { skipBodyCheck = false } = options;
+    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
+    };
+}
+exports.analyzeCommitQuality = analyzeCommitQuality;
+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 '⭐';
+}
+exports.getQualityRating = getQualityRating;
+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';
+}
+exports.getQualityLevel = getQualityLevel;

package/dist/utils/fileHotspotAnalyzer.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwnershipIcon = exports.getRiskLevelColor = exports.analyzeFileHotspots = void 0;
+const child_process_1 = require("child_process");
+function analyzeFileHotspots(repoPath, startDate, endDate) {
+    try {
+        // Get file changes with author info from git log
+        const since = startDate.toISOString().split('T')[0];
+        const until = endDate.toISOString().split('T')[0];
+        let gitLog;
+        try {
+            gitLog = (0, child_process_1.execSync)(`git log --name-only --format="%H|%an|%ad" --date=short --since="${since}" --until="${until}"`, { cwd: repoPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }).trim();
+        }
+        catch (gitError) {
+            // Git command failed, likely not in a git repo or no commits in range
+            return getEmptyAnalysis();
+        }
+        if (!gitLog) {
+            return getEmptyAnalysis();
+        }
+        // Parse git log output
+        const fileMap = new Map();
+        const lines = gitLog.split('\n');
+        let currentCommit = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.includes('|')) {
+                // Commit header line
+                const [hash, author, date] = trimmed.split('|');
+                currentCommit = { hash, author, date };
+            }
+            else if (trimmed && currentCommit) {
+                // File path line
+                const filePath = trimmed;
+                // Skip binary files, lock files, and common generated files
+                if (shouldIgnoreFile(filePath)) {
+                    continue;
+                }
+                if (!fileMap.has(filePath)) {
+                    fileMap.set(filePath, {
+                        path: filePath,
+                        changeCount: 0,
+                        authors: [],
+                        authorDistribution: {},
+                        firstChange: new Date(currentCommit.date),
+                        lastChange: new Date(currentCommit.date),
+                        complexityScore: 0
+                    });
+                }
+                const fileStats = fileMap.get(filePath);
+                fileStats.changeCount++;
+                // Track authors
+                if (!fileStats.authors.includes(currentCommit.author)) {
+                    fileStats.authors.push(currentCommit.author);
+                }
+                fileStats.authorDistribution[currentCommit.author] =
+                    (fileStats.authorDistribution[currentCommit.author] || 0) + 1;
+                // Update dates
+                const commitDate = new Date(currentCommit.date);
+                if (commitDate < fileStats.firstChange) {
+                    fileStats.firstChange = commitDate;
+                }
+                if (commitDate > fileStats.lastChange) {
+                    fileStats.lastChange = commitDate;
+                }
+            }
+        }
+        // Calculate complexity scores
+        for (const fileStats of fileMap.values()) {
+            fileStats.complexityScore = calculateComplexityScore(fileStats);
+        }
+        // Get top files
+        const topFiles = Array.from(fileMap.values())
+            .sort((a, b) => b.changeCount - a.changeCount)
+            .slice(0, 20);
+        // Analyze directories
+        const topDirectories = analyzeDirectories(fileMap);
+        // Identify technical debt
+        const technicalDebt = identifyTechnicalDebt(Array.from(fileMap.values()));
+        // Analyze ownership risks
+        const ownershipRisks = analyzeOwnership(Array.from(fileMap.values()));
+        return {
+            topFiles,
+            topDirectories,
+            technicalDebt,
+            ownershipRisks,
+            totalFilesAnalyzed: fileMap.size
+        };
+    }
+    catch (error) {
+        console.error('Error analyzing file hotspots:', error);
+        return getEmptyAnalysis();
+    }
+}
+exports.analyzeFileHotspots = analyzeFileHotspots;
+function shouldIgnoreFile(path) {
+    const ignoredExtensions = ['.lock', '.log', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
+    const ignoredPatterns = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'node_modules/', 'dist/', 'build/', '.next/', 'coverage/'];
+    // Check extensions
+    if (ignoredExtensions.some(ext => path.toLowerCase().endsWith(ext))) {
+        return true;
+    }
+    // Check patterns
+    if (ignoredPatterns.some(pattern => path.includes(pattern))) {
+        return true;
+    }
+    return false;
+}
+function calculateComplexityScore(fileStats) {
+    let score = 0;
+    // High churn
+    if (fileStats.changeCount > 100)
+        score += 3;
+    else if (fileStats.changeCount > 50)
+        score += 2;
+    else if (fileStats.changeCount > 25)
+        score += 1;
+    // Many authors
+    if (fileStats.authors.length > 10)
+        score += 2;
+    else if (fileStats.authors.length > 5)
+        score += 1;
+    // Time since last change (older = potentially more stable, but also potentially abandoned)
+    const daysSinceLastChange = Math.floor((Date.now() - fileStats.lastChange.getTime()) / (1000 * 60 * 60 * 24));
+    if (daysSinceLastChange > 180)
+        score += 1; // No changes in 6 months
+    return Math.min(10, score);
+}
+function analyzeDirectories(fileMap) {
+    const dirMap = new Map();
+    // Group files by directory
+    for (const file of fileMap.values()) {
+        const dirPath = file.path.includes('/')
+            ? file.path.substring(0, file.path.lastIndexOf('/'))
+            : '.';
+        if (!dirMap.has(dirPath)) {
+            dirMap.set(dirPath, { files: [], totalChanges: 0 });
+        }
+        const dirStats = dirMap.get(dirPath);
+        dirStats.files.push(file);
+        dirStats.totalChanges += file.changeCount;
+    }
+    // Create directory stats
+    const directories = [];
+    for (const [path, data] of dirMap) {
+        const mostActive = data.files.sort((a, b) => b.changeCount - a.changeCount)[0];
+        directories.push({
+            path,
+            totalChanges: data.totalChanges,
+            fileCount: data.files.length,
+            avgChangesPerFile: data.totalChanges / data.files.length,
+            mostActiveFile: mostActive.path
+        });
+    }
+    return directories
+        .sort((a, b) => b.totalChanges - a.totalChanges)
+        .slice(0, 10);
+}
+function identifyTechnicalDebt(files) {
+    const debtFiles = [];
+    for (const file of files) {
+        const score = file.complexityScore;
+        // Only flag files with complexity score >= 4
+        if (score < 4)
+            continue;
+        let riskLevel = 'low';
+        if (score >= 8)
+            riskLevel = 'critical';
+        else if (score >= 6)
+            riskLevel = 'high';
+        else if (score >= 4)
+            riskLevel = 'medium';
+        const recommendations = [];
+        if (file.changeCount > 50) {
+            recommendations.push('High change frequency - consider refactoring for stability');
+        }
+        if (file.authors.length > 8) {
+            recommendations.push('Many different authors - ensure clear ownership');
+        }
+        const daysSinceLastChange = Math.floor((Date.now() - file.lastChange.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysSinceLastChange > 180) {
+            recommendations.push('No recent changes - may be stable or abandoned');
+        }
+        debtFiles.push({
+            file: file.path,
+            riskLevel,
+            changeCount: file.changeCount,
+            authorCount: file.authors.length,
+            lastModified: file.lastChange,
+            score,
+            recommendations
+        });
+    }
+    return debtFiles.sort((a, b) => b.score - a.score).slice(0, 10);
+}
+function analyzeOwnership(files) {
+    const ownershipData = [];
+    for (const file of files) {
+        // Only analyze files with multiple commits
+        if (file.changeCount < 3)
+            continue;
+        // Calculate owner percentages
+        const owners = Object.entries(file.authorDistribution)
+            .map(([author, commits]) => ({
+            author,
+            commits,
+            percentage: (commits / file.changeCount) * 100
+        }))
+            .sort((a, b) => b.commits - a.commits)
+            .slice(0, 5); // Top 5 contributors
+        // Determine ownership type
+        let ownershipType = 'collaborative';
+        let busFactorRisk = 0;
+        if (owners.length === 1 || owners[0].percentage >= 90) {
+            ownershipType = 'single-owner';
+            busFactorRisk = 9;
+        }
+        else if (owners[0].percentage >= 70) {
+            ownershipType = 'single-owner';
+            busFactorRisk = 7;
+        }
+        else if (owners[0].percentage >= 50) {
+            ownershipType = 'shared';
+            busFactorRisk = 4;
+        }
+        else {
+            ownershipType = 'collaborative';
+            busFactorRisk = 2;
+        }
+        ownershipData.push({
+            file: file.path,
+            owners,
+            ownershipType,
+            busFactorRisk
+        });
+    }
+    // Return files with ownership risks
+    return ownershipData
+        .filter(o => o.busFactorRisk >= 7)
+        .sort((a, b) => b.busFactorRisk - a.busFactorRisk)
+        .slice(0, 10);
+}
+function getEmptyAnalysis() {
+    return {
+        topFiles: [],
+        topDirectories: [],
+        technicalDebt: [],
+        ownershipRisks: [],
+        totalFilesAnalyzed: 0
+    };
+}
+function getRiskLevelColor(level) {
+    switch (level) {
+        case 'critical': return '🔴';
+        case 'high': return '🟠';
+        case 'medium': return '🟡';
+        case 'low': return '🟢';
+        default: return '⚪';
+    }
+}
+exports.getRiskLevelColor = getRiskLevelColor;
+function getOwnershipIcon(type) {
+    switch (type) {
+        case 'single-owner': return '🔴';
+        case 'shared': return '🟡';
+        case 'collaborative': return '🟢';
+        default: return '⚪';
+    }
+}
+exports.getOwnershipIcon = getOwnershipIcon;