repo-wrapped 0.0.2

package/dist/utils/streakCalculator.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreakMotivation = exports.calculateStreaks = void 0;
+const date_fns_1 = require("date-fns");
+function calculateStreaks(commits, startDate, endDate) {
+    // Create set of unique commit dates
+    const commitDates = new Set();
+    commits.forEach(commit => {
+        const commitDate = new Date(commit.date);
+        if (commitDate >= startDate && commitDate <= endDate) {
+            commitDates.add((0, date_fns_1.format)(commitDate, 'yyyy-MM-dd'));
+        }
+    });
+    // Calculate total days and active days
+    const totalDays = (0, date_fns_1.differenceInDays)(endDate, startDate) + 1;
+    const totalActiveDays = commitDates.size;
+    const activeDayPercentage = totalDays > 0 ? (totalActiveDays / totalDays) * 100 : 0;
+    // Find all streaks
+    const streaks = [];
+    let currentStreakDays = 0;
+    let currentStreakStart = null;
+    const allDays = (0, date_fns_1.eachDayOfInterval)({ start: startDate, end: endDate });
+    for (const date of allDays) {
+        const dateKey = (0, date_fns_1.format)(date, 'yyyy-MM-dd');
+        if (commitDates.has(dateKey)) {
+            if (currentStreakDays === 0) {
+                currentStreakStart = date;
+            }
+            currentStreakDays++;
+        }
+        else {
+            if (currentStreakDays > 0 && currentStreakStart) {
+                streaks.push({
+                    days: currentStreakDays,
+                    startDate: currentStreakStart,
+                    endDate: (0, date_fns_1.subDays)(date, 1)
+                });
+                currentStreakDays = 0;
+                currentStreakStart = null;
+            }
+        }
+    }
+    // Handle streak that extends to end date
+    if (currentStreakDays > 0 && currentStreakStart) {
+        streaks.push({
+            days: currentStreakDays,
+            startDate: currentStreakStart,
+            endDate: endDate
+        });
+    }
+    // Find longest streak
+    const longestStreak = streaks.length > 0
+        ? streaks.reduce((longest, current) => current.days > longest.days ? current : longest)
+        : { days: 0, startDate: startDate, endDate: startDate };
+    // Determine current streak (from today or most recent commit going backward)
+    const today = new Date();
+    const todayKey = (0, date_fns_1.format)(today, 'yyyy-MM-dd');
+    let currentStreak;
+    if (commitDates.has(todayKey)) {
+        // Today has a commit, find streak from today backward
+        let streakDays = 0;
+        let checkDate = today;
+        while (commitDates.has((0, date_fns_1.format)(checkDate, 'yyyy-MM-dd'))) {
+            streakDays++;
+            checkDate = (0, date_fns_1.subDays)(checkDate, 1);
+            if (checkDate < startDate)
+                break;
+        }
+        currentStreak = {
+            days: streakDays,
+            startDate: (0, date_fns_1.subDays)(today, streakDays - 1),
+            endDate: today,
+            isActive: true
+        };
+    }
+    else {
+        // No commit today, check if yesterday had commit (streak just broke)
+        const yesterday = (0, date_fns_1.subDays)(today, 1);
+        const yesterdayKey = (0, date_fns_1.format)(yesterday, 'yyyy-MM-dd');
+        if (commitDates.has(yesterdayKey)) {
+            let streakDays = 0;
+            let checkDate = yesterday;
+            while (commitDates.has((0, date_fns_1.format)(checkDate, 'yyyy-MM-dd'))) {
+                streakDays++;
+                checkDate = (0, date_fns_1.subDays)(checkDate, 1);
+                if (checkDate < startDate)
+                    break;
+            }
+            currentStreak = {
+                days: streakDays,
+                startDate: (0, date_fns_1.subDays)(yesterday, streakDays - 1),
+                endDate: yesterday,
+                isActive: false
+            };
+        }
+        else {
+            // No recent streak
+            currentStreak = {
+                days: 0,
+                startDate: today,
+                endDate: today,
+                isActive: false
+            };
+        }
+    }
+    return {
+        currentStreak,
+        longestStreak,
+        totalActiveDays,
+        totalDays,
+        activeDayPercentage,
+        streaks
+    };
+}
+exports.calculateStreaks = calculateStreaks;
+function getStreakMotivation(days, isActive) {
+    if (days === 0) {
+        return "Start building momentum today";
+    }
+    if (!isActive) {
+        return `Your ${days}-day streak ended. Time for a fresh start.`;
+    }
+    if (days >= 61)
+        return "Outstanding consistency";
+    if (days >= 31)
+        return "Exceptional dedication";
+    if (days >= 15)
+        return "Strong momentum 🔥";
+    if (days >= 8)
+        return "Solid consistency";
+    if (days >= 4)
+        return "Building momentum";
+    return "Just getting started";
+}
+exports.getStreakMotivation = getStreakMotivation;

package/dist/utils/timePatternAnalyzer.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChronotypeDescription = exports.getChronotypeLabel = exports.analyzeTimePatterns = void 0;
+const date_fns_1 = require("date-fns");
+function analyzeTimePatterns(commits, startDate, endDate) {
+    if (commits.length === 0) {
+        return getEmptyPattern();
+    }
+    // Filter commits within the date range
+    const filteredCommits = commits.filter(c => {
+        const commitDate = new Date(c.date);
+        return commitDate >= startDate && commitDate <= endDate;
+    });
+    if (filteredCommits.length === 0) {
+        return getEmptyPattern();
+    }
+    // 1. Hourly distribution
+    const hourlyMap = new Map();
+    for (let i = 0; i < 24; i++) {
+        hourlyMap.set(i, 0);
+    }
+    filteredCommits.forEach(commit => {
+        const hour = (0, date_fns_1.getHours)(new Date(commit.date));
+        hourlyMap.set(hour, (hourlyMap.get(hour) || 0) + 1);
+    });
+    const hourly = Array.from(hourlyMap.entries()).map(([hour, count]) => ({
+        hour,
+        commitCount: count,
+        percentage: (count / filteredCommits.length) * 100
+    }));
+    // 2. Daily distribution (day of week)
+    const dayMap = new Map();
+    for (let i = 0; i < 7; i++) {
+        dayMap.set(i, []);
+    }
+    filteredCommits.forEach(commit => {
+        const dayIndex = (0, date_fns_1.getDay)(new Date(commit.date));
+        dayMap.get(dayIndex).push(1);
+    });
+    const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    const dailyAverage = Array.from(dayMap.entries()).map(([dayIndex, commits]) => ({
+        dayOfWeek: dayNames[dayIndex],
+        commitCount: commits.length,
+        avgCommitsPerDay: commits.length / Math.ceil((endDate.getTime() - startDate.getTime()) / (7 * 24 * 60 * 60 * 1000))
+    }));
+    // 3. Peak hour
+    const peakHourEntry = hourly.reduce((max, curr) => curr.commitCount > max.commitCount ? curr : max);
+    const peakHour = {
+        hour: peakHourEntry.hour,
+        commitCount: peakHourEntry.commitCount
+    };
+    // 4. Peak day
+    const peakDayEntry = dailyAverage.reduce((max, curr) => curr.commitCount > max.commitCount ? curr : max);
+    const peakDay = {
+        dayOfWeek: peakDayEntry.dayOfWeek,
+        avgCommits: peakDayEntry.avgCommitsPerDay
+    };
+    // 5. Chronotype detection
+    const chronotypeData = getChronotype(hourly);
+    // 6. Work-life balance
+    const workLifeBalance = calculateWorkLifeBalance(dailyAverage);
+    // 7. Timing stats
+    const timingStats = calculateTimingStats(filteredCommits);
+    // 8. Burnout risk
+    const burnoutRisk = detectBurnoutRisk(hourly, dailyAverage, filteredCommits);
+    // 9. Consistency score
+    const consistency = calculateConsistency(filteredCommits);
+    return {
+        hourly,
+        dailyAverage,
+        chronotype: chronotypeData.type,
+        chronotypeConfidence: chronotypeData.confidence,
+        peakHour,
+        peakDay,
+        workLifeBalance,
+        timingStats,
+        burnoutRisk,
+        consistency
+    };
+}
+exports.analyzeTimePatterns = analyzeTimePatterns;
+function getChronotype(hourly) {
+    const totalCommits = hourly.reduce((sum, h) => sum + h.commitCount, 0);
+    if (totalCommits === 0) {
+        return { type: 'balanced', confidence: 0 };
+    }
+    // Calculate time period percentages
+    const morningCommits = hourly.filter(h => h.hour >= 6 && h.hour < 12).reduce((sum, h) => sum + h.commitCount, 0);
+    const eveningCommits = hourly.filter(h => h.hour >= 18 && h.hour < 24).reduce((sum, h) => sum + h.commitCount, 0);
+    const nightCommits = hourly.filter(h => h.hour >= 0 && h.hour < 6).reduce((sum, h) => sum + h.commitCount, 0);
+    const morningPct = (morningCommits / totalCommits) * 100;
+    const eveningPct = (eveningCommits / totalCommits) * 100;
+    const nightPct = (nightCommits / totalCommits) * 100;
+    // Vampire: 30%+ commits between midnight-6am
+    if (nightPct >= 30) {
+        return { type: 'vampire', confidence: nightPct };
+    }
+    // Early Bird: 60%+ commits before 12pm
+    if (morningPct >= 60) {
+        return { type: 'early-bird', confidence: morningPct };
+    }
+    // Night Owl: 60%+ commits after 6pm
+    if (eveningPct >= 60) {
+        return { type: 'night-owl', confidence: eveningPct };
+    }
+    // Balanced: Even distribution
+    return { type: 'balanced', confidence: 100 - Math.max(morningPct, eveningPct, nightPct) };
+}
+function calculateWorkLifeBalance(dailyAverage) {
+    const weekdayCommits = dailyAverage
+        .filter(d => !['Saturday', 'Sunday'].includes(d.dayOfWeek))
+        .reduce((sum, d) => sum + d.commitCount, 0);
+    const weekendCommits = dailyAverage
+        .filter(d => ['Saturday', 'Sunday'].includes(d.dayOfWeek))
+        .reduce((sum, d) => sum + d.commitCount, 0);
+    const totalCommits = weekdayCommits + weekendCommits;
+    const ratio = totalCommits > 0 ? weekdayCommits / weekendCommits : 0;
+    // Score: 5 stars = ratio > 10 (very little weekend work)
+    // 1 star = ratio < 2 (too much weekend work)
+    let score = 5;
+    if (ratio < 2)
+        score = 1;
+    else if (ratio < 4)
+        score = 2;
+    else if (ratio < 6)
+        score = 3;
+    else if (ratio < 10)
+        score = 4;
+    return {
+        weekdayCommits,
+        weekendCommits,
+        ratio,
+        score
+    };
+}
+function calculateTimingStats(commits) {
+    if (commits.length === 0) {
+        return {
+            avgFirstCommit: '00:00',
+            avgLastCommit: '00:00',
+            avgSessionLength: 0,
+            longestSession: { date: new Date(), hours: 0 }
+        };
+    }
+    // Group commits by date
+    const commitsByDate = new Map();
+    commits.forEach(commit => {
+        const dateKey = (0, date_fns_1.format)(new Date(commit.date), 'yyyy-MM-dd');
+        if (!commitsByDate.has(dateKey)) {
+            commitsByDate.set(dateKey, []);
+        }
+        commitsByDate.get(dateKey).push(new Date(commit.date));
+    });
+    // Calculate first/last commit times and session lengths
+    let totalFirstHour = 0;
+    let totalLastHour = 0;
+    let totalSessionHours = 0;
+    let longestSession = { date: new Date(), hours: 0 };
+    commitsByDate.forEach((times, dateKey) => {
+        times.sort((a, b) => a.getTime() - b.getTime());
+        const firstCommit = times[0];
+        const lastCommit = times[times.length - 1];
+        totalFirstHour += firstCommit.getHours() + (firstCommit.getMinutes() / 60);
+        totalLastHour += lastCommit.getHours() + (lastCommit.getMinutes() / 60);
+        const sessionLength = (0, date_fns_1.differenceInHours)(lastCommit, firstCommit);
+        totalSessionHours += sessionLength;
+        if (sessionLength > longestSession.hours) {
+            longestSession = { date: (0, date_fns_1.parse)(dateKey, 'yyyy-MM-dd', new Date()), hours: sessionLength };
+        }
+    });
+    const daysWithCommits = commitsByDate.size;
+    const avgFirstHour = totalFirstHour / daysWithCommits;
+    const avgLastHour = totalLastHour / daysWithCommits;
+    const formatTime = (decimalHour) => {
+        const hour = Math.floor(decimalHour);
+        const minute = Math.floor((decimalHour - hour) * 60);
+        return `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`;
+    };
+    return {
+        avgFirstCommit: formatTime(avgFirstHour),
+        avgLastCommit: formatTime(avgLastHour),
+        avgSessionLength: totalSessionHours / daysWithCommits,
+        longestSession
+    };
+}
+function detectBurnoutRisk(hourly, dailyAverage, commits) {
+    const indicators = [];
+    let riskScore = 0;
+    // Check for late-night commits (after 11 PM)
+    const lateNightCommits = hourly.filter(h => h.hour >= 23).reduce((sum, h) => sum + h.commitCount, 0);
+    const veryLateCommits = hourly.filter(h => h.hour >= 0 && h.hour < 6).reduce((sum, h) => sum + h.commitCount, 0);
+    if (lateNightCommits > 15) {
+        indicators.push(`${lateNightCommits} late-night commits (after 11 PM)`);
+        riskScore += 20;
+    }
+    if (veryLateCommits > 10) {
+        indicators.push(`${veryLateCommits} commits between midnight-6am`);
+        riskScore += 30;
+    }
+    // Weekend work is not counted as a burnout indicator since it's ambiguous
+    // (could be hobby projects vs. overwork) - focusing on late night patterns instead
+    // Check for uneven distribution (working all hours)
+    const activeHours = hourly.filter(h => h.commitCount > 0).length;
+    if (activeHours > 16) {
+        indicators.push('Commits spread across too many hours');
+        riskScore += 15;
+    }
+    // Determine risk level
+    let level = 'low';
+    if (riskScore >= 50)
+        level = 'high';
+    else if (riskScore >= 25)
+        level = 'medium';
+    // Add positive indicators if low risk
+    if (riskScore < 25) {
+        indicators.push('✅ Regular commit times (±2 hour variance)');
+        indicators.push('✅ Healthy work-life balance');
+    }
+    return {
+        level,
+        indicators,
+        score: Math.min(riskScore, 100)
+    };
+}
+function calculateConsistency(commits) {
+    if (commits.length === 0) {
+        return { score: 0, variance: 0, regularity: 'chaotic' };
+    }
+    // Calculate variance in commit times (hour of day)
+    const hours = commits.map(c => (0, date_fns_1.getHours)(new Date(c.date)));
+    const avgHour = hours.reduce((sum, h) => sum + h, 0) / hours.length;
+    const variance = hours.reduce((sum, h) => sum + Math.pow(h - avgHour, 2), 0) / hours.length;
+    const stdDev = Math.sqrt(variance);
+    // Score based on standard deviation (lower = more consistent)
+    // stdDev < 2: very consistent (same 2-hour window)
+    // stdDev < 4: consistent
+    // stdDev < 6: irregular
+    // stdDev >= 6: chaotic
+    let score = 10;
+    let regularity = 'very-consistent';
+    if (stdDev >= 6) {
+        score = Math.max(0, 10 - stdDev);
+        regularity = 'chaotic';
+    }
+    else if (stdDev >= 4) {
+        score = 10 - stdDev;
+        regularity = 'irregular';
+    }
+    else if (stdDev >= 2) {
+        score = 10 - (stdDev / 2);
+        regularity = 'consistent';
+    }
+    else {
+        score = 10 - (stdDev / 4);
+        regularity = 'very-consistent';
+    }
+    return {
+        score: Math.max(0, Math.min(10, score)),
+        variance: stdDev,
+        regularity
+    };
+}
+function getEmptyPattern() {
+    return {
+        hourly: Array.from({ length: 24 }, (_, i) => ({ hour: i, commitCount: 0, percentage: 0 })),
+        dailyAverage: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'].map(day => ({
+            dayOfWeek: day,
+            commitCount: 0,
+            avgCommitsPerDay: 0
+        })),
+        chronotype: 'balanced',
+        chronotypeConfidence: 0,
+        peakHour: { hour: 0, commitCount: 0 },
+        peakDay: { dayOfWeek: 'Monday', avgCommits: 0 },
+        workLifeBalance: { weekdayCommits: 0, weekendCommits: 0, ratio: 0, score: 5 },
+        timingStats: {
+            avgFirstCommit: '00:00',
+            avgLastCommit: '00:00',
+            avgSessionLength: 0,
+            longestSession: { date: new Date(), hours: 0 }
+        },
+        burnoutRisk: { level: 'low', indicators: [], score: 0 },
+        consistency: { score: 0, variance: 0, regularity: 'chaotic' }
+    };
+}
+function getChronotypeLabel(chronotype) {
+    const labels = {
+        'early-bird': '🐦 Early Bird',
+        'night-owl': '🦉 Night Owl',
+        'balanced': '⚖️ Balanced',
+        'vampire': '🧛 Vampire'
+    };
+    return labels[chronotype] || chronotype;
+}
+exports.getChronotypeLabel = getChronotypeLabel;
+function getChronotypeDescription(chronotype) {
+    const descriptions = {
+        'early-bird': "You're most productive in the morning. Consider scheduling important work before lunch.",
+        'night-owl': "You're most productive in the evening. Night time is when you shine!",
+        'balanced': "You maintain a well-balanced coding schedule throughout the day.",
+        'vampire': "⚠️ Many late-night commits detected. Consider adjusting your schedule for better work-life balance."
+    };
+    return descriptions[chronotype] || '';
+}
+exports.getChronotypeDescription = getChronotypeDescription;

package/dist/utils/wrappedDisplay.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayWrappedSlideshow = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const readline = __importStar(require("readline"));
+function displayWrappedSlideshow(slides) {
+    let currentSlide = 0;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    // Set raw mode to capture single keystrokes
+    if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+    }
+    function displaySlide(index) {
+        console.clear();
+        console.log(slides[index].content);
+        console.log();
+        // Show navigation hints
+        const hints = [];
+        if (index < slides.length - 1)
+            hints.push(chalk_1.default.gray('Press ENTER for next'));
+        if (index > 0)
+            hints.push(chalk_1.default.gray('Press B for back'));
+        hints.push(chalk_1.default.gray('Press Q to quit'));
+        console.log(chalk_1.default.dim(hints.join('  |  ')));
+        console.log();
+        console.log(chalk_1.default.gray(`Slide ${index + 1}/${slides.length}`));
+    }
+    function navigate(direction) {
+        if (direction === 'quit') {
+            cleanup();
+            return;
+        }
+        if (direction === 'next' && currentSlide < slides.length - 1) {
+            currentSlide++;
+            displaySlide(currentSlide);
+        }
+        else if (direction === 'next' && currentSlide === slides.length - 1) {
+            // At the end
+            cleanup();
+        }
+        else if (direction === 'prev' && currentSlide > 0) {
+            currentSlide--;
+            displaySlide(currentSlide);
+        }
+    }
+    function cleanup() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        rl.close();
+        console.log();
+        console.log(chalk_1.default.green('✨ Thanks for exploring your Year in Code!'));
+        console.log();
+    }
+    // Handle keypress events
+    process.stdin.on('keypress', (str, key) => {
+        if (key.ctrl && key.name === 'c') {
+            cleanup();
+            process.exit();
+        }
+        switch (key.name) {
+            case 'return':
+            case 'enter':
+            case 'space':
+                navigate('next');
+                break;
+            case 'b':
+                navigate('prev');
+                break;
+            case 'q':
+            case 'escape':
+                navigate('quit');
+                break;
+            case 'left':
+                navigate('prev');
+                break;
+            case 'right':
+                navigate('next');
+                break;
+        }
+    });
+    // Display first slide
+    displaySlide(currentSlide);
+}
+exports.displayWrappedSlideshow = displayWrappedSlideshow;