repo-wrapped 0.0.2 → 0.0.4

package/dist/utils/timePatternAnalyzer.js

@@ -1,305 +1,304 @@
-"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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTimePatterns = analyzeTimePatterns;
+exports.getChronotypeLabel = getChronotypeLabel;
+exports.getChronotypeDescription = getChronotypeDescription;
+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
+    };
+}
+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] || '';
+}