repo-wrapped 0.0.6 → 0.0.9

package/dist/utils/knowledgeDistributionAnalyzer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeKnowledgeDistribution = analyzeKnowledgeDistribution;
 const child_process_1 = require("child_process");
+const emptyResults_1 = require("./emptyResults");
 /**
  * Extract directory from file path
  */
@@ -13,18 +14,15 @@ function getDirectory(filePath) {
 }
 /**
  * Calculate bus factor risk score
- * 1 owner = 10 (critical), 2 = 7 (high), 3 = 4 (medium), 4+ = 1 (low)
+ * 1 owner = 10 (critical), 2+ = 1 (low/safe)
+ * Adjusted for realistic team dynamics where 2+ knowledgeable owners is considered safe
  */
 function calculateRiskScore(significantOwners) {
     if (significantOwners === 0)
         return 10;
     if (significantOwners === 1)
         return 10;
-    if (significantOwners === 2)
-        return 7;
-    if (significantOwners === 3)
-        return 4;
-    return 1;
+    return 1; // 2+ owners = low risk
 }
 /**
  * Determine ownership type based on contribution percentages
@@ -151,7 +149,7 @@ function buildFileOwnership(fileStats, directoryPath) {
         });
         const ownershipPercentage = Math.round((maxCommits / totalCommits) * 100);
         const knowledgeAge = calculateKnowledgeAge(lastModified);
-        const significantOwners = Array.from(data.authors.values()).filter(a => (a.commits / totalCommits) >= 0.2).length;
+        const significantOwners = Array.from(data.authors.values()).filter(a => (a.commits / totalCommits) >= 0.65).length;
         const busFactorRiskScore = calculateRiskScore(significantOwners);
         const riskLevel = getRiskLevel(busFactorRiskScore);
         files.push({
@@ -175,11 +173,29 @@ function buildFileOwnership(fileStats, directoryPath) {
         .slice(0, 20); // Limit to 20 files per directory
 }
 /**
- * Analyze knowledge distribution across the codebase
+ * Analyzes knowledge distribution across the codebase to identify bus factor risks.
+ *
+ * Identifies:
+ * - Directory ownership patterns (solo, primary, shared, collaborative)
+ * - Bus factor risks (areas with single knowledge holders)
+ * - Knowledge silos (directories owned by one person)
+ * - Shared knowledge areas (directories with 3+ active contributors)
+ *
+ * @param commits - Array of commit data to analyze
+ * @param repoPath - Optional repository path for deep file-level analysis via git log
+ * @param deepAnalysis - Whether to perform file-level analysis (slower but more accurate)
+ * @returns Knowledge distribution with ownership data, risks, and recommendations
+ *
+ * @example
+ * ```typescript
+ * const knowledge = analyzeKnowledgeDistribution(commits, '/path/to/repo', true);
+ * console.log(`Bus factor risk: ${knowledge.busFactorRisk.level}`);
+ * console.log(`Knowledge silos: ${knowledge.knowledgeSilos.length}`);
+ * ```
  */
 function analyzeKnowledgeDistribution(commits, repoPath, deepAnalysis = false) {
     if (commits.length === 0) {
-        return getEmptyKnowledgeDistribution();
+        return (0, emptyResults_1.getEmptyKnowledgeDistribution)();
     }
     // For deep analysis, parse git log with file names
     let fileStats = null;
@@ -262,6 +278,11 @@ function analyzeKnowledgeDistribution(commits, repoPath, deepAnalysis = false) {
     let dirCount = 0;
     directoryStats.forEach((authorStats, dirPath) => {
         const totalCommits = Array.from(authorStats.values()).reduce((sum, a) => sum + a.commits, 0);
+        // Skip areas with too few commits - not enough data to assess bus factor
+        const MIN_COMMITS_FOR_ASSESSMENT = 20;
+        if (totalCommits < MIN_COMMITS_FOR_ASSESSMENT) {
+            return; // Skip this directory
+        }
         // Get the latest and earliest activity date for the directory
         let latestActivity = new Date(0);
         let earliestActivity = new Date();
@@ -285,8 +306,8 @@ function analyzeKnowledgeDistribution(commits, repoPath, deepAnalysis = false) {
             knowledgeAge: calculateKnowledgeAge(stats.lastActive)
         }))
             .sort((a, b) => b.commits - a.commits);
-        // Calculate significant owners (>= 20% contribution)
-        const significantOwners = owners.filter(o => o.percentage >= 20).length;
+        // Calculate significant owners (>= 65% contribution)
+        const significantOwners = owners.filter(o => o.percentage >= 65).length;
         const busFactorRisk = calculateRiskScore(significantOwners);
         const ownershipType = determineOwnershipType(owners);
         // Build high-risk files list if deep analysis is enabled
@@ -362,19 +383,3 @@ function generateRecommendations(data) {
     }
     return recommendations.slice(0, 5);
 }
-/**
- * Return empty distribution for no commits
- */
-function getEmptyKnowledgeDistribution() {
-    return {
-        directories: [],
-        busFactorRisk: {
-            overall: 0,
-            level: 'low',
-            criticalPaths: []
-        },
-        knowledgeSilos: [],
-        sharedKnowledge: [],
-        recommendations: ['No commit data available for analysis']
-    };
-}

package/dist/utils/matrixGenerator.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommitMatrix = generateCommitMatrix;
 const chalk_1 = __importDefault(require("chalk"));
 const date_fns_1 = require("date-fns");
-const achievementEngine_1 = require("./achievementEngine");
-const commitQualityAnalyzer_1 = require("./commitQualityAnalyzer");
+const achievements_1 = require("../features/achievements");
+const commit_quality_1 = require("../features/commit-quality");
 const fileHotspotAnalyzer_1 = require("./fileHotspotAnalyzer");
-const streakCalculator_1 = require("./streakCalculator");
-const timePatternAnalyzer_1 = require("./timePatternAnalyzer");
+const streaks_1 = require("../features/streaks");
+const time_patterns_1 = require("../features/time-patterns");
 /**
  * Calculate dynamic thresholds based on commit distribution for terminal output
  */
@@ -53,11 +53,11 @@ function generateCommitMatrix(commits, year, monthsToShow, repoPath, repoName, r
     });
     const totalCommits = Array.from(commitMap.values()).reduce((sum, count) => sum + count, 0);
     // Calculate streaks
-    const streakData = (0, streakCalculator_1.calculateStreaks)(commits, startDate, endDate);
+    const streakData = (0, streaks_1.calculateStreaks)(commits, startDate, endDate);
     // Analyze time patterns
-    const timePattern = (0, timePatternAnalyzer_1.analyzeTimePatterns)(commits, startDate, endDate);
+    const timePattern = (0, time_patterns_1.analyzeTimePatterns)(commits, startDate, endDate);
     // Analyze commit quality
-    const commitQuality = (0, commitQualityAnalyzer_1.analyzeCommitQuality)(commits);
+    const commitQuality = (0, commit_quality_1.analyzeCommitQuality)(commits);
     // Analyze file hotspots
     const fileHotspots = (0, fileHotspotAnalyzer_1.analyzeFileHotspots)(repoPath, startDate, endDate);
     // Prepare analysis data for achievements
@@ -71,7 +71,7 @@ function generateCommitMatrix(commits, year, monthsToShow, repoPath, repoName, r
         dateRange: { start: startDate, end: endDate }
     };
     // Check achievements
-    const achievementProgress = (0, achievementEngine_1.checkAchievements)(analysisData);
+    const achievementProgress = (0, achievements_1.checkAchievements)(analysisData);
     return formatGitHubStyle(commitMap, weekStartDate, weekEndDate, startDate, endDate, totalCommits, streakData, timePattern, commitQuality, fileHotspots, achievementProgress, repoName, repoUrl);
 }
 function formatGitHubStyle(commitMap, weekStartDate, weekEndDate, dataStartDate, dataEndDate, totalCommits, streakData, timePattern, commitQuality, fileHotspots, achievementProgress, repoName, repoUrl) {
@@ -174,7 +174,7 @@ function formatGitHubStyle(commitMap, weekStartDate, weekEndDate, dataStartDate,
         : 'No active streak';
     output += `${currentStreakEmoji} Current Streak: ${chalk_1.default.bold.green(currentStreakText)}`;
     if (streakData.currentStreak.isActive && streakData.currentStreak.days > 0) {
-        output += chalk_1.default.dim(` - ${(0, streakCalculator_1.getStreakMotivation)(streakData.currentStreak.days, true)}`);
+        output += chalk_1.default.dim(` - ${(0, streaks_1.getStreakMotivation)(streakData.currentStreak.days, true)}`);
     }
     output += '\n';
     const longestStreakText = streakData.longestStreak.days > 0
@@ -194,8 +194,8 @@ function formatGitHubStyle(commitMap, weekStartDate, weekEndDate, dataStartDate,
                 `${timePattern.peakHour.hour - 12}:00 PM`;
     output += `⏱️  Peak Hour: ${chalk_1.default.bold.green(peakHourLabel)} (${timePattern.peakHour.commitCount} commits)\n`;
     // Chronotype
-    const chronotypeLabel = (0, timePatternAnalyzer_1.getChronotypeLabel)(timePattern.chronotype);
-    const chronotypeDesc = (0, timePatternAnalyzer_1.getChronotypeDescription)(timePattern.chronotype);
+    const chronotypeLabel = (0, time_patterns_1.getChronotypeLabel)(timePattern.chronotype);
+    const chronotypeDesc = (0, time_patterns_1.getChronotypeDescription)(timePattern.chronotype);
     output += `${chronotypeLabel} ${chalk_1.default.dim(`(${timePattern.chronotypeConfidence.toFixed(0)}% confidence)`)}\n`;
     if (chronotypeDesc) {
         output += chalk_1.default.dim(`   ${chronotypeDesc}\n`);
@@ -217,8 +217,8 @@ function formatGitHubStyle(commitMap, weekStartDate, weekEndDate, dataStartDate,
     output += '\n';
     output += chalk_1.default.bold.cyan('📝 Commit Quality\n');
     output += chalk_1.default.dim('─'.repeat(50)) + '\n';
-    const rating = (0, commitQualityAnalyzer_1.getQualityRating)(commitQuality.overallScore);
-    const level = (0, commitQualityAnalyzer_1.getQualityLevel)(commitQuality.overallScore);
+    const rating = (0, commit_quality_1.getQualityRating)(commitQuality.overallScore);
+    const level = (0, commit_quality_1.getQualityLevel)(commitQuality.overallScore);
     output += `📊 Overall Score: ${chalk_1.default.bold.green(commitQuality.overallScore.toFixed(1))}/10 ${rating} ${chalk_1.default.dim(`(${level})`)}\n`;
     output += `✅ Convention: ${chalk_1.default.bold.cyan(commitQuality.conventionalCommits.adherence.toFixed(1))}%`;
     if (commitQuality.conventionalCommits.adherence < 70) {

package/dist/utils/rangeComparisonAnalyzer.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareRanges = compareRanges;
+exports.parseDateRange = parseDateRange;
+exports.formatComparisonInsights = formatComparisonInsights;
+const date_fns_1 = require("date-fns");
+const commitQualityAnalyzer_1 = require("./commitQualityAnalyzer");
+const streaks_1 = require("../features/streaks");
+/**
+ * Compares metrics between two date ranges to show before/after impact
+ */
+function compareRanges(commits, range1Start, range1End, range2Start, range2End, label1 = 'Period 1', label2 = 'Period 2', skipBodyCheck = true) {
+    // Filter commits for each range
+    const range1Commits = filterCommitsByDateRange(commits, range1Start, range1End);
+    const range2Commits = filterCommitsByDateRange(commits, range2Start, range2End);
+    // Calculate metrics for each range
+    const metrics1 = calculateRangeMetrics(range1Commits, range1Start, range1End, skipBodyCheck);
+    const metrics2 = calculateRangeMetrics(range2Commits, range2Start, range2End, skipBodyCheck);
+    // Calculate changes
+    const changes = calculateChanges(metrics1, metrics2);
+    // Generate summary narrative
+    const summary = generateSummary(label1, label2, metrics1, metrics2, changes);
+    return {
+        range1: {
+            label: label1,
+            start: range1Start,
+            end: range1End,
+            metrics: metrics1,
+        },
+        range2: {
+            label: label2,
+            start: range2Start,
+            end: range2End,
+            metrics: metrics2,
+        },
+        changes,
+        summary,
+    };
+}
+function filterCommitsByDateRange(commits, start, end) {
+    return commits.filter(commit => {
+        const commitDate = new Date(commit.date);
+        return commitDate >= start && commitDate <= end;
+    });
+}
+function calculateRangeMetrics(commits, startDate, endDate, skipBodyCheck) {
+    const totalDays = (0, date_fns_1.differenceInDays)(endDate, startDate) + 1;
+    const totalWeeks = Math.max(1, (0, date_fns_1.differenceInWeeks)(endDate, startDate) + 1);
+    // Basic counts
+    const totalCommits = commits.length;
+    const commitsPerWeek = Math.round((totalCommits / totalWeeks) * 10) / 10;
+    // Unique authors
+    const authors = [...new Set(commits.map(c => c.author))];
+    const totalAuthors = authors.length;
+    // Active days
+    const activeDatesSet = new Set(commits.map(c => {
+        const d = new Date(c.date);
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+    }));
+    const activeDays = activeDatesSet.size;
+    const activeDaysPercentage = Math.round((activeDays / totalDays) * 1000) / 10;
+    const averageCommitsPerDay = activeDays > 0 ? Math.round((totalCommits / activeDays) * 10) / 10 : 0;
+    // Quality score
+    const qualityResult = (0, commitQualityAnalyzer_1.analyzeCommitQuality)(commits, { skipBodyCheck });
+    const qualityScore = Math.round(qualityResult.overallScore * 10) / 10;
+    // Streak data
+    const streakData = (0, streaks_1.calculateStreaks)(commits, startDate, endDate);
+    const longestStreak = streakData.longestStreak.days;
+    const averageStreak = streakData.streaks.length > 0
+        ? Math.round(streakData.streaks.reduce((sum, s) => sum + s.days, 0) / streakData.streaks.length * 10) / 10
+        : 0;
+    // Commits by type (from conventional commits)
+    const commitsByType = {
+        feat: 0,
+        fix: 0,
+        docs: 0,
+        refactor: 0,
+        test: 0,
+        chore: 0,
+        other: 0,
+    };
+    for (const commit of commits) {
+        const match = commit.message.match(/^(feat|fix|docs|refactor|test|chore|style|perf|ci|build|revert)(\(.+\))?:/i);
+        if (match) {
+            const type = match[1].toLowerCase();
+            if (type in commitsByType) {
+                commitsByType[type]++;
+            }
+            else {
+                commitsByType.other++;
+            }
+        }
+        else {
+            commitsByType.other++;
+        }
+    }
+    // Commits by author
+    const commitsByAuthor = {};
+    for (const commit of commits) {
+        commitsByAuthor[commit.author] = (commitsByAuthor[commit.author] || 0) + 1;
+    }
+    return {
+        totalCommits,
+        commitsPerWeek,
+        totalAuthors,
+        activeDays,
+        activeDaysPercentage,
+        averageCommitsPerDay,
+        qualityScore,
+        longestStreak,
+        averageStreak,
+        commitsByType,
+        commitsByAuthor,
+    };
+}
+function calculateChanges(metrics1, metrics2) {
+    return {
+        commits: calculateMetricChange(metrics1.totalCommits, metrics2.totalCommits),
+        velocity: calculateMetricChange(metrics1.commitsPerWeek, metrics2.commitsPerWeek),
+        quality: calculateMetricChange(metrics1.qualityScore, metrics2.qualityScore),
+        activeDays: calculateMetricChange(metrics1.activeDays, metrics2.activeDays),
+        authors: calculateMetricChange(metrics1.totalAuthors, metrics2.totalAuthors),
+    };
+}
+function calculateMetricChange(value1, value2) {
+    const absolute = Math.round((value2 - value1) * 10) / 10;
+    const percentage = value1 !== 0
+        ? Math.round(((value2 - value1) / value1) * 1000) / 10
+        : (value2 > 0 ? 100 : 0);
+    let trend;
+    if (percentage > 5) {
+        trend = 'up';
+    }
+    else if (percentage < -5) {
+        trend = 'down';
+    }
+    else {
+        trend = 'stable';
+    }
+    return { absolute, percentage, trend };
+}
+function generateSummary(label1, label2, metrics1, metrics2, changes) {
+    const parts = [];
+    // Velocity change
+    if (changes.velocity.trend === 'down' && changes.velocity.percentage <= -20) {
+        parts.push(`Velocity decreased ${Math.abs(changes.velocity.percentage)}% in ${label2}`);
+    }
+    else if (changes.velocity.trend === 'up' && changes.velocity.percentage >= 20) {
+        parts.push(`Velocity increased ${changes.velocity.percentage}% in ${label2}`);
+    }
+    // Active days change
+    if (changes.activeDays.trend === 'down' && changes.activeDays.percentage <= -20) {
+        parts.push(`${Math.abs(changes.activeDays.percentage)}% fewer active days`);
+    }
+    else if (changes.activeDays.trend === 'up' && changes.activeDays.percentage >= 20) {
+        parts.push(`${changes.activeDays.percentage}% more active days`);
+    }
+    // Quality change
+    if (changes.quality.trend === 'down' && changes.quality.percentage <= -15) {
+        parts.push(`commit quality dropped ${Math.abs(changes.quality.percentage)}%`);
+    }
+    else if (changes.quality.trend === 'up' && changes.quality.percentage >= 15) {
+        parts.push(`commit quality improved ${changes.quality.percentage}%`);
+    }
+    // Author change
+    if (changes.authors.trend === 'down' && changes.authors.absolute < 0) {
+        parts.push(`${Math.abs(changes.authors.absolute)} fewer contributor(s)`);
+    }
+    else if (changes.authors.trend === 'up' && changes.authors.absolute > 0) {
+        parts.push(`${changes.authors.absolute} additional contributor(s)`);
+    }
+    if (parts.length === 0) {
+        return `Metrics remained relatively stable between ${label1} and ${label2}.`;
+    }
+    return parts.join(', ') + '.';
+}
+/**
+ * Parse date range string in format "YYYY-MM-DD..YYYY-MM-DD"
+ */
+function parseDateRange(rangeStr) {
+    const match = rangeStr.match(/^(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/);
+    if (!match) {
+        return null;
+    }
+    const start = new Date(match[1]);
+    const end = new Date(match[2]);
+    if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+        return null;
+    }
+    return { start, end };
+}
+/**
+ * Format comparison for display
+ */
+function formatComparisonInsights(comparison) {
+    const insights = [];
+    const { range1, range2, changes } = comparison;
+    insights.push(`📊 Comparing: ${range1.label} vs ${range2.label}`);
+    insights.push('');
+    // Commits
+    const commitEmoji = changes.commits.trend === 'up' ? '📈' : changes.commits.trend === 'down' ? '📉' : '➡️';
+    insights.push(`${commitEmoji} Commits: ${range1.metrics.totalCommits} → ${range2.metrics.totalCommits} (${formatChange(changes.commits)})`);
+    // Velocity
+    const velocityEmoji = changes.velocity.trend === 'up' ? '🚀' : changes.velocity.trend === 'down' ? '🐢' : '➡️';
+    insights.push(`${velocityEmoji} Velocity: ${range1.metrics.commitsPerWeek} → ${range2.metrics.commitsPerWeek}/week (${formatChange(changes.velocity)})`);
+    // Quality
+    const qualityEmoji = changes.quality.trend === 'up' ? '✨' : changes.quality.trend === 'down' ? '⚠️' : '➡️';
+    insights.push(`${qualityEmoji} Quality: ${range1.metrics.qualityScore} → ${range2.metrics.qualityScore}/10 (${formatChange(changes.quality)})`);
+    // Active days
+    const activeEmoji = changes.activeDays.trend === 'up' ? '📅' : changes.activeDays.trend === 'down' ? '🗓️' : '➡️';
+    insights.push(`${activeEmoji} Active days: ${range1.metrics.activeDays} → ${range2.metrics.activeDays} (${formatChange(changes.activeDays)})`);
+    // Contributors
+    const authorEmoji = changes.authors.trend === 'up' ? '👥' : changes.authors.trend === 'down' ? '👤' : '➡️';
+    insights.push(`${authorEmoji} Contributors: ${range1.metrics.totalAuthors} → ${range2.metrics.totalAuthors} (${formatChange(changes.authors)})`);
+    insights.push('');
+    insights.push(`💡 ${comparison.summary}`);
+    return insights;
+}
+function formatChange(change) {
+    const sign = change.percentage >= 0 ? '+' : '';
+    return `${sign}${change.percentage}%`;
+}

package/dist/utils/streakCalculator.js

@@ -3,25 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateStreaks = calculateStreaks;
 exports.getStreakMotivation = getStreakMotivation;
 const date_fns_1 = require("date-fns");
-function calculateStreaks(commits, startDate, endDate) {
+const analyzerContextBuilder_1 = require("./analyzerContextBuilder");
+/**
+ * Check if a date is a business day (Monday-Friday)
+ */
+function isBusinessDay(date) {
+    const day = (0, date_fns_1.getDay)(date);
+    return day !== 0 && day !== 6; // 0 = Sunday, 6 = Saturday
+}
+/**
+ * Get the previous business day from a given date
+ */
+function getPreviousBusinessDay(date) {
+    let prevDate = (0, date_fns_1.subDays)(date, 1);
+    while (!isBusinessDay(prevDate)) {
+        prevDate = (0, date_fns_1.subDays)(prevDate, 1);
+    }
+    return prevDate;
+}
+function calculateStreaks(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;
+    }
     // Create set of unique commit dates
     const commitDates = new Set();
     commits.forEach(commit => {
         const commitDate = new Date(commit.date);
-        if (commitDate >= startDate && commitDate <= endDate) {
+        if (commitDate >= start && commitDate <= end) {
             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 totalDays = (0, date_fns_1.differenceInDays)(end, start) + 1;
     const totalActiveDays = commitDates.size;
     const activeDayPercentage = totalDays > 0 ? (totalActiveDays / totalDays) * 100 : 0;
-    // Find all streaks
+    // Calculate business day stats
+    const allDays = (0, date_fns_1.eachDayOfInterval)({ start: start, end: end });
+    const businessDays = allDays.filter(isBusinessDay);
+    const totalBusinessDays = businessDays.length;
+    const activeBusinessDays = businessDays.filter(d => commitDates.has((0, date_fns_1.format)(d, 'yyyy-MM-dd'))).length;
+    // Find all streaks (business days only)
     const streaks = [];
     let currentStreakDays = 0;
     let currentStreakStart = null;
-    const allDays = (0, date_fns_1.eachDayOfInterval)({ start: startDate, end: endDate });
-    for (const date of allDays) {
+    for (const date of businessDays) {
         const dateKey = (0, date_fns_1.format)(date, 'yyyy-MM-dd');
         if (commitDates.has(dateKey)) {
             if (currentStreakDays === 0) {
@@ -31,10 +67,12 @@ function calculateStreaks(commits, startDate, endDate) {
         }
         else {
             if (currentStreakDays > 0 && currentStreakStart) {
+                // Find the last business day in the streak
+                const streakEnd = getPreviousBusinessDay(date);
                 streaks.push({
                     days: currentStreakDays,
                     startDate: currentStreakStart,
-                    endDate: (0, date_fns_1.subDays)(date, 1)
+                    endDate: streakEnd > currentStreakStart ? streakEnd : currentStreakStart
                 });
                 currentStreakDays = 0;
                 currentStreakStart = null;
@@ -43,54 +81,63 @@ function calculateStreaks(commits, startDate, endDate) {
     }
     // Handle streak that extends to end date
     if (currentStreakDays > 0 && currentStreakStart) {
+        // Find the last business day in range
+        const lastBusinessDay = businessDays[businessDays.length - 1] || end;
         streaks.push({
             days: currentStreakDays,
             startDate: currentStreakStart,
-            endDate: endDate
+            endDate: lastBusinessDay
         });
     }
     // 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)
+        : { days: 0, startDate: start, endDate: start };
+    // Determine current streak (from today or most recent business day 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
+    // For current streak, we check today or the last business day
+    const checkToday = isBusinessDay(today) ? today : getPreviousBusinessDay(today);
+    const checkTodayKey = (0, date_fns_1.format)(checkToday, 'yyyy-MM-dd');
+    if (commitDates.has(checkTodayKey)) {
+        // Recent business day has a commit, find streak backward through business days only
         let streakDays = 0;
-        let checkDate = today;
+        let checkDate = checkToday;
+        let streakStartDate = checkToday;
         while (commitDates.has((0, date_fns_1.format)(checkDate, 'yyyy-MM-dd'))) {
             streakDays++;
-            checkDate = (0, date_fns_1.subDays)(checkDate, 1);
-            if (checkDate < startDate)
+            streakStartDate = checkDate;
+            checkDate = getPreviousBusinessDay(checkDate);
+            if (checkDate < start)
                 break;
         }
         currentStreak = {
             days: streakDays,
-            startDate: (0, date_fns_1.subDays)(today, streakDays - 1),
-            endDate: today,
+            startDate: streakStartDate,
+            endDate: checkToday,
             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)) {
+        // No commit on recent business day, check previous business day
+        const prevBusinessDay = getPreviousBusinessDay(checkToday);
+        const prevKey = (0, date_fns_1.format)(prevBusinessDay, 'yyyy-MM-dd');
+        if (commitDates.has(prevKey)) {
             let streakDays = 0;
-            let checkDate = yesterday;
+            let checkDate = prevBusinessDay;
+            let streakStartDate = prevBusinessDay;
             while (commitDates.has((0, date_fns_1.format)(checkDate, 'yyyy-MM-dd'))) {
                 streakDays++;
-                checkDate = (0, date_fns_1.subDays)(checkDate, 1);
-                if (checkDate < startDate)
+                streakStartDate = checkDate;
+                checkDate = getPreviousBusinessDay(checkDate);
+                if (checkDate < start)
                     break;
             }
             currentStreak = {
                 days: streakDays,
-                startDate: (0, date_fns_1.subDays)(yesterday, streakDays - 1),
-                endDate: yesterday,
+                startDate: streakStartDate,
+                endDate: prevBusinessDay,
                 isActive: false
             };
         }
@@ -110,7 +157,10 @@ function calculateStreaks(commits, startDate, endDate) {
         totalActiveDays,
         totalDays,
         activeDayPercentage,
-        streaks
+        streaks,
+        // Add business day specific data
+        totalBusinessDays,
+        activeBusinessDays
     };
 }
 function getStreakMotivation(days, isActive) {