repo-wrapped 0.0.6 → 0.0.9

package/dist/features/time-patterns/template.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTimePatternsSection = buildTimePatternsSection;
+const constants_1 = require("../../constants");
+const formatters_1 = require("../../formatters");
+const analyzer_1 = require("./analyzer");
+function buildTimePatternsSection(timePattern) {
+    // Get chronotype details for dual display
+    const chronotypeDetails = getChronotypeTimeRange(timePattern.chronotype);
+    return `
+    <div class="time-patterns-section">
+      <h2>Time Patterns</h2>
+      
+      <div class="patterns-grid">
+        <div class="pattern-card">
+          <div class="pattern-header">
+            <span class="pattern-icon">⏱️</span>
+            <span class="pattern-title">Peak Hour</span>
+          </div>
+          <div class="pattern-value">${(0, formatters_1.formatHour)(timePattern.peakHour.hour)}</div>
+          <div class="pattern-detail">${timePattern.peakHour.commitCount} commits</div>
+        </div>
+        
+        <div class="pattern-card">
+          <div class="pattern-header">
+            <span class="pattern-icon">${constants_1.ANALYSIS_CHRONOTYPE_EMOJIS[timePattern.chronotype] || '⚖️'}</span>
+            <span class="pattern-title">Chronotype</span>
+          </div>
+          <div class="chronotype-display">
+            <div class="chronotype-label">${(0, analyzer_1.getChronotypeLabel)(timePattern.chronotype)}</div>
+            <div class="chronotype-detail">${chronotypeDetails}</div>
+          </div>
+          <div class="pattern-detail">${timePattern.chronotypeConfidence.toFixed(0)}% confidence</div>
+        </div>
+        
+        <div class="pattern-card">
+          <div class="pattern-header">
+            <span class="pattern-icon">⚖️</span>
+            <span class="pattern-title">Work-Life Balance</span>
+          </div>
+          <div class="pattern-value">${getBalanceScore(timePattern.workLifeBalance.score)}</div>
+          <div class="pattern-detail">Weekday: ${timePattern.workLifeBalance.weekdayCommits} | Weekend: ${timePattern.workLifeBalance.weekendCommits}</div>
+        </div>
+        
+        <div class="pattern-card">
+          <div class="pattern-header">
+            <span class="pattern-icon">📊</span>
+            <span class="pattern-title">Consistency</span>
+          </div>
+          <div class="pattern-value">${timePattern.consistency.score.toFixed(1)}/10</div>
+          <div class="pattern-detail">${formatRegularity(timePattern.consistency.regularity)}</div>
+        </div>
+      </div>
+      
+      ${timePattern.burnoutRisk.level !== 'low' ? `
+        <div class="wellbeing-note">
+          <div class="wellbeing-header">
+            <span class="wellbeing-icon">💚</span>
+            <span class="wellbeing-title">Pace Advisory: ${formatRiskLevel(timePattern.burnoutRisk.level)}</span>
+          </div>
+          <ul class="wellbeing-indicators">
+            ${timePattern.burnoutRisk.indicators.map((indicator) => `<li>${indicator}</li>`).join('')}
+          </ul>
+          <div class="wellbeing-message">
+            Sustainable pace matters. These patterns are informational, not prescriptive.
+          </div>
+        </div>
+      ` : ''}
+      
+      <div class="chronotype-insight">
+        ${(0, analyzer_1.getChronotypeDescription)(timePattern.chronotype)}
+      </div>
+    </div>
+  `;
+}
+function getChronotypeTimeRange(chronotype) {
+    switch (chronotype) {
+        case 'early-bird': return 'Peak hours: 6 AM – 9 AM';
+        case 'night-owl': return 'Peak hours: 9 PM – 12 AM';
+        case 'vampire': return 'Peak hours: 12 AM – 6 AM';
+        case 'balanced': return 'Consistent throughout day';
+        default: return '';
+    }
+}
+function getBalanceScore(score) {
+    if (score >= 4)
+        return 'Excellent';
+    if (score >= 3)
+        return 'Good';
+    if (score >= 2)
+        return 'Fair';
+    return 'Consider adjusting';
+}
+function formatRegularity(regularity) {
+    switch (regularity) {
+        case 'very-consistent': return 'Very Consistent';
+        case 'consistent': return 'Consistent';
+        case 'irregular': return 'Irregular';
+        case 'chaotic': return 'Variable';
+        default: return regularity;
+    }
+}
+function formatRiskLevel(level) {
+    switch (level) {
+        case 'high': return 'High';
+        case 'medium': return 'Moderate';
+        default: return level;
+    }
+}

package/dist/features/time-patterns/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Time Patterns Types
+ *
+ * Re-exports time pattern types from core for feature co-location.
+ *
+ * @module features/time-patterns/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/features/velocity/analyzer.js

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