repo-wrapped 0.0.6 → 0.0.9

package/dist/utils/teamAnalyzer.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterCommitsByAuthor = filterCommitsByAuthor;
+exports.parseAuthorFilter = parseAuthorFilter;
+exports.loadTeamFile = loadTeamFile;
+exports.analyzeTeam = analyzeTeam;
+exports.formatTeamInsights = formatTeamInsights;
+const fs = __importStar(require("fs"));
+const commitQualityAnalyzer_1 = require("./commitQualityAnalyzer");
+/**
+ * Filters commits by author(s) based on the provided filter
+ */
+function filterCommitsByAuthor(commits, filter) {
+    return commits.filter(commit => {
+        const authorLower = commit.author.toLowerCase();
+        const matches = filter.authors.some(filterAuthor => {
+            const filterLower = filterAuthor.toLowerCase();
+            if (filter.matchType === 'exact') {
+                return authorLower === filterLower;
+            }
+            else {
+                return authorLower.includes(filterLower);
+            }
+        });
+        return filter.mode === 'include' ? matches : !matches;
+    });
+}
+/**
+ * Parse author filter from CLI options
+ */
+function parseAuthorFilter(author, authors, excludeAuthor, excludeAuthors) {
+    // Include filters take precedence
+    if (author) {
+        return {
+            mode: 'include',
+            authors: [author],
+            matchType: 'partial',
+        };
+    }
+    if (authors) {
+        return {
+            mode: 'include',
+            authors: authors.split(',').map(a => a.trim()).filter(a => a.length > 0),
+            matchType: 'partial',
+        };
+    }
+    // Exclude filters
+    if (excludeAuthor) {
+        return {
+            mode: 'exclude',
+            authors: [excludeAuthor],
+            matchType: 'partial',
+        };
+    }
+    if (excludeAuthors) {
+        return {
+            mode: 'exclude',
+            authors: excludeAuthors.split(',').map(a => a.trim()).filter(a => a.length > 0),
+            matchType: 'partial',
+        };
+    }
+    return null;
+}
+/**
+ * Load team members from a file (one name per line)
+ */
+function loadTeamFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0 && !line.startsWith('#'));
+    }
+    catch (error) {
+        throw new Error(`Failed to load team file: ${error.message}`);
+    }
+}
+/**
+ * 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
+    const teamFilter = {
+        mode: 'include',
+        authors: teamMembers,
+        matchType: 'partial',
+    };
+    const teamCommits = filterCommitsByAuthor(commits, teamFilter);
+    // Calculate team metrics
+    const totalCommits = teamCommits.length;
+    const commitsPerMember = teamMembers.length > 0
+        ? Math.round((totalCommits / teamMembers.length) * 10) / 10
+        : 0;
+    // Active days
+    const activeDatesSet = new Set(teamCommits.map(c => {
+        const d = new Date(c.date);
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+    }));
+    const activeDays = activeDatesSet.size;
+    // Quality score
+    const qualityResult = (0, commitQualityAnalyzer_1.analyzeCommitQuality)(teamCommits, { skipBodyCheck });
+    const qualityScore = Math.round(qualityResult.overallScore * 10) / 10;
+    // Member breakdown
+    const memberBreakdown = calculateMemberBreakdown(teamCommits, teamMembers, skipBodyCheck);
+    // Load distribution
+    const loadDistribution = calculateLoadDistribution(memberBreakdown, totalCommits);
+    return {
+        teamName,
+        members: teamMembers,
+        teamMetrics: {
+            totalCommits,
+            commitsPerMember,
+            activeDays,
+            qualityScore,
+        },
+        memberBreakdown,
+        loadDistribution,
+    };
+}
+function calculateMemberBreakdown(commits, teamMembers, skipBodyCheck) {
+    const breakdown = [];
+    const totalCommits = commits.length;
+    // Build a map of author -> commits
+    const commitsByAuthor = new Map();
+    for (const commit of commits) {
+        const authorLower = commit.author.toLowerCase();
+        // Find the matching team member
+        const matchedMember = teamMembers.find(member => authorLower.includes(member.toLowerCase()));
+        if (matchedMember) {
+            if (!commitsByAuthor.has(matchedMember)) {
+                commitsByAuthor.set(matchedMember, []);
+            }
+            commitsByAuthor.get(matchedMember).push(commit);
+        }
+    }
+    // Calculate stats for each team member
+    for (const member of teamMembers) {
+        const memberCommits = commitsByAuthor.get(member) || [];
+        const commitCount = memberCommits.length;
+        const percentage = totalCommits > 0
+            ? Math.round((commitCount / totalCommits) * 1000) / 10
+            : 0;
+        // Active days for this member
+        const memberActiveDates = new Set(memberCommits.map(c => {
+            const d = new Date(c.date);
+            return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+        }));
+        // Quality score for this member
+        const qualityResult = memberCommits.length > 0
+            ? (0, commitQualityAnalyzer_1.analyzeCommitQuality)(memberCommits, { skipBodyCheck })
+            : { overallScore: 0 };
+        // Top areas (directories)
+        const areaCounts = new Map();
+        for (const commit of memberCommits) {
+            // Extract directory from commit message if available (heuristic)
+            // In a real implementation, this would use file change data
+            const match = commit.message.match(/^(?:feat|fix|docs|refactor|test|chore)\(([^)]+)\)/i);
+            if (match) {
+                const area = match[1];
+                areaCounts.set(area, (areaCounts.get(area) || 0) + 1);
+            }
+        }
+        const topAreas = [...areaCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([area]) => area);
+        breakdown.push({
+            author: member,
+            commits: commitCount,
+            percentage,
+            activeDays: memberActiveDates.size,
+            qualityScore: Math.round(qualityResult.overallScore * 10) / 10,
+            topAreas,
+        });
+    }
+    // Sort by commits descending
+    breakdown.sort((a, b) => b.commits - a.commits);
+    return breakdown;
+}
+function calculateLoadDistribution(memberBreakdown, totalCommits) {
+    const insights = [];
+    if (memberBreakdown.length === 0 || totalCommits === 0) {
+        return {
+            giniCoefficient: 0,
+            assessment: 'balanced',
+            insights: ['No team data available'],
+        };
+    }
+    // Calculate Gini coefficient for commit distribution
+    const commitCounts = memberBreakdown.map(m => m.commits).sort((a, b) => a - b);
+    const n = commitCounts.length;
+    let giniNumerator = 0;
+    for (let i = 0; i < n; i++) {
+        giniNumerator += (2 * (i + 1) - n - 1) * commitCounts[i];
+    }
+    const giniCoefficient = n > 1
+        ? Math.round((giniNumerator / (n * totalCommits)) * 100) / 100
+        : 0;
+    // Determine assessment
+    let assessment;
+    if (giniCoefficient <= 0.3) {
+        assessment = 'balanced';
+        insights.push('Work is distributed fairly evenly across team members');
+    }
+    else if (giniCoefficient <= 0.5) {
+        assessment = 'moderate-imbalance';
+        insights.push('Some team members are contributing significantly more than others');
+    }
+    else {
+        assessment = 'high-imbalance';
+        insights.push('Work is heavily concentrated among a few team members');
+    }
+    // Additional insights
+    const topContributor = memberBreakdown[0];
+    if (topContributor && topContributor.percentage > 50) {
+        insights.push(`${topContributor.author} accounts for ${topContributor.percentage}% of all commits`);
+    }
+    const inactiveMembers = memberBreakdown.filter(m => m.commits === 0);
+    if (inactiveMembers.length > 0) {
+        insights.push(`${inactiveMembers.length} team member(s) have no commits in this period`);
+    }
+    return {
+        giniCoefficient,
+        assessment,
+        insights,
+    };
+}
+/**
+ * Format team analysis for display
+ */
+function formatTeamInsights(analysis) {
+    const insights = [];
+    const teamLabel = analysis.teamName || 'Team';
+    insights.push(`👥 ${teamLabel} Analysis (${analysis.members.length} members)`);
+    insights.push('');
+    // Team metrics
+    insights.push(`📊 Total commits: ${analysis.teamMetrics.totalCommits}`);
+    insights.push(`📅 Active days: ${analysis.teamMetrics.activeDays}`);
+    insights.push(`⚡ Avg commits/member: ${analysis.teamMetrics.commitsPerMember}`);
+    insights.push(`✨ Quality score: ${analysis.teamMetrics.qualityScore}/10`);
+    insights.push('');
+    // Load distribution
+    const loadEmoji = {
+        'balanced': '🟢',
+        'moderate-imbalance': '🟡',
+        'high-imbalance': '🔴',
+    }[analysis.loadDistribution.assessment];
+    insights.push(`${loadEmoji} Load distribution: ${analysis.loadDistribution.assessment} (Gini: ${analysis.loadDistribution.giniCoefficient})`);
+    for (const insight of analysis.loadDistribution.insights) {
+        insights.push(`  • ${insight}`);
+    }
+    insights.push('');
+    // Member breakdown (top 5)
+    insights.push('👤 Member breakdown:');
+    for (const member of analysis.memberBreakdown.slice(0, 5)) {
+        const areas = member.topAreas.length > 0 ? ` [${member.topAreas.join(', ')}]` : '';
+        insights.push(`  • ${member.author}: ${member.commits} commits (${member.percentage}%)${areas}`);
+    }
+    if (analysis.memberBreakdown.length > 5) {
+        insights.push(`  ... and ${analysis.memberBreakdown.length - 5} more`);
+    }
+    return insights;
+}

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeVelocity = analyzeVelocity;
+exports.formatVelocityInsights = formatVelocityInsights;
+const date_fns_1 = require("date-fns");
+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 (0, emptyResults_1.getEmptyVelocityAnalysis)();
+    }
+    // Build weekly data points
+    const timeline = buildWeeklyTimeline(commits, start, end);
+    // Calculate rolling averages
+    calculateRollingAverages(timeline, windowWeeks);
+    // Detect anomalies
+    const anomalies = detectAnomalies(timeline);
+    // Calculate overall trend
+    const { trend, trendPercentage } = calculateTrend(timeline);
+    // Find peak and lowest weeks
+    const peakWeek = findPeakWeek(timeline);
+    const lowestWeek = findLowestWeek(timeline);
+    // Calculate average
+    const totalCommits = timeline.reduce((sum, dp) => sum + dp.commits, 0);
+    const averageCommitsPerWeek = timeline.length > 0 ? totalCommits / timeline.length : 0;
+    return {
+        timeline,
+        overallTrend: trend,
+        trendPercentage,
+        averageCommitsPerWeek: Math.round(averageCommitsPerWeek * 10) / 10,
+        peakWeek,
+        lowestWeek,
+        anomalies,
+    };
+}
+function buildWeeklyTimeline(commits, startDate, endDate) {
+    const timeline = [];
+    const weekCount = (0, date_fns_1.differenceInWeeks)(endDate, startDate) + 1;
+    // Create a map for quick commit lookup by week
+    const commitsByWeek = new Map();
+    for (const commit of commits) {
+        const commitDate = new Date(commit.date);
+        const weekStart = (0, date_fns_1.startOfWeek)(commitDate, { weekStartsOn: 1 });
+        const weekKey = (0, date_fns_1.format)(weekStart, 'yyyy-MM-dd');
+        if (!commitsByWeek.has(weekKey)) {
+            commitsByWeek.set(weekKey, []);
+        }
+        commitsByWeek.get(weekKey).push(commit);
+    }
+    // Build timeline for each week
+    let currentWeekStart = (0, date_fns_1.startOfWeek)(startDate, { weekStartsOn: 1 });
+    for (let i = 0; i < weekCount && currentWeekStart <= endDate; i++) {
+        const weekEnd = (0, date_fns_1.endOfWeek)(currentWeekStart, { weekStartsOn: 1 });
+        const weekKey = (0, date_fns_1.format)(currentWeekStart, 'yyyy-MM-dd');
+        const weekCommits = commitsByWeek.get(weekKey) || [];
+        const authors = [...new Set(weekCommits.map(c => c.author))];
+        // For now, we don't have line stats in CommitData, so we'll use 0
+        // This could be enhanced later by parsing git diff stats
+        timeline.push({
+            weekStart: new Date(currentWeekStart),
+            weekEnd: new Date(weekEnd),
+            commits: weekCommits.length,
+            linesAdded: 0,
+            linesDeleted: 0,
+            filesChanged: 0,
+            authors,
+            rollingAverage: 0, // Will be calculated later
+        });
+        currentWeekStart = (0, date_fns_1.addWeeks)(currentWeekStart, 1);
+    }
+    return timeline;
+}
+function calculateRollingAverages(timeline, windowWeeks) {
+    for (let i = 0; i < timeline.length; i++) {
+        const windowStart = Math.max(0, i - windowWeeks + 1);
+        const windowEnd = i + 1;
+        const window = timeline.slice(windowStart, windowEnd);
+        const sum = window.reduce((acc, dp) => acc + dp.commits, 0);
+        timeline[i].rollingAverage = Math.round((sum / window.length) * 10) / 10;
+    }
+}
+function detectAnomalies(timeline) {
+    const anomalies = [];
+    if (timeline.length < 3) {
+        return anomalies;
+    }
+    for (let i = 1; i < timeline.length; i++) {
+        const current = timeline[i];
+        const rollingAvg = timeline[i - 1].rollingAverage;
+        if (rollingAvg === 0) {
+            if (current.commits === 0) {
+                anomalies.push({
+                    weekStart: current.weekStart,
+                    type: 'zero-activity',
+                    severity: 'significant',
+                    percentageChange: -100,
+                    possibleCauses: ['Holiday period', 'Team blocked', 'Sprint planning', 'Vacation'],
+                });
+            }
+            continue;
+        }
+        const percentageChange = ((current.commits - rollingAvg) / rollingAvg) * 100;
+        // Detect drops
+        if (percentageChange <= -60) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'drop',
+                severity: 'critical',
+                percentageChange: Math.round(percentageChange),
+                possibleCauses: ['Major blocker', 'Team disruption', 'Holiday/vacation', 'Context switching'],
+            });
+        }
+        else if (percentageChange <= -40) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'drop',
+                severity: 'significant',
+                percentageChange: Math.round(percentageChange),
+                possibleCauses: ['Potential blocker', 'Reduced capacity', 'Complex work'],
+            });
+        }
+        else if (percentageChange <= -20) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'drop',
+                severity: 'minor',
+                percentageChange: Math.round(percentageChange),
+                possibleCauses: ['Normal variance', 'Focus on larger tasks'],
+            });
+        }
+        // Detect spikes
+        if (percentageChange >= 100) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'spike',
+                severity: 'significant',
+                percentageChange: Math.round(percentageChange),
+                possibleCauses: ['Release push', 'Catch-up after blocker', 'New team members'],
+            });
+        }
+        else if (percentageChange >= 50) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'spike',
+                severity: 'minor',
+                percentageChange: Math.round(percentageChange),
+                possibleCauses: ['Productive week', 'Smaller tasks'],
+            });
+        }
+        // Zero activity detection
+        if (current.commits === 0) {
+            anomalies.push({
+                weekStart: current.weekStart,
+                type: 'zero-activity',
+                severity: 'critical',
+                percentageChange: -100,
+                possibleCauses: ['Holiday period', 'Team blocked', 'Vacation', 'Sprint transition'],
+            });
+        }
+    }
+    return anomalies;
+}
+function calculateTrend(timeline) {
+    if (timeline.length < 4) {
+        return { trend: 'stable', trendPercentage: 0 };
+    }
+    // Compare first quarter to last quarter of the timeline
+    const quarterSize = Math.max(1, Math.floor(timeline.length / 4));
+    const firstQuarter = timeline.slice(0, quarterSize);
+    const lastQuarter = timeline.slice(-quarterSize);
+    const firstAvg = firstQuarter.reduce((sum, dp) => sum + dp.commits, 0) / firstQuarter.length;
+    const lastAvg = lastQuarter.reduce((sum, dp) => sum + dp.commits, 0) / lastQuarter.length;
+    if (firstAvg === 0) {
+        return { trend: lastAvg > 0 ? 'increasing' : 'stable', trendPercentage: 100 };
+    }
+    const percentageChange = ((lastAvg - firstAvg) / firstAvg) * 100;
+    // Check for volatility (high variance)
+    const allCommits = timeline.map(dp => dp.commits);
+    const mean = allCommits.reduce((a, b) => a + b, 0) / allCommits.length;
+    const variance = allCommits.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / allCommits.length;
+    const coefficientOfVariation = mean > 0 ? (Math.sqrt(variance) / mean) * 100 : 0;
+    if (coefficientOfVariation > 80) {
+        return { trend: 'volatile', trendPercentage: Math.round(percentageChange) };
+    }
+    if (percentageChange > 15) {
+        return { trend: 'increasing', trendPercentage: Math.round(percentageChange) };
+    }
+    else if (percentageChange < -15) {
+        return { trend: 'decreasing', trendPercentage: Math.round(percentageChange) };
+    }
+    return { trend: 'stable', trendPercentage: Math.round(percentageChange) };
+}
+function findPeakWeek(timeline) {
+    if (timeline.length === 0) {
+        return { weekStart: new Date(), commits: 0 };
+    }
+    const peak = timeline.reduce((max, dp) => dp.commits > max.commits ? dp : max, timeline[0]);
+    return { weekStart: peak.weekStart, commits: peak.commits };
+}
+function findLowestWeek(timeline) {
+    if (timeline.length === 0) {
+        return { weekStart: new Date(), commits: 0 };
+    }
+    // Find lowest non-zero week, or zero if all are zero
+    const nonZeroWeeks = timeline.filter(dp => dp.commits > 0);
+    if (nonZeroWeeks.length === 0) {
+        return { weekStart: timeline[0].weekStart, commits: 0 };
+    }
+    const lowest = nonZeroWeeks.reduce((min, dp) => dp.commits < min.commits ? dp : min, nonZeroWeeks[0]);
+    return { weekStart: lowest.weekStart, commits: lowest.commits };
+}
+/**
+ * Format velocity analysis for display
+ */
+function formatVelocityInsights(analysis) {
+    const insights = [];
+    if (analysis.timeline.length === 0) {
+        return ['No velocity data available'];
+    }
+    // Trend insight
+    const trendDirection = analysis.trendPercentage >= 0 ? 'up' : 'down';
+    const trendEmoji = analysis.overallTrend === 'increasing' ? '📈' :
+        analysis.overallTrend === 'decreasing' ? '📉' :
+            analysis.overallTrend === 'volatile' ? '📊' : '➡️';
+    insights.push(`${trendEmoji} Velocity trend: ${analysis.overallTrend} (${trendDirection === 'up' ? '+' : ''}${analysis.trendPercentage}%)`);
+    insights.push(`📊 Average: ${analysis.averageCommitsPerWeek} commits/week`);
+    // Peak week
+    const peakDate = (0, date_fns_1.format)(analysis.peakWeek.weekStart, 'MMM d, yyyy');
+    insights.push(`🚀 Peak week: ${peakDate} (${analysis.peakWeek.commits} commits)`);
+    // Anomalies summary
+    const criticalDrops = analysis.anomalies.filter(a => a.type === 'drop' && a.severity === 'critical');
+    const zeroWeeks = analysis.anomalies.filter(a => a.type === 'zero-activity');
+    if (criticalDrops.length > 0) {
+        insights.push(`⚠️ ${criticalDrops.length} critical productivity drop(s) detected`);
+    }
+    if (zeroWeeks.length > 0) {
+        insights.push(`🚫 ${zeroWeeks.length} week(s) with zero activity`);
+    }
+    return insights;
+}

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,