repo-wrapped 0.0.7 → 0.0.9

package/dist/features/events/parser.js

@@ -0,0 +1,253 @@
+"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.loadEventsFile = loadEventsFile;
+exports.parseEventsInline = parseEventsInline;
+exports.correlateEventsWithMetrics = correlateEventsWithMetrics;
+exports.getEventTypeEmoji = getEventTypeEmoji;
+exports.getEventTypeColor = getEventTypeColor;
+exports.formatEventsInsights = formatEventsInsights;
+const fs = __importStar(require("fs"));
+const date_fns_1 = require("date-fns");
+const commit_quality_1 = require("../commit-quality");
+/**
+ * Load events from a JSON file
+ */
+function loadEventsFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Validate and transform
+        const events = (parsed.events || []).map((event) => ({
+            date: new Date(event.date),
+            label: event.label,
+            type: validateEventType(event.type),
+            description: event.description,
+        }));
+        return { events };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Events file not found: ${filePath}`);
+        }
+        throw new Error(`Failed to parse events file: ${error.message}`);
+    }
+}
+/**
+ * Parse inline events JSON
+ */
+function parseEventsInline(jsonStr) {
+    try {
+        const parsed = JSON.parse(jsonStr);
+        const events = (parsed.events || [parsed]).map((event) => ({
+            date: new Date(event.date),
+            label: event.label,
+            type: validateEventType(event.type),
+            description: event.description,
+        }));
+        return { events };
+    }
+    catch (error) {
+        throw new Error(`Failed to parse inline events JSON: ${error.message}`);
+    }
+}
+function validateEventType(type) {
+    const validTypes = ['disruption', 'attrition', 'growth', 'release', 'incident', 'external', 'custom'];
+    if (validTypes.includes(type)) {
+        return type;
+    }
+    return 'custom';
+}
+/**
+ * Calculate correlation between events and metrics changes
+ */
+function correlateEventsWithMetrics(events, commits, windowDays = 14, skipBodyCheck = true) {
+    return events.map(event => ({
+        ...event,
+        correlation: calculateEventCorrelation(event, commits, windowDays, skipBodyCheck),
+    }));
+}
+function calculateEventCorrelation(event, commits, windowDays, skipBodyCheck) {
+    const eventDate = event.date;
+    // Before period
+    const beforeStart = (0, date_fns_1.subDays)(eventDate, windowDays);
+    const beforeEnd = (0, date_fns_1.subDays)(eventDate, 1);
+    const beforeCommits = commits.filter(c => {
+        const d = new Date(c.date);
+        return d >= beforeStart && d <= beforeEnd;
+    });
+    // After period
+    const afterStart = (0, date_fns_1.addDays)(eventDate, 1);
+    const afterEnd = (0, date_fns_1.addDays)(eventDate, windowDays);
+    const afterCommits = commits.filter(c => {
+        const d = new Date(c.date);
+        return d >= afterStart && d <= afterEnd;
+    });
+    const metricsBefore = calculatePeriodMetrics(beforeCommits, beforeStart, beforeEnd, skipBodyCheck);
+    const metricsAfter = calculatePeriodMetrics(afterCommits, afterStart, afterEnd, skipBodyCheck);
+    // Calculate changes
+    const velocityChange = calculatePercentageChange(metricsBefore.commitsPerWeek ?? 0, metricsAfter.commitsPerWeek ?? 0);
+    const qualityChange = calculatePercentageChange(metricsBefore.qualityScore ?? 0, metricsAfter.qualityScore ?? 0);
+    const activeAuthorsChange = (metricsAfter.totalAuthors ?? 0) - (metricsBefore.totalAuthors ?? 0);
+    // Generate assessment
+    const assessment = generateAssessment(event, velocityChange, qualityChange, activeAuthorsChange);
+    return {
+        metricsBefore,
+        metricsAfter,
+        impact: {
+            velocityChange,
+            qualityChange,
+            activeAuthorsChange,
+        },
+        assessment,
+    };
+}
+function calculatePeriodMetrics(commits, startDate, endDate, skipBodyCheck) {
+    const days = (0, date_fns_1.differenceInDays)(endDate, startDate) + 1;
+    const weeks = Math.max(1, days / 7);
+    const totalCommits = commits.length;
+    const commitsPerWeek = Math.round((totalCommits / weeks) * 10) / 10;
+    const totalAuthors = new Set(commits.map(c => c.author)).size;
+    const qualityResult = commits.length > 0
+        ? (0, commit_quality_1.analyzeCommitQuality)(commits, { skipBodyCheck })
+        : { overallScore: 0 };
+    return {
+        totalCommits,
+        commitsPerWeek,
+        totalAuthors,
+        qualityScore: Math.round(qualityResult.overallScore * 10) / 10,
+    };
+}
+function calculatePercentageChange(before, after) {
+    if (before === 0) {
+        return after > 0 ? 100 : 0;
+    }
+    return Math.round(((after - before) / before) * 1000) / 10;
+}
+function generateAssessment(event, velocityChange, qualityChange, authorChange) {
+    const parts = [];
+    const eventLabel = `"${event.label}"`;
+    if (velocityChange <= -30) {
+        parts.push(`velocity dropped ${Math.abs(velocityChange)}%`);
+    }
+    else if (velocityChange >= 30) {
+        parts.push(`velocity increased ${velocityChange}%`);
+    }
+    if (qualityChange <= -20) {
+        parts.push(`quality decreased ${Math.abs(qualityChange)}%`);
+    }
+    else if (qualityChange >= 20) {
+        parts.push(`quality improved ${qualityChange}%`);
+    }
+    if (authorChange < 0) {
+        parts.push(`${Math.abs(authorChange)} fewer active contributor(s)`);
+    }
+    else if (authorChange > 0) {
+        parts.push(`${authorChange} more active contributor(s)`);
+    }
+    if (parts.length === 0) {
+        return `No significant metric changes detected after ${eventLabel}`;
+    }
+    return `After ${eventLabel}: ${parts.join(', ')}`;
+}
+/**
+ * Get emoji for event type
+ */
+function getEventTypeEmoji(type) {
+    const emojis = {
+        disruption: '⚡',
+        attrition: '👋',
+        growth: '🌱',
+        release: '🚀',
+        incident: '🔥',
+        external: '📅',
+        custom: '📌',
+    };
+    return emojis[type] || '📌';
+}
+/**
+ * Get color for event type (for HTML)
+ */
+function getEventTypeColor(type) {
+    const colors = {
+        disruption: '#ff6b6b',
+        attrition: '#ffa94d',
+        growth: '#69db7c',
+        release: '#4dabf7',
+        incident: '#ff8787',
+        external: '#868e96',
+        custom: '#9775fa',
+    };
+    return colors[type] || '#9775fa';
+}
+/**
+ * Format events for display
+ */
+function formatEventsInsights(events) {
+    const insights = [];
+    if (events.length === 0) {
+        return ['No events annotated'];
+    }
+    insights.push(`📅 ${events.length} Event(s) Annotated`);
+    insights.push('');
+    // Sort by date
+    const sortedEvents = [...events].sort((a, b) => a.date.getTime() - b.date.getTime());
+    for (const event of sortedEvents) {
+        const emoji = getEventTypeEmoji(event.type);
+        const dateStr = (0, date_fns_1.format)(event.date, 'MMM d, yyyy');
+        insights.push(`${emoji} ${dateStr}: ${event.label}`);
+        if (event.description) {
+            insights.push(`   ${event.description}`);
+        }
+        if (event.correlation) {
+            const { impact } = event.correlation;
+            const impactParts = [];
+            if (Math.abs(impact.velocityChange) >= 10) {
+                impactParts.push(`velocity ${impact.velocityChange >= 0 ? '+' : ''}${impact.velocityChange}%`);
+            }
+            if (Math.abs(impact.qualityChange) >= 10) {
+                impactParts.push(`quality ${impact.qualityChange >= 0 ? '+' : ''}${impact.qualityChange}%`);
+            }
+            if (impact.activeAuthorsChange !== 0) {
+                impactParts.push(`${impact.activeAuthorsChange >= 0 ? '+' : ''}${impact.activeAuthorsChange} contributors`);
+            }
+            if (impactParts.length > 0) {
+                insights.push(`   📊 Impact: ${impactParts.join(', ')}`);
+            }
+        }
+        insights.push('');
+    }
+    return insights;
+}

package/dist/features/events/template.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEventsSection = buildEventsSection;
+const date_fns_1 = require("date-fns");
+const EVENT_ICONS = {
+    disruption: '⚠️',
+    attrition: '👋',
+    growth: '🌱',
+    release: '🚀',
+    incident: '🔥',
+    external: '📅',
+    custom: '📌'
+};
+const EVENT_COLORS = {
+    disruption: '#f59e0b',
+    attrition: '#ef4444',
+    growth: '#10b981',
+    release: '#3b82f6',
+    incident: '#dc2626',
+    external: '#6b7280',
+    custom: '#8b5cf6'
+};
+function buildEventsSection(events) {
+    if (!events || events.length === 0) {
+        return '<p class="no-data">No events annotated</p>';
+    }
+    const sortedEvents = [...events].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+    return `
+    <div class="events-section">
+      <!-- Event Legend -->
+      <div class="events-legend">
+        ${Object.entries(EVENT_ICONS).map(([type, icon]) => `
+          <span class="legend-item">
+            <span class="event-icon">${icon}</span>
+            <span class="legend-label">${type}</span>
+          </span>
+        `).join('')}
+      </div>
+
+      <!-- Event Stats Summary -->
+      <div class="events-summary">
+        <div class="summary-stat">
+          <span class="stat-value">${events.length}</span>
+          <span class="stat-label">Total Events</span>
+        </div>
+        ${buildEventTypeCounts(events)}
+      </div>
+
+      <!-- Events Timeline -->
+      <div class="events-timeline">
+        ${sortedEvents.map(event => buildEventCard(event)).join('')}
+      </div>
+    </div>
+  `;
+}
+function buildEventTypeCounts(events) {
+    const counts = events.reduce((acc, e) => {
+        acc[e.type] = (acc[e.type] || 0) + 1;
+        return acc;
+    }, {});
+    const topTypes = Object.entries(counts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3);
+    return topTypes.map(([type, count]) => `
+    <div class="summary-stat">
+      <span class="stat-value">${EVENT_ICONS[type] || '📌'} ${count}</span>
+      <span class="stat-label">${type}</span>
+    </div>
+  `).join('');
+}
+function buildEventCard(event) {
+    const icon = EVENT_ICONS[event.type] || '📌';
+    const color = EVENT_COLORS[event.type] || '#6b7280';
+    const dateStr = (0, date_fns_1.format)(new Date(event.date), 'MMM d, yyyy');
+    let correlationHtml = '';
+    if (event.correlation) {
+        const { velocityChange, qualityChange, activeAuthorsChange } = event.correlation.impact;
+        correlationHtml = `
+      <div class="event-correlation">
+        <div class="correlation-metrics">
+          <div class="correlation-metric ${velocityChange >= 0 ? 'positive' : 'negative'}">
+            <span class="metric-label">Velocity</span>
+            <span class="metric-value">${velocityChange >= 0 ? '+' : ''}${velocityChange.toFixed(0)}%</span>
+          </div>
+          <div class="correlation-metric ${qualityChange >= 0 ? 'positive' : 'negative'}">
+            <span class="metric-label">Quality</span>
+            <span class="metric-value">${qualityChange >= 0 ? '+' : ''}${qualityChange.toFixed(1)}</span>
+          </div>
+          <div class="correlation-metric ${activeAuthorsChange >= 0 ? 'positive' : 'negative'}">
+            <span class="metric-label">Contributors</span>
+            <span class="metric-value">${activeAuthorsChange >= 0 ? '+' : ''}${activeAuthorsChange}</span>
+          </div>
+        </div>
+        <div class="correlation-assessment">
+          <span class="assessment-icon">💡</span>
+          ${event.correlation.assessment}
+        </div>
+      </div>
+    `;
+    }
+    return `
+    <div class="event-card" style="--event-color: ${color}">
+      <div class="event-header">
+        <span class="event-icon">${icon}</span>
+        <span class="event-date">${dateStr}</span>
+        <span class="event-type-badge">${event.type}</span>
+      </div>
+      <div class="event-label">${event.label}</div>
+      ${event.description ? `<div class="event-description">${event.description}</div>` : ''}
+      ${correlationHtml}
+    </div>
+  `;
+}

package/dist/features/events/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/features/executive-summary/generator.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/features/executive-summary/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExecutiveSummarySection = exports.formatExecutiveSummary = exports.generateExecutiveSummary = void 0;
+/**
+ * Executive Summary Feature
+ * @module features/executive-summary
+ */
+__exportStar(require("./types"), exports);
+var generator_1 = require("./generator");
+Object.defineProperty(exports, "generateExecutiveSummary", { enumerable: true, get: function () { return generator_1.generateExecutiveSummary; } });
+Object.defineProperty(exports, "formatExecutiveSummary", { enumerable: true, get: function () { return generator_1.formatExecutiveSummary; } });
+var template_1 = require("./template");
+Object.defineProperty(exports, "buildExecutiveSummarySection", { enumerable: true, get: function () { return template_1.buildExecutiveSummarySection; } });