repo-wrapped 0.0.2

package/dist/utils/wrappedGenerator.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateYearWrapped = void 0;
+const child_process_1 = require("child_process");
+const achievementEngine_js_1 = require("./achievementEngine.js");
+const commitQualityAnalyzer_js_1 = require("./commitQualityAnalyzer.js");
+const fileHotspotAnalyzer_js_1 = require("./fileHotspotAnalyzer.js");
+const gitParser_js_1 = require("./gitParser.js");
+const streakCalculator_js_1 = require("./streakCalculator.js");
+const timePatternAnalyzer_js_1 = require("./timePatternAnalyzer.js");
+function generateYearWrapped(year, repoPath = '.', includeComparison = false) {
+    // Define year boundaries
+    const startDate = new Date(`${year}-01-01`);
+    const endDate = new Date(`${year}-12-31`);
+    // Fetch all commits for the year
+    const commits = (0, gitParser_js_1.parseGitCommits)(repoPath).filter(commit => {
+        const commitDate = new Date(commit.date);
+        return commitDate >= startDate && commitDate <= endDate;
+    });
+    if (commits.length === 0) {
+        throw new Error(`No commits found for year ${year}`);
+    }
+    // Calculate all metrics using existing utilities
+    const streakData = (0, streakCalculator_js_1.calculateStreaks)(commits, startDate, endDate);
+    const timePattern = (0, timePatternAnalyzer_js_1.analyzeTimePatterns)(commits, startDate, endDate);
+    const commitQuality = (0, commitQualityAnalyzer_js_1.analyzeCommitQuality)(commits);
+    const fileHotspots = (0, fileHotspotAnalyzer_js_1.analyzeFileHotspots)(repoPath, startDate, endDate);
+    // Create AnalysisData for achievement checking
+    const analysisData = {
+        commits,
+        totalCommits: commits.length,
+        streakData,
+        timePattern,
+        commitQuality,
+        fileHotspots,
+        dateRange: {
+            start: startDate,
+            end: endDate
+        }
+    };
+    const achievementProgress = (0, achievementEngine_js_1.checkAchievements)(analysisData);
+    // Calculate overview
+    const overview = {
+        totalCommits: commits.length,
+        activeDays: streakData.totalActiveDays,
+        totalDays: streakData.totalDays,
+        activePercentage: streakData.activeDayPercentage,
+        avgCommitsPerDay: commits.length / streakData.totalActiveDays
+    };
+    // Calculate impact (lines added/removed)
+    const impact = calculateImpact(commits, repoPath, year);
+    // Extract timing insights
+    const timing = {
+        chronotype: mapChronotype(timePattern.chronotype),
+        peakHour: timePattern.peakHour.hour,
+        peakDay: timePattern.peakDay.dayOfWeek,
+        mostProductiveMonth: findMostProductiveMonth(commits),
+        mostProductiveWeek: findMostProductiveWeek(commits)
+    };
+    // Extract streaks
+    const streaks = {
+        longest: {
+            days: streakData.longestStreak.days,
+            start: streakData.longestStreak.startDate,
+            end: streakData.longestStreak.endDate
+        },
+        current: {
+            days: streakData.currentStreak.days,
+            isActive: streakData.currentStreak.isActive
+        },
+        totalStreaks: streakData.streaks.length
+    };
+    // Extract quality metrics
+    const quality = {
+        overallScore: commitQuality.overallScore,
+        conventionalPercentage: commitQuality.conventionalCommits.adherence,
+        avgMessageLength: commitQuality.subjectQuality.avgLength,
+        withBody: commitQuality.bodyQuality.withBody
+    };
+    // Work distribution
+    const workDistribution = {
+        features: commitQuality.typeDistribution.features,
+        fixes: commitQuality.typeDistribution.fixes,
+        docs: commitQuality.typeDistribution.docs,
+        refactors: commitQuality.typeDistribution.refactors,
+        tests: commitQuality.typeDistribution.tests,
+        other: commitQuality.typeDistribution.chores + commitQuality.typeDistribution.other
+    };
+    // Collaboration
+    const collaboration = analyzeCollaboration(commits, repoPath);
+    // Achievements
+    const achievements = {
+        earned: achievementProgress.achievements
+            .filter(a => a.isUnlocked)
+            .map(a => a.name),
+        total: achievementProgress.unlockedCount
+    };
+    // Fun facts
+    const funFacts = findFunFacts(commits, timePattern);
+    // Get developer name
+    const developer = getDeveloperName(repoPath);
+    // Compare with previous year if requested
+    let comparison;
+    if (includeComparison) {
+        try {
+            comparison = compareWithPreviousYear(year, repoPath);
+        }
+        catch (error) {
+            // Previous year data not available
+            comparison = undefined;
+        }
+    }
+    return {
+        year,
+        developer,
+        overview,
+        impact,
+        timing,
+        streaks,
+        quality,
+        workDistribution,
+        collaboration,
+        achievements,
+        funFacts,
+        comparison
+    };
+}
+exports.generateYearWrapped = generateYearWrapped;
+function calculateImpact(commits, repoPath, year) {
+    try {
+        // Get git log with numstat for the year
+        const output = (0, child_process_1.execSync)(`git log --since="${year}-01-01" --until="${year}-12-31" --numstat --format="%H" --no-merges`, { cwd: repoPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        const filesChanged = new Set();
+        const fileChangeCount = {};
+        const lines = output.trim().split('\n');
+        for (const line of lines) {
+            if (line.match(/^[0-9a-f]{40}$/))
+                continue; // Skip commit hashes
+            if (line.trim() === '')
+                continue;
+            const parts = line.split('\t');
+            if (parts.length !== 3)
+                continue;
+            const [added, removed, file] = parts;
+            // Skip binary files
+            if (added === '-' || removed === '-')
+                continue;
+            linesAdded += parseInt(added, 10) || 0;
+            linesRemoved += parseInt(removed, 10) || 0;
+            filesChanged.add(file);
+            fileChangeCount[file] = (fileChangeCount[file] || 0) + 1;
+        }
+        // Get top 3 most changed files
+        const mostChangedFiles = Object.entries(fileChangeCount)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 3)
+            .map(([file]) => file);
+        return {
+            linesAdded,
+            linesRemoved,
+            netLines: linesAdded - linesRemoved,
+            filesChanged: filesChanged.size,
+            mostChangedFiles
+        };
+    }
+    catch (error) {
+        return {
+            linesAdded: 0,
+            linesRemoved: 0,
+            netLines: 0,
+            filesChanged: 0,
+            mostChangedFiles: []
+        };
+    }
+}
+function mapChronotype(type) {
+    const mapping = {
+        'early-bird': 'morning',
+        'balanced': 'day',
+        'night-owl': 'evening',
+        'vampire': 'night'
+    };
+    return mapping[type] || 'day';
+}
+function findMostProductiveMonth(commits) {
+    const monthCounts = {};
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    commits.forEach(commit => {
+        const date = new Date(commit.date);
+        const monthKey = months[date.getMonth()];
+        monthCounts[monthKey] = (monthCounts[monthKey] || 0) + 1;
+    });
+    const topMonth = Object.entries(monthCounts)
+        .sort(([, a], [, b]) => b - a)[0];
+    return topMonth ? topMonth[0] : 'Jan';
+}
+function findMostProductiveWeek(commits) {
+    if (commits.length === 0)
+        return new Date();
+    // Group commits by week
+    const weekCounts = {};
+    commits.forEach(commit => {
+        const date = new Date(commit.date);
+        const weekStart = getWeekStart(date);
+        const key = weekStart.toISOString().split('T')[0];
+        if (!weekCounts[key]) {
+            weekCounts[key] = { count: 0, date: weekStart };
+        }
+        weekCounts[key].count++;
+    });
+    const topWeek = Object.values(weekCounts)
+        .sort((a, b) => b.count - a.count)[0];
+    return topWeek ? topWeek.date : new Date(commits[0].date);
+}
+function getWeekStart(date) {
+    const d = new Date(date);
+    const day = d.getDay();
+    const diff = d.getDate() - day + (day === 0 ? -6 : 1); // Adjust for Monday start
+    return new Date(d.setDate(diff));
+}
+function analyzeCollaboration(commits, repoPath) {
+    const authors = new Set();
+    const authorDays = {};
+    commits.forEach(commit => {
+        authors.add(commit.author);
+        if (!authorDays[commit.author]) {
+            authorDays[commit.author] = new Set();
+        }
+        authorDays[commit.author].add(commit.date);
+    });
+    const currentUser = getDeveloperName(repoPath);
+    const otherAuthors = Array.from(authors).filter(a => a !== currentUser);
+    // Find top collaborator (most shared commit days)
+    let topCollaborator = null;
+    if (otherAuthors.length > 0 && authorDays[currentUser]) {
+        const userDays = authorDays[currentUser];
+        otherAuthors.forEach(author => {
+            const sharedDays = Array.from(authorDays[author] || [])
+                .filter(day => userDays.has(day)).length;
+            if (!topCollaborator || sharedDays > topCollaborator.sharedDays) {
+                topCollaborator = { name: author, sharedDays };
+            }
+        });
+    }
+    // Calculate solo percentage
+    const totalDays = authorDays[currentUser]?.size || 0;
+    const soloDays = Array.from(authorDays[currentUser] || []).filter(day => {
+        return otherAuthors.every(author => !authorDays[author]?.has(day));
+    }).length;
+    const soloPercentage = totalDays > 0 ? (soloDays / totalDays) * 100 : 100;
+    return {
+        uniqueContributors: otherAuthors.length,
+        topCollaborator,
+        soloPercentage
+    };
+}
+function findFunFacts(commits, timePattern) {
+    const holidayCommits = [];
+    let midnightCommits = 0;
+    let weekendCommits = 0;
+    const dayCommitCounts = {};
+    commits.forEach(commit => {
+        const date = new Date(commit.date);
+        const dayKey = commit.date;
+        dayCommitCounts[dayKey] = (dayCommitCounts[dayKey] || 0) + 1;
+        // Check for holidays
+        const month = date.getMonth() + 1;
+        const day = date.getDate();
+        if (month === 12 && day === 25)
+            holidayCommits.push('Christmas');
+        if (month === 1 && day === 1)
+            holidayCommits.push('New Year');
+        if (month === 7 && day === 4)
+            holidayCommits.push('Independence Day');
+        if (month === 10 && day === 31)
+            holidayCommits.push('Halloween');
+        // Weekend commits
+        const dayOfWeek = date.getDay();
+        if (dayOfWeek === 0 || dayOfWeek === 6) {
+            weekendCommits++;
+        }
+    });
+    // Count midnight commits from time pattern
+    if (timePattern.hourly) {
+        const midnight = timePattern.hourly.find((h) => h.hour === 0);
+        midnightCommits = midnight ? midnight.commitCount : 0;
+    }
+    // Find busiest day
+    const busiestDayEntry = Object.entries(dayCommitCounts)
+        .sort(([, a], [, b]) => b - a)[0];
+    const busiestDay = busiestDayEntry
+        ? { date: new Date(busiestDayEntry[0]), commits: busiestDayEntry[1] }
+        : null;
+    // Longest session from timePattern
+    const longestSession = timePattern.timingStats?.longestSession || null;
+    return {
+        holidayCommits: Array.from(new Set(holidayCommits)),
+        midnightCommits,
+        weekendCommits,
+        longestSession,
+        busiestDay
+    };
+}
+function getDeveloperName(repoPath) {
+    try {
+        const name = (0, child_process_1.execSync)('git config user.name', {
+            cwd: repoPath,
+            encoding: 'utf-8'
+        }).trim();
+        return name || 'Developer';
+    }
+    catch {
+        return 'Developer';
+    }
+}
+function compareWithPreviousYear(year, repoPath) {
+    // Generate wrapped for current and previous year
+    const currentYearData = generateYearWrapped(year, repoPath, false);
+    const previousYearData = generateYearWrapped(year - 1, repoPath, false);
+    // Extract stats
+    const currentStats = {
+        commits: currentYearData.overview.totalCommits,
+        streak: currentYearData.streaks.longest.days,
+        quality: currentYearData.quality.overallScore,
+        collaboration: currentYearData.collaboration.uniqueContributors
+    };
+    const previousStats = {
+        commits: previousYearData.overview.totalCommits,
+        streak: previousYearData.streaks.longest.days,
+        quality: previousYearData.quality.overallScore,
+        collaboration: previousYearData.collaboration.uniqueContributors
+    };
+    // Calculate changes
+    const calculateChange = (current, previous) => {
+        const value = current - previous;
+        const percentage = previous > 0 ? (value / previous) * 100 : 0;
+        let trend = 'stable';
+        if (Math.abs(percentage) >= 5) {
+            trend = value > 0 ? 'up' : 'down';
+        }
+        return { value, percentage, trend };
+    };
+    const changes = {
+        commits: calculateChange(currentStats.commits, previousStats.commits),
+        streak: calculateChange(currentStats.streak, previousStats.streak),
+        quality: calculateChange(currentStats.quality, previousStats.quality),
+        collaboration: calculateChange(currentStats.collaboration, previousStats.collaboration)
+    };
+    // Generate insights
+    const insights = [];
+    if (changes.commits.trend === 'up') {
+        insights.push(`${Math.abs(changes.commits.percentage).toFixed(0)}% more commits than last year!`);
+    }
+    else if (changes.commits.trend === 'down') {
+        insights.push('Fewer commits, but quality over quantity!');
+    }
+    if (changes.quality.trend === 'up') {
+        insights.push('Commit quality improved significantly! 📈');
+    }
+    if (changes.streak.trend === 'up') {
+        insights.push(`Streak improved by ${changes.streak.value} days!`);
+    }
+    if (changes.collaboration.trend === 'up') {
+        insights.push('Expanded collaboration network! 🤝');
+    }
+    if (insights.length === 0) {
+        insights.push('Consistent performance year over year!');
+    }
+    return {
+        currentYear: currentStats,
+        previousYear: previousStats,
+        changes,
+        insights
+    };
+}