repo-wrapped 0.0.6 → 0.0.9

package/dist/utils/executiveSummaryGenerator.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExecutiveSummary = generateExecutiveSummary;
+exports.formatExecutiveSummary = formatExecutiveSummary;
+const date_fns_1 = require("date-fns");
+/**
+ * Generates an executive summary with KPIs, insights, and risks
+ */
+function generateExecutiveSummary(input) {
+    const { commits, startDate, endDate, repoName, streakData, timePattern, commitQuality, knowledgeDistribution, velocityAnalysis, gapAnalysis, } = input;
+    const kpis = generateKPIs(commits, startDate, endDate, streakData, commitQuality, velocityAnalysis);
+    const keyInsights = generateKeyInsights(commits, streakData, timePattern, commitQuality, velocityAnalysis, gapAnalysis);
+    const risks = assessRisks(knowledgeDistribution, gapAnalysis, commitQuality, timePattern);
+    const recommendations = generateRecommendations(risks, keyInsights, commitQuality);
+    return {
+        generatedAt: new Date(),
+        period: { start: startDate, end: endDate },
+        repoName,
+        kpis,
+        keyInsights,
+        risks,
+        recommendations,
+    };
+}
+function generateKPIs(commits, startDate, endDate, streakData, commitQuality, velocityAnalysis) {
+    const kpis = [];
+    const totalDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24)) + 1;
+    const totalWeeks = Math.max(1, Math.ceil(totalDays / 7));
+    // 1. Velocity KPI
+    const commitsPerWeek = Math.round((commits.length / totalWeeks) * 10) / 10;
+    const velocityTrend = velocityAnalysis?.overallTrend || 'stable';
+    const velocityTrendPct = velocityAnalysis?.trendPercentage || 0;
+    kpis.push({
+        name: 'Velocity',
+        value: `${commitsPerWeek}/week`,
+        trend: velocityTrend === 'increasing' ? 'up' : velocityTrend === 'decreasing' ? 'down' : 'stable',
+        trendValue: `${velocityTrendPct >= 0 ? '+' : ''}${velocityTrendPct}%`,
+        status: commitsPerWeek >= 10 ? 'green' : commitsPerWeek >= 5 ? 'yellow' : 'red',
+        benchmark: 'vs start of period',
+    });
+    // 2. Quality Score KPI
+    const qualityScore = Math.round(commitQuality.overallScore * 10) / 10;
+    kpis.push({
+        name: 'Quality Score',
+        value: `${qualityScore}/10`,
+        trend: qualityScore >= 7 ? 'up' : qualityScore >= 5 ? 'stable' : 'down',
+        trendValue: qualityScore >= 7 ? 'Good' : qualityScore >= 5 ? 'Fair' : 'Needs work',
+        status: qualityScore >= 7 ? 'green' : qualityScore >= 5 ? 'yellow' : 'red',
+    });
+    // 3. Active Contributors
+    const uniqueAuthors = new Set(commits.map(c => c.author)).size;
+    kpis.push({
+        name: 'Active Contributors',
+        value: uniqueAuthors,
+        trend: 'stable',
+        trendValue: `${uniqueAuthors} developer${uniqueAuthors !== 1 ? 's' : ''}`,
+        status: uniqueAuthors >= 3 ? 'green' : uniqueAuthors >= 2 ? 'yellow' : 'red',
+    });
+    // 4. Consistency
+    const consistencyPct = Math.round(streakData.activeDayPercentage);
+    kpis.push({
+        name: 'Consistency',
+        value: `${consistencyPct}%`,
+        trend: consistencyPct >= 50 ? 'up' : consistencyPct >= 30 ? 'stable' : 'down',
+        trendValue: `${streakData.totalActiveDays}/${totalDays} days active`,
+        status: consistencyPct >= 50 ? 'green' : consistencyPct >= 30 ? 'yellow' : 'red',
+    });
+    // 5. Longest Streak
+    kpis.push({
+        name: 'Best Streak',
+        value: `${streakData.longestStreak.days} days`,
+        trend: streakData.longestStreak.days >= 7 ? 'up' : 'stable',
+        trendValue: streakData.currentStreak.isActive ? 'Current active' : 'Historical',
+        status: streakData.longestStreak.days >= 14 ? 'green' : streakData.longestStreak.days >= 7 ? 'yellow' : 'red',
+    });
+    return kpis;
+}
+function generateKeyInsights(commits, streakData, timePattern, commitQuality, velocityAnalysis, gapAnalysis) {
+    const insights = [];
+    // Velocity insight
+    if (velocityAnalysis) {
+        if (velocityAnalysis.overallTrend === 'decreasing' && velocityAnalysis.trendPercentage <= -20) {
+            insights.push({
+                type: 'negative',
+                insight: `Velocity has decreased ${Math.abs(velocityAnalysis.trendPercentage)}% over this period`,
+            });
+        }
+        else if (velocityAnalysis.overallTrend === 'increasing' && velocityAnalysis.trendPercentage >= 20) {
+            insights.push({
+                type: 'positive',
+                insight: `Velocity has increased ${velocityAnalysis.trendPercentage}% over this period`,
+            });
+        }
+        // Anomalies
+        const criticalAnomalies = velocityAnalysis.anomalies.filter(a => a.severity === 'critical');
+        if (criticalAnomalies.length >= 2) {
+            insights.push({
+                type: 'negative',
+                insight: `${criticalAnomalies.length} critical productivity drops detected - potential blockers or disruptions`,
+            });
+        }
+    }
+    // Gap insight
+    if (gapAnalysis && gapAnalysis.gaps.length > 0) {
+        if (gapAnalysis.riskLevel === 'critical' || gapAnalysis.riskLevel === 'high') {
+            insights.push({
+                type: 'negative',
+                insight: `${gapAnalysis.totalGapDays} days lost to activity gaps (${gapAnalysis.percentageOfPeriodInGaps}% of period)`,
+            });
+        }
+    }
+    // Quality insight
+    if (commitQuality.overallScore >= 8) {
+        insights.push({
+            type: 'positive',
+            insight: 'Excellent commit quality with clear, well-structured messages',
+        });
+    }
+    else if (commitQuality.overallScore < 5) {
+        insights.push({
+            type: 'negative',
+            insight: `Commit quality score of ${Math.round(commitQuality.overallScore * 10) / 10}/10 indicates room for improvement`,
+        });
+    }
+    // Burnout insight
+    if (timePattern.burnoutRisk.level === 'high') {
+        insights.push({
+            type: 'negative',
+            insight: 'High burnout risk indicators detected (late nights, irregular hours)',
+        });
+    }
+    // Consistency insight
+    if (streakData.activeDayPercentage >= 60) {
+        insights.push({
+            type: 'positive',
+            insight: `Strong consistency with ${Math.round(streakData.activeDayPercentage)}% of days active`,
+        });
+    }
+    // Conventional commits
+    if (commitQuality.conventionalCommits.adherence >= 80) {
+        insights.push({
+            type: 'positive',
+            insight: `${Math.round(commitQuality.conventionalCommits.adherence)}% conventional commit adherence enables better automation`,
+        });
+    }
+    // Ensure we have at least 3 insights
+    if (insights.length < 3) {
+        insights.push({
+            type: 'neutral',
+            insight: `${commits.length} commits analyzed across ${streakData.totalActiveDays} active days`,
+        });
+    }
+    return insights.slice(0, 5);
+}
+function assessRisks(knowledgeDistribution, gapAnalysis, commitQuality, timePattern) {
+    const risks = [];
+    // Bus factor risk
+    if (knowledgeDistribution) {
+        const busFactorLevel = knowledgeDistribution.busFactorRisk.level;
+        if (busFactorLevel === 'critical' || busFactorLevel === 'high') {
+            risks.push({
+                category: 'Knowledge Distribution',
+                level: busFactorLevel === 'critical' ? 'high' : 'medium',
+                description: `Bus factor risk: ${knowledgeDistribution.knowledgeSilos.length} areas have single-owner knowledge`,
+            });
+        }
+    }
+    // Gap/blocker risk
+    if (gapAnalysis && gapAnalysis.riskLevel !== 'low') {
+        risks.push({
+            category: 'Productivity',
+            level: gapAnalysis.riskLevel === 'critical' ? 'high' : gapAnalysis.riskLevel,
+            description: `${gapAnalysis.gaps.length} activity gaps totaling ${gapAnalysis.totalGapDays} days of lost productivity`,
+        });
+    }
+    // Quality risk
+    if (commitQuality && commitQuality.overallScore < 5) {
+        risks.push({
+            category: 'Code Quality',
+            level: commitQuality.overallScore < 3 ? 'high' : 'medium',
+            description: 'Low commit quality may indicate rushed work or unclear requirements',
+        });
+    }
+    // Burnout risk
+    if (timePattern && timePattern.burnoutRisk.level === 'high') {
+        risks.push({
+            category: 'Team Health',
+            level: 'medium',
+            description: `Burnout indicators: ${timePattern.burnoutRisk.indicators.slice(0, 2).join(', ')}`,
+        });
+    }
+    // Sort by level
+    const levelOrder = { high: 0, medium: 1, low: 2 };
+    risks.sort((a, b) => levelOrder[a.level] - levelOrder[b.level]);
+    return risks;
+}
+function generateRecommendations(risks, insights, commitQuality) {
+    const recommendations = [];
+    // Based on risks
+    for (const risk of risks) {
+        if (risk.category === 'Knowledge Distribution') {
+            recommendations.push('Schedule knowledge sharing sessions to reduce bus factor risk');
+        }
+        else if (risk.category === 'Productivity') {
+            recommendations.push('Investigate root causes of activity gaps - potential blockers or process issues');
+        }
+        else if (risk.category === 'Code Quality') {
+            recommendations.push('Implement commit message guidelines and consider pre-commit hooks');
+        }
+        else if (risk.category === 'Team Health') {
+            recommendations.push('Review workload distribution and consider work-life balance initiatives');
+        }
+    }
+    // Quality-based recommendations
+    if (commitQuality.conventionalCommits.adherence < 50) {
+        recommendations.push('Adopt conventional commits standard for better changelog generation');
+    }
+    if (commitQuality.codeHygiene.workInProgress > commitQuality.totalCommits * 0.1) {
+        recommendations.push('Reduce WIP commits by encouraging atomic, complete changes');
+    }
+    // Ensure we have at least one recommendation
+    if (recommendations.length === 0) {
+        recommendations.push('Continue current practices - metrics are within healthy ranges');
+    }
+    return [...new Set(recommendations)].slice(0, 4);
+}
+/**
+ * Format executive summary for terminal display
+ */
+function formatExecutiveSummary(summary) {
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  📊 EXECUTIVE SUMMARY: ${summary.repoName}`);
+    lines.push(`  Period: ${(0, date_fns_1.format)(summary.period.start, 'MMM d, yyyy')} - ${(0, date_fns_1.format)(summary.period.end, 'MMM d, yyyy')}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    // KPIs
+    lines.push('📈 KEY PERFORMANCE INDICATORS');
+    lines.push('───────────────────────────────────────────────────────────────');
+    for (const kpi of summary.kpis) {
+        const statusEmoji = kpi.status === 'green' ? '🟢' : kpi.status === 'yellow' ? '🟡' : '🔴';
+        const trendEmoji = kpi.trend === 'up' ? '↑' : kpi.trend === 'down' ? '↓' : '→';
+        lines.push(`  ${statusEmoji} ${kpi.name}: ${kpi.value} ${trendEmoji} ${kpi.trendValue}`);
+    }
+    lines.push('');
+    // Key Insights
+    lines.push('💡 KEY INSIGHTS');
+    lines.push('───────────────────────────────────────────────────────────────');
+    for (const insight of summary.keyInsights) {
+        const emoji = insight.type === 'positive' ? '✅' : insight.type === 'negative' ? '⚠️' : 'ℹ️';
+        lines.push(`  ${emoji} ${insight.insight}`);
+    }
+    lines.push('');
+    // Risks
+    if (summary.risks.length > 0) {
+        lines.push('🚨 RISK ASSESSMENT');
+        lines.push('───────────────────────────────────────────────────────────────');
+        for (const risk of summary.risks) {
+            const levelEmoji = risk.level === 'high' ? '🔴' : risk.level === 'medium' ? '🟡' : '🟢';
+            lines.push(`  ${levelEmoji} [${risk.level.toUpperCase()}] ${risk.category}: ${risk.description}`);
+        }
+        lines.push('');
+    }
+    // Recommendations
+    lines.push('📋 RECOMMENDATIONS');
+    lines.push('───────────────────────────────────────────────────────────────');
+    for (let i = 0; i < summary.recommendations.length; i++) {
+        lines.push(`  ${i + 1}. ${summary.recommendations[i]}`);
+    }
+    lines.push('');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  Generated: ${(0, date_fns_1.format)(summary.generatedAt, 'MMM d, yyyy HH:mm')}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    return lines;
+}

package/dist/utils/fileHotspotAnalyzer.js

@@ -4,6 +4,7 @@ exports.analyzeFileHotspots = analyzeFileHotspots;
 exports.getRiskLevelColor = getRiskLevelColor;
 exports.getOwnershipIcon = getOwnershipIcon;
 const child_process_1 = require("child_process");
+const emptyResults_1 = require("./emptyResults");
 function analyzeFileHotspots(repoPath, startDate, endDate) {
     try {
         // Get file changes with author info from git log
@@ -15,10 +16,10 @@ function analyzeFileHotspots(repoPath, startDate, endDate) {
         }
         catch (gitError) {
             // Git command failed, likely not in a git repo or no commits in range
-            return getEmptyAnalysis();
+            return (0, emptyResults_1.getEmptyFileHotspotAnalysis)();
         }
         if (!gitLog) {
-            return getEmptyAnalysis();
+            return (0, emptyResults_1.getEmptyFileHotspotAnalysis)();
         }
         // Parse git log output
         const fileMap = new Map();
@@ -91,7 +92,7 @@ function analyzeFileHotspots(repoPath, startDate, endDate) {
     }
     catch (error) {
         console.error('Error analyzing file hotspots:', error);
-        return getEmptyAnalysis();
+        return (0, emptyResults_1.getEmptyFileHotspotAnalysis)();
     }
 }
 function shouldIgnoreFile(path) {
@@ -241,15 +242,6 @@ function analyzeOwnership(files) {
         .sort((a, b) => b.busFactorRisk - a.busFactorRisk)
         .slice(0, 10);
 }
-function getEmptyAnalysis() {
-    return {
-        topFiles: [],
-        topDirectories: [],
-        technicalDebt: [],
-        ownershipRisks: [],
-        totalFilesAnalyzed: 0
-    };
-}
 function getRiskLevelColor(level) {
     switch (level) {
         case 'critical': return '🔴';

package/dist/utils/gapAnalyzer.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeGaps = analyzeGaps;
+exports.formatGapInsights = formatGapInsights;
+const date_fns_1 = require("date-fns");
+const emptyResults_1 = require("./emptyResults");
+const analyzerContextBuilder_1 = require("./analyzerContextBuilder");
+function analyzeGaps(ctxOrCommits, startDate, endDate, thresholdDays = 3, excludeWeekends = false) {
+    // Normalize to internal variables
+    let commits;
+    let start;
+    let end;
+    let threshold;
+    let skipWeekends;
+    if ((0, analyzerContextBuilder_1.isAnalyzerContext)(ctxOrCommits)) {
+        commits = ctxOrCommits.commits;
+        start = ctxOrCommits.dateRange.start;
+        end = ctxOrCommits.dateRange.end;
+        threshold = (0, analyzerContextBuilder_1.getOption)(ctxOrCommits, 'thresholdDays', 3);
+        skipWeekends = (0, analyzerContextBuilder_1.getOption)(ctxOrCommits, 'excludeWeekends', false);
+    }
+    else {
+        commits = ctxOrCommits;
+        start = startDate;
+        end = endDate;
+        threshold = thresholdDays;
+        skipWeekends = excludeWeekends;
+    }
+    if (commits.length === 0) {
+        return (0, emptyResults_1.getEmptyGapAnalysis)(start, end);
+    }
+    // Sort commits by date
+    const sortedCommits = [...commits].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+    // Find all gaps
+    const gaps = findGaps(sortedCommits, start, end, threshold, skipWeekends);
+    // Calculate statistics
+    const totalGapDays = gaps.reduce((sum, gap) => sum + gap.durationDays, 0);
+    const totalPeriodDays = (0, date_fns_1.differenceInDays)(end, start) + 1;
+    const percentageOfPeriodInGaps = totalPeriodDays > 0
+        ? Math.round((totalGapDays / totalPeriodDays) * 1000) / 10
+        : 0;
+    const longestGap = gaps.length > 0
+        ? gaps.reduce((max, gap) => gap.durationDays > max.durationDays ? gap : max, gaps[0])
+        : null;
+    const averageGapLength = gaps.length > 0
+        ? Math.round((totalGapDays / gaps.length) * 10) / 10
+        : 0;
+    // Calculate gap frequency (gaps per month)
+    const months = totalPeriodDays / 30;
+    const gapFrequency = months > 0 ? Math.round((gaps.length / months) * 10) / 10 : 0;
+    // Detect patterns
+    const patterns = detectGapPatterns(gaps);
+    // Assess risk
+    const { riskLevel, riskFactors } = assessGapRisk(gaps, percentageOfPeriodInGaps, longestGap);
+    return {
+        gaps,
+        totalGapDays,
+        percentageOfPeriodInGaps,
+        longestGap,
+        averageGapLength,
+        gapFrequency,
+        patterns,
+        riskLevel,
+        riskFactors,
+    };
+}
+function findGaps(sortedCommits, startDate, endDate, thresholdDays, excludeWeekends) {
+    const gaps = [];
+    // Check gap from startDate to first commit
+    const firstCommitDate = new Date(sortedCommits[0].date);
+    const daysToFirstCommit = calculateDaysBetween(startDate, firstCommitDate, excludeWeekends);
+    if (daysToFirstCommit >= thresholdDays) {
+        gaps.push({
+            start: startDate,
+            end: (0, date_fns_1.addDays)(firstCommitDate, -1),
+            durationDays: daysToFirstCommit,
+            commitBefore: null,
+            commitAfter: {
+                date: firstCommitDate,
+                message: sortedCommits[0].message,
+                author: sortedCommits[0].author,
+            },
+            possibleType: classifyGap(startDate, (0, date_fns_1.addDays)(firstCommitDate, -1), daysToFirstCommit),
+        });
+    }
+    // Check gaps between commits
+    for (let i = 0; i < sortedCommits.length - 1; i++) {
+        const currentCommit = sortedCommits[i];
+        const nextCommit = sortedCommits[i + 1];
+        const currentDate = new Date(currentCommit.date);
+        const nextDate = new Date(nextCommit.date);
+        const daysBetween = calculateDaysBetween(currentDate, nextDate, excludeWeekends);
+        if (daysBetween >= thresholdDays) {
+            const gapStart = (0, date_fns_1.addDays)(currentDate, 1);
+            const gapEnd = (0, date_fns_1.addDays)(nextDate, -1);
+            gaps.push({
+                start: gapStart,
+                end: gapEnd,
+                durationDays: daysBetween,
+                commitBefore: {
+                    date: currentDate,
+                    message: currentCommit.message,
+                    author: currentCommit.author,
+                },
+                commitAfter: {
+                    date: nextDate,
+                    message: nextCommit.message,
+                    author: nextCommit.author,
+                },
+                possibleType: classifyGap(gapStart, gapEnd, daysBetween),
+            });
+        }
+    }
+    // Check gap from last commit to endDate
+    const lastCommit = sortedCommits[sortedCommits.length - 1];
+    const lastCommitDate = new Date(lastCommit.date);
+    const daysAfterLast = calculateDaysBetween(lastCommitDate, endDate, excludeWeekends);
+    if (daysAfterLast >= thresholdDays) {
+        gaps.push({
+            start: (0, date_fns_1.addDays)(lastCommitDate, 1),
+            end: endDate,
+            durationDays: daysAfterLast,
+            commitBefore: {
+                date: lastCommitDate,
+                message: lastCommit.message,
+                author: lastCommit.author,
+            },
+            commitAfter: null,
+            possibleType: classifyGap((0, date_fns_1.addDays)(lastCommitDate, 1), endDate, daysAfterLast),
+        });
+    }
+    return gaps;
+}
+function calculateDaysBetween(start, end, excludeWeekends) {
+    if (!excludeWeekends) {
+        return (0, date_fns_1.differenceInDays)(end, start);
+    }
+    let days = 0;
+    let current = new Date(start);
+    while (current < end) {
+        if (!(0, date_fns_1.isWeekend)(current)) {
+            days++;
+        }
+        current = (0, date_fns_1.addDays)(current, 1);
+    }
+    return days;
+}
+function classifyGap(start, end, durationDays) {
+    // Check if it's just a weekend
+    if (durationDays <= 2) {
+        const startIsWeekend = (0, date_fns_1.isWeekend)(start);
+        const endIsWeekend = (0, date_fns_1.isWeekend)(end);
+        if (startIsWeekend || endIsWeekend) {
+            return 'weekend';
+        }
+    }
+    // Check for common holiday periods (rough heuristics)
+    const startMonth = start.getMonth();
+    const startDay = start.getDate();
+    // Christmas/New Year period
+    if ((startMonth === 11 && startDay >= 20) || (startMonth === 0 && startDay <= 5)) {
+        return 'holiday';
+    }
+    // Summer vacation period (July-August) with longer gaps
+    if ((startMonth === 6 || startMonth === 7) && durationDays >= 5) {
+        return 'vacation';
+    }
+    // Longer gaps are more likely blockers
+    if (durationDays >= 7) {
+        return 'blocker';
+    }
+    return 'unknown';
+}
+function detectGapPatterns(gaps) {
+    const patterns = [];
+    if (gaps.length < 2) {
+        return patterns;
+    }
+    // Check for recurring patterns
+    const gapsByDayOfWeek = new Map();
+    for (const gap of gaps) {
+        const dayOfWeek = gap.start.getDay();
+        gapsByDayOfWeek.set(dayOfWeek, (gapsByDayOfWeek.get(dayOfWeek) || 0) + 1);
+    }
+    // Check if gaps tend to start on specific days (e.g., Mondays = after weekend extension)
+    for (const [day, count] of gapsByDayOfWeek) {
+        if (count >= 3 && count >= gaps.length * 0.4) {
+            const dayName = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][day];
+            patterns.push({
+                type: 'recurring-weekly',
+                description: `Gaps frequently start on ${dayName}s`,
+                occurrences: count,
+            });
+        }
+    }
+    // Check for blocker pattern (multiple unknown/blocker gaps)
+    const blockerGaps = gaps.filter(g => g.possibleType === 'blocker' || g.possibleType === 'unknown');
+    if (blockerGaps.length >= 3) {
+        patterns.push({
+            type: 'random',
+            description: `${blockerGaps.length} unexplained gaps detected - potential recurring blockers`,
+            occurrences: blockerGaps.length,
+        });
+    }
+    return patterns;
+}
+function assessGapRisk(gaps, percentageInGaps, longestGap) {
+    const riskFactors = [];
+    let riskScore = 0;
+    // Factor 1: Percentage of time in gaps
+    if (percentageInGaps >= 30) {
+        riskScore += 3;
+        riskFactors.push(`${percentageInGaps}% of time spent in activity gaps`);
+    }
+    else if (percentageInGaps >= 20) {
+        riskScore += 2;
+        riskFactors.push(`${percentageInGaps}% of time spent in activity gaps`);
+    }
+    else if (percentageInGaps >= 10) {
+        riskScore += 1;
+        riskFactors.push(`${percentageInGaps}% of time spent in activity gaps`);
+    }
+    // Factor 2: Longest gap duration
+    if (longestGap) {
+        if (longestGap.durationDays >= 21) {
+            riskScore += 3;
+            riskFactors.push(`Longest gap: ${longestGap.durationDays} days (3+ weeks)`);
+        }
+        else if (longestGap.durationDays >= 14) {
+            riskScore += 2;
+            riskFactors.push(`Longest gap: ${longestGap.durationDays} days (2+ weeks)`);
+        }
+        else if (longestGap.durationDays >= 7) {
+            riskScore += 1;
+            riskFactors.push(`Longest gap: ${longestGap.durationDays} days (1+ week)`);
+        }
+    }
+    // Factor 3: Number of blocker-type gaps
+    const blockerGaps = gaps.filter(g => g.possibleType === 'blocker');
+    if (blockerGaps.length >= 5) {
+        riskScore += 2;
+        riskFactors.push(`${blockerGaps.length} potential blocker gaps identified`);
+    }
+    else if (blockerGaps.length >= 2) {
+        riskScore += 1;
+        riskFactors.push(`${blockerGaps.length} potential blocker gaps identified`);
+    }
+    // Determine risk level
+    let riskLevel;
+    if (riskScore >= 6) {
+        riskLevel = 'critical';
+    }
+    else if (riskScore >= 4) {
+        riskLevel = 'high';
+    }
+    else if (riskScore >= 2) {
+        riskLevel = 'medium';
+    }
+    else {
+        riskLevel = 'low';
+    }
+    if (riskFactors.length === 0) {
+        riskFactors.push('No significant gap patterns detected');
+    }
+    return { riskLevel, riskFactors };
+}
+/**
+ * Format gap analysis for display
+ */
+function formatGapInsights(analysis) {
+    const insights = [];
+    if (analysis.gaps.length === 0) {
+        insights.push('✅ No significant activity gaps detected');
+        return insights;
+    }
+    // Summary
+    insights.push(`🕳️ ${analysis.gaps.length} activity gap(s) detected`);
+    insights.push(`📅 ${analysis.totalGapDays} total gap days (${analysis.percentageOfPeriodInGaps}% of period)`);
+    // Longest gap
+    if (analysis.longestGap) {
+        const startStr = (0, date_fns_1.format)(analysis.longestGap.start, 'MMM d');
+        const endStr = (0, date_fns_1.format)(analysis.longestGap.end, 'MMM d, yyyy');
+        insights.push(`⏱️ Longest gap: ${analysis.longestGap.durationDays} days (${startStr} - ${endStr})`);
+    }
+    // Risk assessment
+    const riskEmoji = {
+        low: '🟢',
+        medium: '🟡',
+        high: '🟠',
+        critical: '🔴',
+    }[analysis.riskLevel];
+    insights.push(`${riskEmoji} Risk level: ${analysis.riskLevel.toUpperCase()}`);
+    // Top risk factors
+    for (const factor of analysis.riskFactors.slice(0, 3)) {
+        insights.push(`  • ${factor}`);
+    }
+    return insights;
+}