repo-wrapped 0.0.6 → 0.0.9

package/dist/features/time-patterns/analyzer.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTimePatterns = analyzeTimePatterns;
+exports.getChronotypeLabel = getChronotypeLabel;
+exports.getChronotypeDescription = getChronotypeDescription;
+const date_fns_1 = require("date-fns");
+const analyzerContextBuilder_1 = require("../../utils/analyzerContextBuilder");
+function analyzeTimePatterns(ctxOrCommits, startDate, endDate) {
+    // Normalize to internal variables
+    let commits;
+    let start;
+    let end;
+    if ((0, analyzerContextBuilder_1.isAnalyzerContext)(ctxOrCommits)) {
+        commits = ctxOrCommits.commits;
+        start = ctxOrCommits.dateRange.start;
+        end = ctxOrCommits.dateRange.end;
+    }
+    else {
+        commits = ctxOrCommits;
+        start = startDate;
+        end = 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 >= start && commitDate <= end;
+    });
+    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((end.getTime() - start.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
+    };
+}
+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;
+}
+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] || '';
+}

package/dist/features/time-patterns/analyzer.test.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * Unit tests for the time pattern analyzer
+ *
+ * Tests analyzeTimePatterns function for correct hourly/daily distribution,
+ * chronotype detection, and work-life balance calculations.
+ *
+ * NOTE: Hour extraction uses local time via date-fns getHours, which means
+ * tests need to be timezone-agnostic or use local-time-aware assertions.
+ *
+ * @module features/time-patterns/analyzer.test
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const analyzer_1 = require("./analyzer");
+// ============================================================================
+// Test Helpers
+// ============================================================================
+/**
+ * Creates a commit with the specified date
+ */
+function createCommit(date) {
+    return {
+        hash: `hash-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        author: 'Test Author',
+        date,
+        message: 'test commit',
+    };
+}
+/**
+ * Creates multiple commits on consecutive dates
+ */
+function createCommits(dates) {
+    return dates.map(d => createCommit(d));
+}
+// ============================================================================
+// Basic Functionality
+// ============================================================================
+(0, vitest_1.describe)('analyzeTimePatterns', () => {
+    (0, vitest_1.describe)('basic functionality', () => {
+        (0, vitest_1.it)('returns empty pattern for empty commits', () => {
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)([], start, end);
+            (0, vitest_1.expect)(result.hourly).toHaveLength(24);
+            (0, vitest_1.expect)(result.hourly.every(h => h.commitCount === 0)).toBe(true);
+        });
+        (0, vitest_1.it)('returns all 24 hours in hourly distribution', () => {
+            const commits = [createCommit('2025-06-09T10:00:00Z')];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.hourly).toHaveLength(24);
+            // Should have exactly 1 commit total
+            const totalCommits = result.hourly.reduce((sum, h) => sum + h.commitCount, 0);
+            (0, vitest_1.expect)(totalCommits).toBe(1);
+        });
+        (0, vitest_1.it)('calculates percentages that sum to 100', () => {
+            const commits = createCommits([
+                '2025-06-09T08:00:00Z',
+                '2025-06-09T12:00:00Z',
+                '2025-06-09T16:00:00Z',
+                '2025-06-09T20:00:00Z',
+            ]);
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // Percentages should sum to 100 (or close due to floating point)
+            const totalPercentage = result.hourly.reduce((sum, h) => sum + h.percentage, 0);
+            (0, vitest_1.expect)(totalPercentage).toBeCloseTo(100, 0);
+        });
+        (0, vitest_1.it)('identifies peak hour with highest commit count', () => {
+            const commits = createCommits([
+                '2025-06-09T10:00:00Z',
+                '2025-06-09T10:30:00Z',
+                '2025-06-09T10:45:00Z', // 3 commits around 10
+                '2025-06-09T16:00:00Z', // 1 commit at 16
+            ]);
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // Peak hour should have at least 3 commits
+            (0, vitest_1.expect)(result.peakHour.commitCount).toBeGreaterThanOrEqual(3);
+        });
+    });
+    // ============================================================================
+    // Chronotype Detection
+    // ============================================================================
+    (0, vitest_1.describe)('chronotype detection', () => {
+        (0, vitest_1.it)('returns one of the valid chronotypes', () => {
+            const commits = createCommits([
+                '2025-06-09T08:00:00Z',
+                '2025-06-10T09:00:00Z',
+                '2025-06-11T10:00:00Z',
+            ]);
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(['early-bird', 'night-owl', 'balanced', 'vampire']).toContain(result.chronotype);
+        });
+        (0, vitest_1.it)('returns chronotype confidence score between 0 and 100', () => {
+            const commits = createCommits([
+                '2025-06-09T09:00:00Z',
+                '2025-06-10T09:00:00Z',
+                '2025-06-11T09:00:00Z',
+            ]);
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.chronotypeConfidence).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)(result.chronotypeConfidence).toBeLessThanOrEqual(100);
+        });
+    });
+    // ============================================================================
+    // Daily Distribution
+    // ============================================================================
+    (0, vitest_1.describe)('daily distribution', () => {
+        (0, vitest_1.it)('calculates daily averages', () => {
+            const commits = [
+                // Multiple Mondays (2025-06-02, 2025-06-09, 2025-06-16 are Mondays)
+                { hash: 'h1', author: 'A', date: '2025-06-02T10:00:00Z', message: 'm' },
+                { hash: 'h2', author: 'A', date: '2025-06-09T10:00:00Z', message: 'm' },
+                { hash: 'h3', author: 'A', date: '2025-06-16T10:00:00Z', message: 'm' },
+                // One Tuesday (2025-06-03)
+                { hash: 'h4', author: 'A', date: '2025-06-03T10:00:00Z', message: 'm' },
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.dailyAverage).toHaveLength(7);
+            // Total commits should be 4
+            const totalCommits = result.dailyAverage.reduce((sum, d) => sum + d.commitCount, 0);
+            (0, vitest_1.expect)(totalCommits).toBe(4);
+        });
+        (0, vitest_1.it)('identifies peak day', () => {
+            const commits = [
+                // 5 commits on Monday
+                { hash: 'h1', author: 'A', date: '2025-06-02T10:00:00Z', message: 'm' },
+                { hash: 'h2', author: 'A', date: '2025-06-09T10:00:00Z', message: 'm' },
+                { hash: 'h3', author: 'A', date: '2025-06-16T10:00:00Z', message: 'm' },
+                { hash: 'h4', author: 'A', date: '2025-06-23T10:00:00Z', message: 'm' },
+                { hash: 'h5', author: 'A', date: '2025-06-30T10:00:00Z', message: 'm' },
+                // 2 commits on Friday
+                { hash: 'h6', author: 'A', date: '2025-06-06T10:00:00Z', message: 'm' },
+                { hash: 'h7', author: 'A', date: '2025-06-13T10:00:00Z', message: 'm' },
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.peakDay.dayOfWeek).toBe('Monday');
+        });
+    });
+    // ============================================================================
+    // Work-Life Balance
+    // ============================================================================
+    (0, vitest_1.describe)('work-life balance', () => {
+        (0, vitest_1.it)('counts weekday vs weekend commits', () => {
+            const commits = [
+                // Weekday commits (Mon-Fri)
+                { hash: 'h1', author: 'A', date: '2025-06-09T10:00:00Z', message: 'm' }, // Mon
+                { hash: 'h2', author: 'A', date: '2025-06-10T10:00:00Z', message: 'm' }, // Tue
+                { hash: 'h3', author: 'A', date: '2025-06-11T10:00:00Z', message: 'm' }, // Wed
+                // Weekend commits (Sat-Sun)
+                { hash: 'h4', author: 'A', date: '2025-06-07T10:00:00Z', message: 'm' }, // Sat
+                { hash: 'h5', author: 'A', date: '2025-06-08T10:00:00Z', message: 'm' }, // Sun
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.workLifeBalance.weekdayCommits).toBe(3);
+            (0, vitest_1.expect)(result.workLifeBalance.weekendCommits).toBe(2);
+        });
+        (0, vitest_1.it)('calculates weekday/weekend ratio', () => {
+            const commits = [
+                { hash: 'h1', author: 'A', date: '2025-06-09T10:00:00Z', message: 'm' }, // Mon
+                { hash: 'h2', author: 'A', date: '2025-06-10T10:00:00Z', message: 'm' }, // Tue
+                { hash: 'h3', author: 'A', date: '2025-06-07T10:00:00Z', message: 'm' }, // Sat
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // 2 weekday : 1 weekend = ratio of 2
+            (0, vitest_1.expect)(result.workLifeBalance.ratio).toBeGreaterThan(0);
+        });
+        (0, vitest_1.it)('returns work-life balance score', () => {
+            const commits = [
+                { hash: 'h1', author: 'A', date: '2025-06-09T10:00:00Z', message: 'm' },
+                { hash: 'h2', author: 'A', date: '2025-06-10T10:00:00Z', message: 'm' },
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.workLifeBalance.score).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)(result.workLifeBalance.score).toBeLessThanOrEqual(100);
+        });
+        (0, vitest_1.it)('handles all-weekend commits', () => {
+            const commits = [
+                { hash: 'h1', author: 'A', date: '2025-06-07T10:00:00Z', message: 'm' }, // Sat
+                { hash: 'h2', author: 'A', date: '2025-06-08T10:00:00Z', message: 'm' }, // Sun
+                { hash: 'h3', author: 'A', date: '2025-06-14T10:00:00Z', message: 'm' }, // Sat
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            (0, vitest_1.expect)(result.workLifeBalance.weekdayCommits).toBe(0);
+            (0, vitest_1.expect)(result.workLifeBalance.weekendCommits).toBe(3);
+        });
+    });
+    // ============================================================================
+    // Edge Cases
+    // ============================================================================
+    (0, vitest_1.describe)('edge cases', () => {
+        (0, vitest_1.it)('handles commits outside date range', () => {
+            const commits = [
+                { hash: 'h1', author: 'A', date: '2025-05-15T10:00:00Z', message: 'm' }, // Before
+                { hash: 'h2', author: 'A', date: '2025-06-15T10:00:00Z', message: 'm' }, // In range
+                { hash: 'h3', author: 'A', date: '2025-07-15T10:00:00Z', message: 'm' }, // After
+            ];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // Only 1 commit should be counted
+            const totalCommits = result.hourly.reduce((sum, h) => sum + h.commitCount, 0);
+            (0, vitest_1.expect)(totalCommits).toBe(1);
+        });
+        (0, vitest_1.it)('handles single commit', () => {
+            const commits = [createCommit('2025-06-09T10:00:00Z')];
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // Should have one peak hour with 1 commit
+            (0, vitest_1.expect)(result.peakHour.commitCount).toBe(1);
+        });
+        (0, vitest_1.it)('returns valid structure for all commits', () => {
+            const commits = createCommits([
+                '2025-06-09T00:00:00Z',
+                '2025-06-10T06:00:00Z',
+                '2025-06-11T12:00:00Z',
+                '2025-06-12T18:00:00Z',
+                '2025-06-13T23:59:59Z',
+            ]);
+            const start = new Date('2025-06-01');
+            const end = new Date('2025-06-30');
+            const result = (0, analyzer_1.analyzeTimePatterns)(commits, start, end);
+            // Structure should be complete
+            (0, vitest_1.expect)(result.hourly).toHaveLength(24);
+            (0, vitest_1.expect)(result.dailyAverage).toHaveLength(7);
+            (0, vitest_1.expect)(result.peakHour).toBeDefined();
+            (0, vitest_1.expect)(result.peakDay).toBeDefined();
+            (0, vitest_1.expect)(result.workLifeBalance).toBeDefined();
+            (0, vitest_1.expect)(result.chronotype).toBeDefined();
+        });
+    });
+    // ============================================================================
+    // Context-based API
+    // ============================================================================
+    (0, vitest_1.describe)('context-based API', () => {
+        (0, vitest_1.it)('works with AnalyzerContext', () => {
+            const commits = createCommits([
+                '2025-06-09T09:00:00Z',
+                '2025-06-10T10:00:00Z',
+                '2025-06-11T11:00:00Z',
+            ]);
+            const ctx = {
+                commits,
+                dateRange: {
+                    start: new Date('2025-06-01'),
+                    end: new Date('2025-06-30'),
+                },
+                author: 'Test Author',
+            };
+            const result = (0, analyzer_1.analyzeTimePatterns)(ctx);
+            // Should count all 3 commits
+            const totalCommits = result.hourly.reduce((sum, h) => sum + h.commitCount, 0);
+            (0, vitest_1.expect)(totalCommits).toBe(3);
+        });
+    });
+});

package/dist/features/time-patterns/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Time Patterns Feature
+ *
+ * Self-contained time pattern analysis including:
+ * - Types: TimePattern interfaces
+ * - Analyzer: Time pattern analysis logic
+ * - Template: HTML rendering
+ *
+ * @module features/time-patterns
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTimePatternsSection = exports.getChronotypeLabel = exports.getChronotypeDescription = exports.analyzeTimePatterns = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Analyzer
+var analyzer_1 = require("./analyzer");
+Object.defineProperty(exports, "analyzeTimePatterns", { enumerable: true, get: function () { return analyzer_1.analyzeTimePatterns; } });
+Object.defineProperty(exports, "getChronotypeDescription", { enumerable: true, get: function () { return analyzer_1.getChronotypeDescription; } });
+Object.defineProperty(exports, "getChronotypeLabel", { enumerable: true, get: function () { return analyzer_1.getChronotypeLabel; } });
+// Template
+var template_1 = require("./template");
+Object.defineProperty(exports, "buildTimePatternsSection", { enumerable: true, get: function () { return template_1.buildTimePatternsSection; } });