repo-wrapped 0.0.7 → 0.0.9

package/dist/features/executive-summary/template.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExecutiveSummarySection = buildExecutiveSummarySection;
+const date_fns_1 = require("date-fns");
+function buildExecutiveSummarySection(summary) {
+    return `
+    <div class="executive-summary-section">
+      <div class="executive-header">
+        <h2>📊 Executive Summary</h2>
+      </div>
+      
+      <div class="kpi-grid">
+        ${summary.kpis.map(kpi => buildKPICard(kpi)).join('')}
+      </div>
+      
+      <div class="insights-risks-grid">
+        <div class="insights-column">
+          <h3>💡 Key Insights</h3>
+          <div class="insights-list">
+            ${summary.keyInsights.map(insight => `
+              <div class="insight-item ${insight.type}">
+                <span class="insight-icon">${insight.type === 'positive' ? '✅' : insight.type === 'negative' ? '⚠️' : 'ℹ️'}</span>
+                <span class="insight-text">${insight.insight}</span>
+              </div>
+            `).join('')}
+          </div>
+        </div>
+        
+        <div class="risks-column">
+          <h3>🚨 Risk Assessment</h3>
+          <div class="risks-list">
+            ${summary.risks.length > 0 ? summary.risks.map(risk => `
+              <div class="risk-item ${risk.level}">
+                <span class="risk-badge">${risk.level.toUpperCase()}</span>
+                <div class="risk-content">
+                  <span class="risk-category">${risk.category}</span>
+                  <span class="risk-description">${risk.description}</span>
+                </div>
+              </div>
+            `).join('') : '<div class="no-risks">No significant risks identified</div>'}
+          </div>
+        </div>
+      </div>
+      
+      <div class="recommendations-section">
+        <h3>📋 Recommendations</h3>
+        <ol class="recommendations-list">
+          ${summary.recommendations.map(rec => `<li>${rec}</li>`).join('')}
+        </ol>
+      </div>
+      
+      <div class="summary-footer">
+        Generated: ${(0, date_fns_1.format)(summary.generatedAt, 'MMM d, yyyy HH:mm')}
+      </div>
+    </div>
+  `;
+}
+function buildKPICard(kpi) {
+    const statusColors = {
+        green: '#69db7c',
+        yellow: '#ffd43b',
+        red: '#ff6b6b',
+    };
+    const trendArrow = kpi.trend === 'up' ? '↑' : kpi.trend === 'down' ? '↓' : '→';
+    const trendClass = kpi.trend === 'up' ? 'positive' : kpi.trend === 'down' ? 'negative' : 'neutral';
+    return `
+    <div class="kpi-card" style="--status-color: ${statusColors[kpi.status]}">
+      <div class="kpi-status-indicator" title="${kpi.status}"></div>
+      <div class="kpi-content">
+        <div class="kpi-label">${kpi.name}</div>
+        <div class="kpi-value">${kpi.value}</div>
+        <div class="kpi-trend ${trendClass}">
+          <span class="trend-arrow">${trendArrow}</span>
+          <span class="trend-value">${kpi.trendValue}</span>
+        </div>
+        ${kpi.benchmark ? `<div class="kpi-benchmark">${kpi.benchmark}</div>` : ''}
+      </div>
+    </div>
+  `;
+}

package/dist/features/executive-summary/types.js

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

package/dist/features/gaps/analyzer.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("../../utils/emptyResults");
+const analyzerContextBuilder_1 = require("../../utils/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;
+}