repo-wrapped 0.0.7 → 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

@@ -5,7 +5,7 @@ exports.parseDateRange = parseDateRange;
 exports.formatComparisonInsights = formatComparisonInsights;
 const date_fns_1 = require("date-fns");
 const commitQualityAnalyzer_1 = require("./commitQualityAnalyzer");
-const streakCalculator_1 = require("./streakCalculator");
+const streaks_1 = require("../features/streaks");
 /**
  * Compares metrics between two date ranges to show before/after impact
  */
@@ -64,7 +64,7 @@ function calculateRangeMetrics(commits, startDate, endDate, skipBodyCheck) {
     const qualityResult = (0, commitQualityAnalyzer_1.analyzeCommitQuality)(commits, { skipBodyCheck });
     const qualityScore = Math.round(qualityResult.overallScore * 10) / 10;
     // Streak data
-    const streakData = (0, streakCalculator_1.calculateStreaks)(commits, startDate, endDate);
+    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

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) {

package/dist/utils/teamAnalyzer.js

@@ -110,7 +110,26 @@ function loadTeamFile(filePath) {
     }
 }
 /**
- * Analyzes commits for a team of contributors
+ * Analyzes commit patterns and distribution for a team of contributors.
+ *
+ * Calculates team-level metrics including:
+ * - Commit distribution across members (Gini coefficient)
+ * - Individual member statistics and rankings
+ * - Quality scores and active days
+ * - Load balancing insights
+ *
+ * @param commits - Array of all commit data (will be filtered to team members)
+ * @param teamMembers - Array of team member names/patterns to include
+ * @param teamName - Optional team name for display
+ * @param skipBodyCheck - Whether to skip commit body quality checks (default: true)
+ * @returns Team analysis with member breakdown, distribution metrics, and insights
+ *
+ * @example
+ * ```typescript
+ * const team = analyzeTeam(commits, ['Alice', 'Bob', 'Charlie'], 'Backend Team');
+ * console.log(`Team commits: ${team.stats.totalCommits}`);
+ * console.log(`Distribution: ${team.loadDistribution.assessment}`);
+ * ```
  */
 function analyzeTeam(commits, teamMembers, teamName, skipBodyCheck = true) {
     // Filter commits to team members only

package/dist/utils/timePatternAnalyzer.js

@@ -4,14 +4,29 @@ exports.analyzeTimePatterns = analyzeTimePatterns;
 exports.getChronotypeLabel = getChronotypeLabel;
 exports.getChronotypeDescription = getChronotypeDescription;
 const date_fns_1 = require("date-fns");
-function analyzeTimePatterns(commits, startDate, endDate) {
+const analyzerContextBuilder_1 = require("./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 >= startDate && commitDate <= endDate;
+        return commitDate >= start && commitDate <= end;
     });
     if (filteredCommits.length === 0) {
         return getEmptyPattern();
@@ -43,7 +58,7 @@ function analyzeTimePatterns(commits, startDate, endDate) {
     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))
+        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);

package/dist/utils/velocityAnalyzer.js

@@ -3,17 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeVelocity = analyzeVelocity;
 exports.formatVelocityInsights = formatVelocityInsights;
 const date_fns_1 = require("date-fns");
-/**
- * Analyzes commit velocity over time to show productivity trends
- */
-function analyzeVelocity(commits, startDate, endDate, rollingWindowWeeks = 4) {
+const emptyResults_1 = require("./emptyResults");
+const analyzerContextBuilder_1 = require("./analyzerContextBuilder");
+function analyzeVelocity(ctxOrCommits, startDate, endDate, rollingWindowWeeks = 4) {
+    // Normalize to internal variables
+    let commits;
+    let start;
+    let end;
+    let windowWeeks;
+    if ((0, analyzerContextBuilder_1.isAnalyzerContext)(ctxOrCommits)) {
+        commits = ctxOrCommits.commits;
+        start = ctxOrCommits.dateRange.start;
+        end = ctxOrCommits.dateRange.end;
+        windowWeeks = (0, analyzerContextBuilder_1.getOption)(ctxOrCommits, 'windowWeeks', 4);
+    }
+    else {
+        commits = ctxOrCommits;
+        start = startDate;
+        end = endDate;
+        windowWeeks = rollingWindowWeeks;
+    }
     if (commits.length === 0) {
-        return getEmptyVelocityAnalysis();
+        return (0, emptyResults_1.getEmptyVelocityAnalysis)();
     }
     // Build weekly data points
-    const timeline = buildWeeklyTimeline(commits, startDate, endDate);
+    const timeline = buildWeeklyTimeline(commits, start, end);
     // Calculate rolling averages
-    calculateRollingAverages(timeline, rollingWindowWeeks);
+    calculateRollingAverages(timeline, windowWeeks);
     // Detect anomalies
     const anomalies = detectAnomalies(timeline);
     // Calculate overall trend
@@ -210,17 +226,6 @@ function findLowestWeek(timeline) {
     const lowest = nonZeroWeeks.reduce((min, dp) => dp.commits < min.commits ? dp : min, nonZeroWeeks[0]);
     return { weekStart: lowest.weekStart, commits: lowest.commits };
 }
-function getEmptyVelocityAnalysis() {
-    return {
-        timeline: [],
-        overallTrend: 'stable',
-        trendPercentage: 0,
-        averageCommitsPerWeek: 0,
-        peakWeek: { weekStart: new Date(), commits: 0 },
-        lowestWeek: { weekStart: new Date(), commits: 0 },
-        anomalies: [],
-    };
-}
 /**
  * Format velocity analysis for display
  */

package/dist/utils/wrappedGenerator.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateYearWrapped = generateYearWrapped;
 const child_process_1 = require("child_process");
-const achievementEngine_js_1 = require("./achievementEngine.js");
-const commitQualityAnalyzer_js_1 = require("./commitQualityAnalyzer.js");
+const achievements_1 = require("../features/achievements");
+const commit_quality_1 = require("../features/commit-quality");
 const fileHotspotAnalyzer_js_1 = require("./fileHotspotAnalyzer.js");
 const gitParser_js_1 = require("./gitParser.js");
-const streakCalculator_js_1 = require("./streakCalculator.js");
-const timePatternAnalyzer_js_1 = require("./timePatternAnalyzer.js");
+const streaks_1 = require("../features/streaks");
+const time_patterns_1 = require("../features/time-patterns");
 function generateYearWrapped(year, repoPath = '.', includeComparison = false) {
     // Define year boundaries
     const startDate = new Date(`${year}-01-01`);
@@ -21,9 +21,9 @@ function generateYearWrapped(year, repoPath = '.', includeComparison = false) {
         throw new Error(`No commits found for year ${year}`);
     }
     // Calculate all metrics using existing utilities
-    const streakData = (0, streakCalculator_js_1.calculateStreaks)(commits, startDate, endDate);
-    const timePattern = (0, timePatternAnalyzer_js_1.analyzeTimePatterns)(commits, startDate, endDate);
-    const commitQuality = (0, commitQualityAnalyzer_js_1.analyzeCommitQuality)(commits);
+    const streakData = (0, streaks_1.calculateStreaks)(commits, startDate, endDate);
+    const timePattern = (0, time_patterns_1.analyzeTimePatterns)(commits, startDate, endDate);
+    const commitQuality = (0, commit_quality_1.analyzeCommitQuality)(commits);
     const fileHotspots = (0, fileHotspotAnalyzer_js_1.analyzeFileHotspots)(repoPath, startDate, endDate);
     // Create AnalysisData for achievement checking
     const analysisData = {
@@ -38,7 +38,7 @@ function generateYearWrapped(year, repoPath = '.', includeComparison = false) {
             end: endDate
         }
     };
-    const achievementProgress = (0, achievementEngine_js_1.checkAchievements)(analysisData);
+    const achievementProgress = (0, achievements_1.checkAchievements)(analysisData);
     // Calculate overview
     const overview = {
         totalCommits: commits.length,