repo-wrapped 0.0.7 → 0.0.9

package/dist/features/gaps/template.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGapSection = buildGapSection;
+const date_fns_1 = require("date-fns");
+function buildGapSection(gapAnalysis) {
+    const statsHtml = buildGapStats(gapAnalysis);
+    const timelineHtml = buildGapTimeline(gapAnalysis);
+    const gapsListHtml = buildGapsList(gapAnalysis.gaps);
+    return `
+    <div class="gap-section">
+      <h2>🕳️ Gap & Blocker Analysis</h2>
+      
+      ${statsHtml}
+      
+      ${timelineHtml}
+      
+      ${gapsListHtml}
+    </div>
+  `;
+}
+function buildGapStats(gapAnalysis) {
+    const riskColors = {
+        low: '#69db7c',
+        medium: '#ffd43b',
+        high: '#ff922b',
+        critical: '#ff6b6b',
+    };
+    const riskEmoji = {
+        low: '🟢',
+        medium: '🟡',
+        high: '🟠',
+        critical: '🔴',
+    };
+    return `
+    <div class="gap-stats">
+      <div class="gap-stat-card">
+        <div class="stat-icon">🕳️</div>
+        <div class="stat-info">
+          <div class="stat-label">Total Gaps</div>
+          <div class="stat-value">${gapAnalysis.gaps.length}</div>
+          <div class="stat-detail">${gapAnalysis.gapFrequency}/month avg</div>
+        </div>
+      </div>
+      <div class="gap-stat-card">
+        <div class="stat-icon">📅</div>
+        <div class="stat-info">
+          <div class="stat-label">Gap Days</div>
+          <div class="stat-value">${gapAnalysis.totalGapDays}</div>
+          <div class="stat-detail">${gapAnalysis.percentageOfPeriodInGaps}% of period</div>
+        </div>
+      </div>
+      <div class="gap-stat-card">
+        <div class="stat-icon">⏱️</div>
+        <div class="stat-info">
+          <div class="stat-label">Longest Gap</div>
+          <div class="stat-value">${gapAnalysis.longestGap?.durationDays || 0} days</div>
+          <div class="stat-detail">avg: ${gapAnalysis.averageGapLength} days</div>
+        </div>
+      </div>
+      <div class="gap-stat-card risk-card" style="--risk-color: ${riskColors[gapAnalysis.riskLevel]}">
+        <div class="stat-icon">${riskEmoji[gapAnalysis.riskLevel]}</div>
+        <div class="stat-info">
+          <div class="stat-label">Risk Level</div>
+          <div class="stat-value risk-${gapAnalysis.riskLevel}">${gapAnalysis.riskLevel.toUpperCase()}</div>
+        </div>
+      </div>
+    </div>
+    
+    ${gapAnalysis.riskFactors.length > 0 ? `
+      <div class="risk-factors">
+        <h4>Risk Factors</h4>
+        <ul>
+          ${gapAnalysis.riskFactors.map(f => `<li>${f}</li>`).join('')}
+        </ul>
+      </div>
+    ` : ''}
+  `;
+}
+function buildGapTimeline(gapAnalysis) {
+    if (gapAnalysis.gaps.length === 0) {
+        return `
+      <div class="gap-timeline-container">
+        <h3>Activity Timeline</h3>
+        <div class="no-gaps-message">
+          <span class="success-icon">✅</span>
+          <span>No significant activity gaps detected</span>
+        </div>
+      </div>
+    `;
+    }
+    // Find the full date range
+    const allDates = gapAnalysis.gaps.flatMap(g => [g.start, g.end]);
+    const minDate = new Date(Math.min(...allDates.map(d => d.getTime())));
+    const maxDate = new Date(Math.max(...allDates.map(d => d.getTime())));
+    const totalDays = Math.ceil((maxDate.getTime() - minDate.getTime()) / (1000 * 60 * 60 * 24)) + 1;
+    if (totalDays <= 0) {
+        return '';
+    }
+    // Build gap segments
+    const segments = gapAnalysis.gaps.map(gap => {
+        const startOffset = Math.ceil((gap.start.getTime() - minDate.getTime()) / (1000 * 60 * 60 * 24));
+        const width = gap.durationDays;
+        const leftPercent = (startOffset / totalDays) * 100;
+        const widthPercent = (width / totalDays) * 100;
+        const typeClass = gap.possibleType === 'blocker' ? 'blocker' :
+            gap.possibleType === 'vacation' ? 'vacation' :
+                gap.possibleType === 'holiday' ? 'holiday' : 'unknown';
+        return `
+      <div class="gap-segment ${typeClass}" 
+           style="left: ${leftPercent}%; width: ${widthPercent}%"
+           title="${gap.durationDays} days - ${gap.possibleType}">
+      </div>
+    `;
+    }).join('');
+    return `
+    <div class="gap-timeline-container">
+      <h3>Activity Timeline</h3>
+      <div class="gap-timeline">
+        <div class="timeline-track">
+          ${segments}
+        </div>
+        <div class="timeline-labels">
+          <span>${(0, date_fns_1.format)(minDate, 'MMM d, yyyy')}</span>
+          <span>${(0, date_fns_1.format)(maxDate, 'MMM d, yyyy')}</span>
+        </div>
+      </div>
+      <div class="timeline-legend">
+        <span class="legend-item"><span class="legend-color blocker"></span> Potential Blocker</span>
+        <span class="legend-item"><span class="legend-color vacation"></span> Vacation</span>
+        <span class="legend-item"><span class="legend-color holiday"></span> Holiday</span>
+        <span class="legend-item"><span class="legend-color unknown"></span> Unknown</span>
+      </div>
+    </div>
+  `;
+}
+function buildGapsList(gaps) {
+    if (gaps.length === 0) {
+        return '';
+    }
+    // Sort by duration descending, take top 5
+    const sortedGaps = [...gaps].sort((a, b) => b.durationDays - a.durationDays).slice(0, 5);
+    const gapItems = sortedGaps.map(gap => {
+        const typeEmoji = {
+            blocker: '🚧',
+            vacation: '🏖️',
+            holiday: '🎄',
+            weekend: '📅',
+            unknown: '❓',
+        };
+        return `
+      <div class="gap-item">
+        <div class="gap-item-header">
+          <span class="gap-type-icon">${typeEmoji[gap.possibleType]}</span>
+          <span class="gap-duration">${gap.durationDays} days</span>
+          <span class="gap-type-badge ${gap.possibleType}">${gap.possibleType}</span>
+        </div>
+        <div class="gap-dates">
+          ${(0, date_fns_1.format)(gap.start, 'MMM d')} - ${(0, date_fns_1.format)(gap.end, 'MMM d, yyyy')}
+        </div>
+        <div class="gap-context">
+          ${gap.commitBefore ? `
+            <div class="context-item before">
+              <span class="context-label">Before:</span>
+              <span class="context-message">"${truncate(gap.commitBefore.message, 50)}"</span>
+            </div>
+          ` : ''}
+          ${gap.commitAfter ? `
+            <div class="context-item after">
+              <span class="context-label">After:</span>
+              <span class="context-message">"${truncate(gap.commitAfter.message, 50)}"</span>
+            </div>
+          ` : ''}
+        </div>
+      </div>
+    `;
+    }).join('');
+    return `
+    <div class="gaps-list-section">
+      <h3>Top Gaps by Duration</h3>
+      <div class="gaps-list">
+        ${gapItems}
+      </div>
+    </div>
+  `;
+}
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength - 3) + '...';
+}

package/dist/features/gaps/types.js

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

package/dist/features/impact/analyzer.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImpact = analyzeImpact;
+const emptyResults_1 = require("../../utils/emptyResults");
+// File weight patterns based on criticality
+const FILE_WEIGHTS = [
+    { pattern: /^src\/(core|lib)\//, weight: 1.5, category: 'core' },
+    { pattern: /^(src|lib)\/.*\.(ts|js|tsx|jsx)$/, weight: 1.0, category: 'feature' },
+    { pattern: /(test|spec|__tests__)\/|\.test\.|\.spec\./, weight: 0.8, category: 'test' },
+    { pattern: /\.(config|rc)\.|\.env|tsconfig|webpack|vite|eslint|prettier/, weight: 0.6, category: 'config' },
+    { pattern: /\.md$|^docs\/|^README/, weight: 0.4, category: 'docs' },
+    { pattern: /package\.json|\.lock$|yarn\.lock|pnpm-lock/, weight: 0.3, category: 'config' },
+];
+// Commit type weights based on conventional commits
+const TYPE_WEIGHTS = {
+    feat: 1.5,
+    fix: 1.2,
+    refactor: 1.0,
+    perf: 1.3,
+    test: 0.9,
+    docs: 0.5,
+    chore: 0.4,
+    style: 0.3,
+    ci: 0.4,
+    build: 0.5,
+};
+/**
+ * Get file weight and category based on path
+ */
+function getFileInfo(filePath) {
+    const normalizedPath = filePath.toLowerCase().replace(/\\/g, '/');
+    for (const { pattern, weight, category } of FILE_WEIGHTS) {
+        if (pattern.test(normalizedPath)) {
+            return { weight, category };
+        }
+    }
+    // Default for unknown files
+    return { weight: 0.7, category: 'feature' };
+}
+/**
+ * Extract commit type from conventional commit message
+ */
+function getCommitType(message) {
+    const match = message.match(/^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?!?:/i);
+    return match ? match[1].toLowerCase() : null;
+}
+/**
+ * Calculate recency factor (recent changes weighted higher)
+ */
+function getRecencyFactor(commitDate, now = new Date()) {
+    const daysSinceCommit = Math.floor((now.getTime() - commitDate.getTime()) / (1000 * 60 * 60 * 24));
+    // Exponential decay over 90 days
+    if (daysSinceCommit <= 7)
+        return 1.0;
+    if (daysSinceCommit <= 30)
+        return 0.9;
+    if (daysSinceCommit <= 60)
+        return 0.7;
+    if (daysSinceCommit <= 90)
+        return 0.5;
+    return 0.3;
+}
+/**
+ * Extract files changed from commit message (simplified - assumes file paths in message)
+ * In a real implementation, this would come from git diff
+ */
+function extractFilesFromCommit(commit) {
+    // For now, return empty - in a real implementation we'd parse git log --name-only
+    // This is a placeholder that allows the analyzer to work with existing data
+    return [];
+}
+/**
+ * Analyzes the impact of commits based on file criticality and change patterns.
+ *
+ * Calculates an overall impact score (0-100) by weighting commits based on:
+ * - File criticality (core files > features > tests > config > docs)
+ * - Commit type (feat/perf > fix/refactor > test > docs/chore)
+ * - Recency (recent changes weighted higher)
+ *
+ * @param commits - Array of commit data to analyze
+ * @param changedFiles - Optional pre-computed file change data from fileHotspotAnalyzer
+ * @returns Impact analysis with score breakdown, top files, trend, and insights
+ *
+ * @example
+ * ```typescript
+ * const impact = analyzeImpact(commits);
+ * console.log(`Impact score: ${impact.overallScore}/100`);
+ * console.log(`Trend: ${impact.impactTrend}`);
+ * console.log(`Core contributions: ${impact.scoreBreakdown.coreContributions} points`);
+ * ```
+ */
+function analyzeImpact(commits, changedFiles) {
+    if (commits.length === 0) {
+        return (0, emptyResults_1.getEmptyImpactAnalysis)();
+    }
+    const now = new Date();
+    const fileImpacts = new Map();
+    let coreContributions = 0;
+    let featureWork = 0;
+    let maintenanceWork = 0;
+    let documentationWork = 0;
+    let totalRawScore = 0;
+    let recentScore = 0; // Last 30 days
+    let olderScore = 0; // 30-90 days ago
+    // If we have file change data from fileHotspotAnalyzer, use it
+    if (changedFiles && changedFiles.size > 0) {
+        changedFiles.forEach((data, filePath) => {
+            const { weight, category } = getFileInfo(filePath);
+            const impactScore = data.count * weight;
+            fileImpacts.set(filePath, {
+                score: impactScore,
+                count: data.count,
+                lastChanged: data.lastChanged,
+                category
+            });
+            totalRawScore += impactScore;
+            // Categorize contributions
+            switch (category) {
+                case 'core':
+                    coreContributions += impactScore;
+                    break;
+                case 'test':
+                case 'config':
+                    maintenanceWork += impactScore;
+                    break;
+                case 'docs':
+                    documentationWork += impactScore;
+                    break;
+                default:
+                    featureWork += impactScore;
+            }
+        });
+    }
+    // Process commits for type-based weighting and recency
+    commits.forEach(commit => {
+        const commitDate = new Date(commit.date);
+        const commitType = getCommitType(commit.message);
+        const typeWeight = commitType ? (TYPE_WEIGHTS[commitType] || 1.0) : 1.0;
+        const recencyFactor = getRecencyFactor(commitDate, now);
+        const daysSinceCommit = Math.floor((now.getTime() - commitDate.getTime()) / (1000 * 60 * 60 * 24));
+        const baseScore = typeWeight * recencyFactor;
+        if (daysSinceCommit <= 30) {
+            recentScore += baseScore;
+        }
+        else if (daysSinceCommit <= 90) {
+            olderScore += baseScore;
+        }
+        // Additional category scoring based on commit type
+        if (commitType === 'feat') {
+            featureWork += typeWeight;
+        }
+        else if (commitType === 'fix' || commitType === 'refactor') {
+            maintenanceWork += typeWeight;
+        }
+        else if (commitType === 'docs') {
+            documentationWork += typeWeight;
+        }
+    });
+    // Normalize overall score to 0-100
+    const maxPossibleScore = commits.length * 1.5 * 1.0; // Max type weight * max recency
+    const normalizedScore = Math.min(100, Math.round((totalRawScore + recentScore) / Math.max(maxPossibleScore, 1) * 100));
+    // Get top 10 impact files
+    const topImpactFiles = Array.from(fileImpacts.entries())
+        .sort((a, b) => b[1].score - a[1].score)
+        .slice(0, 10)
+        .map(([path, data]) => ({
+        path,
+        impactScore: Math.round(data.score * 10) / 10,
+        changeCount: data.count,
+        lastChanged: data.lastChanged,
+        category: data.category
+    }));
+    // Determine trend
+    let impactTrend = 'stable';
+    if (recentScore > olderScore * 1.2) {
+        impactTrend = 'increasing';
+    }
+    else if (recentScore < olderScore * 0.8) {
+        impactTrend = 'decreasing';
+    }
+    // Generate insights
+    const insights = generateInsights({
+        coreContributions,
+        featureWork,
+        maintenanceWork,
+        documentationWork,
+        topImpactFiles,
+        impactTrend,
+        totalCommits: commits.length
+    });
+    // Normalize breakdown scores
+    const breakdownTotal = coreContributions + featureWork + maintenanceWork + documentationWork || 1;
+    return {
+        overallScore: normalizedScore,
+        scoreBreakdown: {
+            coreContributions: Math.round((coreContributions / breakdownTotal) * 100),
+            featureWork: Math.round((featureWork / breakdownTotal) * 100),
+            maintenanceWork: Math.round((maintenanceWork / breakdownTotal) * 100),
+            documentationWork: Math.round((documentationWork / breakdownTotal) * 100),
+        },
+        topImpactFiles,
+        impactTrend,
+        insights
+    };
+}
+/**
+ * Generate meaningful insights from impact data
+ */
+function generateInsights(data) {
+    const insights = [];
+    const total = data.coreContributions + data.featureWork + data.maintenanceWork + data.documentationWork || 1;
+    // Core contributions insight
+    const corePercentage = (data.coreContributions / total) * 100;
+    if (corePercentage > 30) {
+        insights.push(`Strong focus on core modules — ${corePercentage.toFixed(0)}% of impact from critical paths`);
+    }
+    // Feature work insight
+    const featurePercentage = (data.featureWork / total) * 100;
+    if (featurePercentage > 50) {
+        insights.push(`Feature-focused development — ${featurePercentage.toFixed(0)}% of contributions are new functionality`);
+    }
+    // Maintenance insight
+    const maintenancePercentage = (data.maintenanceWork / total) * 100;
+    if (maintenancePercentage > 40) {
+        insights.push(`Strong maintenance focus — keeping the codebase healthy`);
+    }
+    // Documentation insight
+    const docPercentage = (data.documentationWork / total) * 100;
+    if (docPercentage < 5 && data.totalCommits > 20) {
+        insights.push(`Documentation contributions below average — consider adding READMEs or inline docs`);
+    }
+    else if (docPercentage > 15) {
+        insights.push(`Good documentation practices — ${docPercentage.toFixed(0)}% of work includes docs`);
+    }
+    // Trend insight
+    if (data.impactTrend === 'increasing') {
+        insights.push(`Impact trending upward — recent contributions are higher value`);
+    }
+    else if (data.impactTrend === 'decreasing') {
+        insights.push(`Recent activity lower than historical average`);
+    }
+    // Top files insight
+    if (data.topImpactFiles.length > 0) {
+        const topFile = data.topImpactFiles[0];
+        insights.push(`Highest impact: ${topFile.path.split('/').pop()} (${topFile.changeCount} changes)`);
+    }
+    return insights.slice(0, 5); // Limit to 5 insights
+}

package/dist/features/impact/index.js

@@ -0,0 +1,26 @@
+"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.buildImpactSection = exports.analyzeImpact = void 0;
+/**
+ * Impact Feature
+ * @module features/impact
+ */
+__exportStar(require("./types"), exports);
+var analyzer_1 = require("./analyzer");
+Object.defineProperty(exports, "analyzeImpact", { enumerable: true, get: function () { return analyzer_1.analyzeImpact; } });
+var template_1 = require("./template");
+Object.defineProperty(exports, "buildImpactSection", { enumerable: true, get: function () { return template_1.buildImpactSection; } });

package/dist/features/impact/template.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildImpactSection = buildImpactSection;
+/**
+ * Build the Impact Analysis section for the dashboard
+ */
+function buildImpactSection(impact) {
+    const trendIcon = impact.impactTrend === 'increasing' ? '↑' : impact.impactTrend === 'decreasing' ? '↓' : '→';
+    const trendClass = impact.impactTrend === 'increasing' ? 'trend-up' : impact.impactTrend === 'decreasing' ? 'trend-down' : 'trend-stable';
+    return `
+    <div class="impact-section">
+      <h2>Impact Analysis</h2>
+      
+      <div class="impact-content">
+        <div class="impact-overview">
+        <div class="impact-score-display">
+          <div class="score-circle">
+            <span class="score-value">${impact.overallScore}</span>
+            <span class="score-max">/100</span>
+          </div>
+          <div class="score-meta">
+            <span class="score-label">Impact Score</span>
+            <span class="score-trend ${trendClass}">${trendIcon} ${impact.impactTrend}</span>
+          </div>
+        </div>
+        
+        <div class="impact-breakdown">
+          <h3>Contribution Breakdown</h3>
+          <div class="breakdown-items">
+            <div class="breakdown-item">
+              <div class="breakdown-header">
+                <span class="breakdown-label">Core Contributions <span class="info-tooltip" title="Changes to src/core/ and src/lib/ folders - foundational code">ⓘ</span></span>
+                <span class="breakdown-value">${impact.scoreBreakdown.coreContributions}%</span>
+              </div>
+              <div class="breakdown-bar">
+                <div class="breakdown-fill core" style="width: ${impact.scoreBreakdown.coreContributions}%"></div>
+              </div>
+            </div>
+            
+            <div class="breakdown-item">
+              <div class="breakdown-header">
+                <span class="breakdown-label">Feature Work <span class="info-tooltip" title="Changes to source files (.ts, .js, .tsx, .jsx) outside core/lib">ⓘ</span></span>
+                <span class="breakdown-value">${impact.scoreBreakdown.featureWork}%</span>
+              </div>
+              <div class="breakdown-bar">
+                <div class="breakdown-fill feature" style="width: ${impact.scoreBreakdown.featureWork}%"></div>
+              </div>
+            </div>
+            
+            <div class="breakdown-item">
+              <div class="breakdown-header">
+                <span class="breakdown-label">Maintenance <span class="info-tooltip" title="Changes to tests, configs, CI/CD, and build files">ⓘ</span></span>
+                <span class="breakdown-value">${impact.scoreBreakdown.maintenanceWork}%</span>
+              </div>
+              <div class="breakdown-bar">
+                <div class="breakdown-fill maintenance" style="width: ${impact.scoreBreakdown.maintenanceWork}%"></div>
+              </div>
+            </div>
+            
+            <div class="breakdown-item">
+              <div class="breakdown-header">
+                <span class="breakdown-label">Documentation <span class="info-tooltip" title="Changes to .md files, README, and docs/ folder">ⓘ</span></span>
+                <span class="breakdown-value">${impact.scoreBreakdown.documentationWork}%</span>
+              </div>
+              <div class="breakdown-bar">
+                <div class="breakdown-fill docs" style="width: ${impact.scoreBreakdown.documentationWork}%"></div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      
+      ${impact.topImpactFiles.length > 0 ? `
+        <div class="impact-files">
+          <h3>Highest Impact Changes</h3>
+          <table class="data-table">
+            <thead>
+              <tr>
+                <th>File</th>
+                <th>Category</th>
+                <th>Changes</th>
+                <th>Impact</th>
+              </tr>
+            </thead>
+            <tbody>
+              ${impact.topImpactFiles.map(file => `
+                <tr>
+                  <td class="file-path">${truncatePath(file.path)}</td>
+                  <td><span class="category-badge ${file.category}">${file.category}</span></td>
+                  <td>${file.changeCount}</td>
+                  <td><span class="impact-badge">${file.impactScore.toFixed(1)}</span></td>
+                </tr>
+              `).join('')}
+            </tbody>
+          </table>
+        </div>
+      ` : ''}
+      
+      ${impact.insights.length > 0 ? `
+        <div class="insights-list">
+          <h3>Insights</h3>
+          <ul>
+            ${impact.insights.map(insight => `<li>💡 ${insight}</li>`).join('')}
+          </ul>
+        </div>
+      ` : ''}
+      </div>
+    </div>
+  `;
+}
+/**
+ * Truncate file path for display
+ */
+function truncatePath(path, maxLength = 40) {
+    if (path.length <= maxLength)
+        return path;
+    return '...' + path.slice(-maxLength + 3);
+}

package/dist/features/impact/types.js

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

package/dist/features/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Features Module
+ *
+ * Central export for all feature modules.
+ * Each feature is self-contained with its own types, logic, and templates.
+ *
+ * @module features
+ */
+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 });
+// Core features
+__exportStar(require("./achievements"), exports);
+__exportStar(require("./streaks"), exports);
+__exportStar(require("./time-patterns"), exports);
+// Analysis features
+__exportStar(require("./velocity"), exports);
+__exportStar(require("./gaps"), exports);
+__exportStar(require("./knowledge"), exports);
+__exportStar(require("./impact"), exports);
+__exportStar(require("./commit-quality"), exports);
+__exportStar(require("./team"), exports);
+__exportStar(require("./comparison"), exports);
+// Content features
+__exportStar(require("./executive-summary"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./contribution-graph"), exports);