repo-wrapped 0.0.6 → 0.0.9

package/dist/utils/achievementDefinitions.js

@@ -59,10 +59,10 @@ exports.ACHIEVEMENTS = [
         id: 'champion',
         name: 'Champion',
         emoji: '🏆',
-        description: 'Reached 500 commits',
+        description: 'Reached 200 commits',
         category: 'milestone',
-        tier: 'platinum',
-        criteria: { type: 'commit-count', threshold: 500, comparator: '>=' },
+        tier: 'gold',
+        criteria: { type: 'commit-count', threshold: 200, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -71,10 +71,10 @@ exports.ACHIEVEMENTS = [
         id: 'master',
         name: 'Master',
         emoji: '💫',
-        description: 'Reached 1000 commits',
+        description: 'Reached 300 commits',
         category: 'milestone',
         tier: 'platinum',
-        criteria: { type: 'commit-count', threshold: 1000, comparator: '>=' },
+        criteria: { type: 'commit-count', threshold: 300, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -83,10 +83,10 @@ exports.ACHIEVEMENTS = [
         id: 'legend',
         name: 'Legend',
         emoji: '🌟',
-        description: 'Reached 5000 commits',
+        description: 'Reached 500 commits',
         category: 'milestone',
         tier: 'legendary',
-        criteria: { type: 'commit-count', threshold: 5000, comparator: '>=' },
+        criteria: { type: 'commit-count', threshold: 500, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -98,7 +98,7 @@ exports.ACHIEVEMENTS = [
         id: 'consistency',
         name: 'Consistency',
         emoji: '📅',
-        description: 'Maintained a 3-day commit streak',
+        description: 'Maintained a 3-day business day streak',
         category: 'time',
         tier: 'bronze',
         criteria: { type: 'streak', threshold: 3, comparator: '>=' },
@@ -110,10 +110,10 @@ exports.ACHIEVEMENTS = [
         id: 'week-warrior',
         name: 'Week Warrior',
         emoji: '⚡',
-        description: 'Maintained a 7-day commit streak',
+        description: 'Maintained a 5-day business day streak (full week)',
         category: 'time',
         tier: 'silver',
-        criteria: { type: 'streak', threshold: 7, comparator: '>=' },
+        criteria: { type: 'streak', threshold: 5, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -122,10 +122,10 @@ exports.ACHIEVEMENTS = [
         id: 'streak-on-fire',
         name: 'Streak On Fire',
         emoji: '🔥',
-        description: 'Maintained a 14-day commit streak',
+        description: 'Maintained a 10-day business day streak (2 weeks)',
         category: 'time',
         tier: 'gold',
-        criteria: { type: 'streak', threshold: 14, comparator: '>=' },
+        criteria: { type: 'streak', threshold: 10, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -134,10 +134,10 @@ exports.ACHIEVEMENTS = [
         id: 'unstoppable',
         name: 'Unstoppable',
         emoji: '💪',
-        description: 'Maintained a 30-day commit streak',
+        description: 'Maintained a 20-day business day streak (1 month)',
         category: 'time',
         tier: 'platinum',
-        criteria: { type: 'streak', threshold: 30, comparator: '>=' },
+        criteria: { type: 'streak', threshold: 20, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -146,10 +146,10 @@ exports.ACHIEVEMENTS = [
         id: 'iron-will',
         name: 'Iron Will',
         emoji: '🦾',
-        description: 'Maintained a 60-day commit streak',
+        description: 'Maintained a 40-day business day streak (2 months)',
         category: 'time',
         tier: 'platinum',
-        criteria: { type: 'streak', threshold: 60, comparator: '>=' },
+        criteria: { type: 'streak', threshold: 40, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -158,10 +158,10 @@ exports.ACHIEVEMENTS = [
         id: 'code-machine',
         name: 'Code Machine',
         emoji: '👾',
-        description: 'Maintained a 100-day commit streak',
+        description: 'Maintained a 60-day business day streak (3 months)',
         category: 'time',
         tier: 'legendary',
-        criteria: { type: 'streak', threshold: 100, comparator: '>=' },
+        criteria: { type: 'streak', threshold: 60, comparator: '>=' },
         progress: 0,
         isUnlocked: false,
         isSecret: false
@@ -230,7 +230,7 @@ exports.ACHIEVEMENTS = [
         id: 'early-bird',
         name: 'Early Bird',
         emoji: '🌅',
-        description: '50+ commits before 9am',
+        description: '20+ commits before 9am',
         category: 'time',
         tier: 'silver',
         criteria: {
@@ -240,7 +240,7 @@ exports.ACHIEVEMENTS = [
                     const hour = new Date(c.date).getHours();
                     return hour >= 5 && hour < 9;
                 }).length;
-                return earlyCommits >= 50;
+                return earlyCommits >= 20;
             }
         },
         progress: 0,
@@ -251,7 +251,7 @@ exports.ACHIEVEMENTS = [
         id: 'night-owl',
         name: 'Night Owl',
         emoji: '🦉',
-        description: '50+ commits after 9pm',
+        description: '20+ commits after 9pm',
         category: 'time',
         tier: 'silver',
         criteria: {
@@ -261,7 +261,7 @@ exports.ACHIEVEMENTS = [
                     const hour = new Date(c.date).getHours();
                     return hour >= 21 || hour < 5;
                 }).length;
-                return lateCommits >= 50;
+                return lateCommits >= 20;
             }
         },
         progress: 0,

package/dist/utils/analyzerContextBuilder.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Utility functions for building and working with AnalyzerContext.
+ *
+ * @module analyzerContextBuilder
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnalyzerContext = isAnalyzerContext;
+exports.buildContext = buildContext;
+exports.getOption = getOption;
+exports.computeFileChanges = computeFileChanges;
+exports.withOptions = withOptions;
+/**
+ * Type guard to check if an argument is an AnalyzerContext.
+ *
+ * @param arg - Value to check
+ * @returns True if the argument is an AnalyzerContext
+ *
+ * @example
+ * ```typescript
+ * function analyze(arg1: CommitData[] | AnalyzerContext, ...rest: unknown[]) {
+ *   if (isAnalyzerContext(arg1)) {
+ *     // Use arg1.commits, arg1.dateRange, etc.
+ *   } else {
+ *     // Use positional parameters
+ *   }
+ * }
+ * ```
+ */
+function isAnalyzerContext(arg) {
+    return (typeof arg === 'object' &&
+        arg !== null &&
+        'commits' in arg &&
+        'dateRange' in arg &&
+        typeof arg.dateRange === 'object' &&
+        arg.dateRange !== null &&
+        'start' in arg.dateRange &&
+        'end' in arg.dateRange);
+}
+/**
+ * Build an AnalyzerContext from individual parameters.
+ *
+ * @param commits - Array of commits to analyze
+ * @param startDate - Start of the analysis period
+ * @param endDate - End of the analysis period
+ * @param repoPath - Path to the repository (optional)
+ * @param options - Additional analyzer options (optional)
+ * @returns A fully constructed AnalyzerContext
+ *
+ * @example
+ * ```typescript
+ * const ctx = buildContext(commits, startDate, endDate, '/path/to/repo', { windowWeeks: 8 });
+ * const velocity = analyzeVelocity(ctx);
+ * ```
+ */
+function buildContext(commits, startDate, endDate, repoPath = '', options) {
+    return {
+        commits,
+        dateRange: {
+            start: startDate,
+            end: endDate,
+        },
+        repoPath,
+        options,
+    };
+}
+/**
+ * Get an option value from context with a default fallback.
+ *
+ * @param ctx - The analyzer context
+ * @param key - The option key to retrieve
+ * @param defaultValue - Default value if option is not set
+ * @returns The option value or the default
+ *
+ * @example
+ * ```typescript
+ * const windowWeeks = getOption(ctx, 'windowWeeks', 4);
+ * const thresholdDays = getOption(ctx, 'thresholdDays', 3);
+ * ```
+ */
+function getOption(ctx, key, defaultValue) {
+    return ctx.options?.[key] ?? defaultValue;
+}
+/**
+ * Compute file change data from commits (cached).
+ *
+ * This is an expensive operation that should only be done once
+ * and then shared across analyzers via the context.
+ *
+ * @param _repoPath - Path to the git repository
+ * @param _commits - Commits to analyze for file changes
+ * @returns Map of file paths to change data
+ *
+ * @remarks
+ * This is a placeholder for future implementation.
+ * Currently returns an empty map.
+ */
+function computeFileChanges(_repoPath, _commits) {
+    // TODO: Implement git log --name-only parsing
+    // This would be called once and shared across impact/knowledge analyzers
+    return new Map();
+}
+/**
+ * Clone a context with merged options.
+ *
+ * @param ctx - Original context
+ * @param additionalOptions - Options to merge
+ * @returns New context with merged options
+ *
+ * @example
+ * ```typescript
+ * const velocityCtx = withOptions(ctx, { windowWeeks: 8 });
+ * const gapCtx = withOptions(ctx, { thresholdDays: 5, excludeWeekends: true });
+ * ```
+ */
+function withOptions(ctx, additionalOptions) {
+    return {
+        ...ctx,
+        options: {
+            ...ctx.options,
+            ...additionalOptions,
+        },
+    };
+}

package/dist/utils/commitQualityAnalyzer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeCommitQuality = analyzeCommitQuality;
 exports.getQualityRating = getQualityRating;
 exports.getQualityLevel = getQualityLevel;
+const analyzerContextBuilder_1 = require("./analyzerContextBuilder");
 const CONVENTIONAL_COMMIT_REGEX = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?!?:\s.+/;
 const CODE_HYGIENE_PATTERNS = {
     quickFix: /fix(ed)?\s+(typo|spelling|grammar)/i,
@@ -24,8 +25,18 @@ const IMPERATIVE_STARTERS = [
     'improve', 'optimize', 'enhance', 'change', 'move', 'rename', 'extract',
     'merge', 'bump', 'revert', 'document', 'test', 'upgrade', 'downgrade'
 ];
-function analyzeCommitQuality(commits, options = {}) {
-    const { skipBodyCheck = false } = options;
+function analyzeCommitQuality(ctxOrCommits, options = {}) {
+    // Normalize to internal variables
+    let commits;
+    let skipBodyCheck;
+    if ((0, analyzerContextBuilder_1.isAnalyzerContext)(ctxOrCommits)) {
+        commits = ctxOrCommits.commits;
+        skipBodyCheck = (0, analyzerContextBuilder_1.getOption)(ctxOrCommits, 'skipBodyCheck', false);
+    }
+    else {
+        commits = ctxOrCommits;
+        skipBodyCheck = options.skipBodyCheck ?? false;
+    }
     if (commits.length === 0) {
         return getEmptyQuality();
     }

package/dist/utils/emptyResults.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Centralized empty result factories for all analyzers
+ * Provides consistent default values when there's no data to analyze
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmptyImpactAnalysis = getEmptyImpactAnalysis;
+exports.getEmptyVelocityAnalysis = getEmptyVelocityAnalysis;
+exports.getEmptyGapAnalysis = getEmptyGapAnalysis;
+exports.getEmptyKnowledgeDistribution = getEmptyKnowledgeDistribution;
+exports.getEmptyFileHotspotAnalysis = getEmptyFileHotspotAnalysis;
+const date_fns_1 = require("date-fns");
+/**
+ * Creates an empty impact analysis result
+ */
+function getEmptyImpactAnalysis() {
+    return {
+        overallScore: 0,
+        scoreBreakdown: {
+            coreContributions: 0,
+            featureWork: 0,
+            maintenanceWork: 0,
+            documentationWork: 0,
+        },
+        topImpactFiles: [],
+        impactTrend: 'stable',
+        insights: ['No commit data available for analysis']
+    };
+}
+/**
+ * Creates an empty velocity analysis result
+ */
+function getEmptyVelocityAnalysis() {
+    return {
+        timeline: [],
+        overallTrend: 'stable',
+        trendPercentage: 0,
+        averageCommitsPerWeek: 0,
+        peakWeek: { weekStart: new Date(), commits: 0 },
+        lowestWeek: { weekStart: new Date(), commits: 0 },
+        anomalies: [],
+    };
+}
+/**
+ * Creates an empty gap analysis result
+ */
+function getEmptyGapAnalysis(startDate, endDate) {
+    const totalDays = (0, date_fns_1.differenceInDays)(endDate, startDate) + 1;
+    return {
+        gaps: [{
+                start: startDate,
+                end: endDate,
+                durationDays: totalDays,
+                commitBefore: null,
+                commitAfter: null,
+                possibleType: 'blocker',
+            }],
+        totalGapDays: totalDays,
+        percentageOfPeriodInGaps: 100,
+        longestGap: null,
+        averageGapLength: totalDays,
+        gapFrequency: 0,
+        patterns: [],
+        riskLevel: 'critical',
+        riskFactors: ['No commits found in the analysis period'],
+    };
+}
+/**
+ * Creates an empty knowledge distribution result
+ */
+function getEmptyKnowledgeDistribution() {
+    return {
+        directories: [],
+        busFactorRisk: {
+            overall: 0,
+            level: 'low',
+            criticalPaths: []
+        },
+        knowledgeSilos: [],
+        sharedKnowledge: [],
+        recommendations: ['No commit data available for analysis']
+    };
+}
+/**
+ * Creates an empty file hotspot analysis result
+ */
+function getEmptyFileHotspotAnalysis() {
+    return {
+        topFiles: [],
+        topDirectories: [],
+        technicalDebt: [],
+        ownershipRisks: [],
+        totalFilesAnalyzed: 0
+    };
+}

package/dist/utils/eventAnnotationParser.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 commitQualityAnalyzer_1 = require("./commitQualityAnalyzer");
+/**
+ * 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, commitQualityAnalyzer_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;
+}