repo-wrapped 0.0.6 → 0.0.9

package/dist/features/team/analyzer.js

@@ -0,0 +1,316 @@
+"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.filterCommitsByAuthor = filterCommitsByAuthor;
+exports.parseAuthorFilter = parseAuthorFilter;
+exports.loadTeamFile = loadTeamFile;
+exports.analyzeTeam = analyzeTeam;
+exports.formatTeamInsights = formatTeamInsights;
+const fs = __importStar(require("fs"));
+const commit_quality_1 = require("../commit-quality");
+/**
+ * Filters commits by author(s) based on the provided filter
+ */
+function filterCommitsByAuthor(commits, filter) {
+    return commits.filter(commit => {
+        const authorLower = commit.author.toLowerCase();
+        const matches = filter.authors.some(filterAuthor => {
+            const filterLower = filterAuthor.toLowerCase();
+            if (filter.matchType === 'exact') {
+                return authorLower === filterLower;
+            }
+            else {
+                return authorLower.includes(filterLower);
+            }
+        });
+        return filter.mode === 'include' ? matches : !matches;
+    });
+}
+/**
+ * Parse author filter from CLI options
+ */
+function parseAuthorFilter(author, authors, excludeAuthor, excludeAuthors) {
+    // Include filters take precedence
+    if (author) {
+        return {
+            mode: 'include',
+            authors: [author],
+            matchType: 'partial',
+        };
+    }
+    if (authors) {
+        return {
+            mode: 'include',
+            authors: authors.split(',').map(a => a.trim()).filter(a => a.length > 0),
+            matchType: 'partial',
+        };
+    }
+    // Exclude filters
+    if (excludeAuthor) {
+        return {
+            mode: 'exclude',
+            authors: [excludeAuthor],
+            matchType: 'partial',
+        };
+    }
+    if (excludeAuthors) {
+        return {
+            mode: 'exclude',
+            authors: excludeAuthors.split(',').map(a => a.trim()).filter(a => a.length > 0),
+            matchType: 'partial',
+        };
+    }
+    return null;
+}
+/**
+ * Load team members from a file (one name per line)
+ */
+function loadTeamFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0 && !line.startsWith('#'));
+    }
+    catch (error) {
+        throw new Error(`Failed to load team file: ${error.message}`);
+    }
+}
+/**
+ * Analyzes commit patterns and distribution for a team of contributors.
+ *
+ * Calculates team-level metrics including:
+ * - Commit distribution across members (Gini coefficient)
+ * - Individual member statistics and rankings
+ * - Quality scores and active days
+ * - Load balancing insights
+ *
+ * @param commits - Array of all commit data (will be filtered to team members)
+ * @param teamMembers - Array of team member names/patterns to include
+ * @param teamName - Optional team name for display
+ * @param skipBodyCheck - Whether to skip commit body quality checks (default: true)
+ * @returns Team analysis with member breakdown, distribution metrics, and insights
+ *
+ * @example
+ * ```typescript
+ * const team = analyzeTeam(commits, ['Alice', 'Bob', 'Charlie'], 'Backend Team');
+ * console.log(`Team commits: ${team.stats.totalCommits}`);
+ * console.log(`Distribution: ${team.loadDistribution.assessment}`);
+ * ```
+ */
+function analyzeTeam(commits, teamMembers, teamName, skipBodyCheck = true) {
+    // Filter commits to team members only
+    const teamFilter = {
+        mode: 'include',
+        authors: teamMembers,
+        matchType: 'partial',
+    };
+    const teamCommits = filterCommitsByAuthor(commits, teamFilter);
+    // Calculate team metrics
+    const totalCommits = teamCommits.length;
+    const commitsPerMember = teamMembers.length > 0
+        ? Math.round((totalCommits / teamMembers.length) * 10) / 10
+        : 0;
+    // Active days
+    const activeDatesSet = new Set(teamCommits.map(c => {
+        const d = new Date(c.date);
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+    }));
+    const activeDays = activeDatesSet.size;
+    // Quality score
+    const qualityResult = (0, commit_quality_1.analyzeCommitQuality)(teamCommits, { skipBodyCheck });
+    const qualityScore = Math.round(qualityResult.overallScore * 10) / 10;
+    // Member breakdown
+    const memberBreakdown = calculateMemberBreakdown(teamCommits, teamMembers, skipBodyCheck);
+    // Load distribution
+    const loadDistribution = calculateLoadDistribution(memberBreakdown, totalCommits);
+    return {
+        teamName,
+        members: teamMembers,
+        teamMetrics: {
+            totalCommits,
+            commitsPerMember,
+            activeDays,
+            qualityScore,
+        },
+        memberBreakdown,
+        loadDistribution,
+    };
+}
+function calculateMemberBreakdown(commits, teamMembers, skipBodyCheck) {
+    const breakdown = [];
+    const totalCommits = commits.length;
+    // Build a map of author -> commits
+    const commitsByAuthor = new Map();
+    for (const commit of commits) {
+        const authorLower = commit.author.toLowerCase();
+        // Find the matching team member
+        const matchedMember = teamMembers.find(member => authorLower.includes(member.toLowerCase()));
+        if (matchedMember) {
+            if (!commitsByAuthor.has(matchedMember)) {
+                commitsByAuthor.set(matchedMember, []);
+            }
+            commitsByAuthor.get(matchedMember).push(commit);
+        }
+    }
+    // Calculate stats for each team member
+    for (const member of teamMembers) {
+        const memberCommits = commitsByAuthor.get(member) || [];
+        const commitCount = memberCommits.length;
+        const percentage = totalCommits > 0
+            ? Math.round((commitCount / totalCommits) * 1000) / 10
+            : 0;
+        // Active days for this member
+        const memberActiveDates = new Set(memberCommits.map(c => {
+            const d = new Date(c.date);
+            return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+        }));
+        // Quality score for this member
+        const qualityResult = memberCommits.length > 0
+            ? (0, commit_quality_1.analyzeCommitQuality)(memberCommits, { skipBodyCheck })
+            : { overallScore: 0 };
+        // Top areas (directories)
+        const areaCounts = new Map();
+        for (const commit of memberCommits) {
+            // Extract directory from commit message if available (heuristic)
+            // In a real implementation, this would use file change data
+            const match = commit.message.match(/^(?:feat|fix|docs|refactor|test|chore)\(([^)]+)\)/i);
+            if (match) {
+                const area = match[1];
+                areaCounts.set(area, (areaCounts.get(area) || 0) + 1);
+            }
+        }
+        const topAreas = [...areaCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([area]) => area);
+        breakdown.push({
+            author: member,
+            commits: commitCount,
+            percentage,
+            activeDays: memberActiveDates.size,
+            qualityScore: Math.round(qualityResult.overallScore * 10) / 10,
+            topAreas,
+        });
+    }
+    // Sort by commits descending
+    breakdown.sort((a, b) => b.commits - a.commits);
+    return breakdown;
+}
+function calculateLoadDistribution(memberBreakdown, totalCommits) {
+    const insights = [];
+    if (memberBreakdown.length === 0 || totalCommits === 0) {
+        return {
+            giniCoefficient: 0,
+            assessment: 'balanced',
+            insights: ['No team data available'],
+        };
+    }
+    // Calculate Gini coefficient for commit distribution
+    const commitCounts = memberBreakdown.map(m => m.commits).sort((a, b) => a - b);
+    const n = commitCounts.length;
+    let giniNumerator = 0;
+    for (let i = 0; i < n; i++) {
+        giniNumerator += (2 * (i + 1) - n - 1) * commitCounts[i];
+    }
+    const giniCoefficient = n > 1
+        ? Math.round((giniNumerator / (n * totalCommits)) * 100) / 100
+        : 0;
+    // Determine assessment
+    let assessment;
+    if (giniCoefficient <= 0.3) {
+        assessment = 'balanced';
+        insights.push('Work is distributed fairly evenly across team members');
+    }
+    else if (giniCoefficient <= 0.5) {
+        assessment = 'moderate-imbalance';
+        insights.push('Some team members are contributing significantly more than others');
+    }
+    else {
+        assessment = 'high-imbalance';
+        insights.push('Work is heavily concentrated among a few team members');
+    }
+    // Additional insights
+    const topContributor = memberBreakdown[0];
+    if (topContributor && topContributor.percentage > 50) {
+        insights.push(`${topContributor.author} accounts for ${topContributor.percentage}% of all commits`);
+    }
+    const inactiveMembers = memberBreakdown.filter(m => m.commits === 0);
+    if (inactiveMembers.length > 0) {
+        insights.push(`${inactiveMembers.length} team member(s) have no commits in this period`);
+    }
+    return {
+        giniCoefficient,
+        assessment,
+        insights,
+    };
+}
+/**
+ * Format team analysis for display
+ */
+function formatTeamInsights(analysis) {
+    const insights = [];
+    const teamLabel = analysis.teamName || 'Team';
+    insights.push(`👥 ${teamLabel} Analysis (${analysis.members.length} members)`);
+    insights.push('');
+    // Team metrics
+    insights.push(`📊 Total commits: ${analysis.teamMetrics.totalCommits}`);
+    insights.push(`📅 Active days: ${analysis.teamMetrics.activeDays}`);
+    insights.push(`⚡ Avg commits/member: ${analysis.teamMetrics.commitsPerMember}`);
+    insights.push(`✨ Quality score: ${analysis.teamMetrics.qualityScore}/10`);
+    insights.push('');
+    // Load distribution
+    const loadEmoji = {
+        'balanced': '🟢',
+        'moderate-imbalance': '🟡',
+        'high-imbalance': '🔴',
+    }[analysis.loadDistribution.assessment];
+    insights.push(`${loadEmoji} Load distribution: ${analysis.loadDistribution.assessment} (Gini: ${analysis.loadDistribution.giniCoefficient})`);
+    for (const insight of analysis.loadDistribution.insights) {
+        insights.push(`  • ${insight}`);
+    }
+    insights.push('');
+    // Member breakdown (top 5)
+    insights.push('👤 Member breakdown:');
+    for (const member of analysis.memberBreakdown.slice(0, 5)) {
+        const areas = member.topAreas.length > 0 ? ` [${member.topAreas.join(', ')}]` : '';
+        insights.push(`  • ${member.author}: ${member.commits} commits (${member.percentage}%)${areas}`);
+    }
+    if (analysis.memberBreakdown.length > 5) {
+        insights.push(`  ... and ${analysis.memberBreakdown.length - 5} more`);
+    }
+    return insights;
+}

package/dist/features/team/index.js

@@ -0,0 +1,30 @@
+"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.buildTeamSection = exports.formatTeamInsights = exports.loadTeamFile = exports.parseAuthorFilter = exports.filterCommitsByAuthor = exports.analyzeTeam = void 0;
+/**
+ * Team Feature
+ * @module features/team
+ */
+__exportStar(require("./types"), exports);
+var analyzer_1 = require("./analyzer");
+Object.defineProperty(exports, "analyzeTeam", { enumerable: true, get: function () { return analyzer_1.analyzeTeam; } });
+Object.defineProperty(exports, "filterCommitsByAuthor", { enumerable: true, get: function () { return analyzer_1.filterCommitsByAuthor; } });
+Object.defineProperty(exports, "parseAuthorFilter", { enumerable: true, get: function () { return analyzer_1.parseAuthorFilter; } });
+Object.defineProperty(exports, "loadTeamFile", { enumerable: true, get: function () { return analyzer_1.loadTeamFile; } });
+Object.defineProperty(exports, "formatTeamInsights", { enumerable: true, get: function () { return analyzer_1.formatTeamInsights; } });
+var template_1 = require("./template");
+Object.defineProperty(exports, "buildTeamSection", { enumerable: true, get: function () { return template_1.buildTeamSection; } });

package/dist/features/team/template.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTeamSection = buildTeamSection;
+/**
+ * Builds the HTML section for team analysis visualization
+ */
+function buildTeamSection(analysis) {
+    if (!analysis || analysis.members.length === 0) {
+        return '<p class="no-data">No team data available</p>';
+    }
+    const { teamMetrics, memberBreakdown, loadDistribution } = analysis;
+    // Build summary cards
+    const summaryHtml = buildSummaryCards(teamMetrics, analysis.members.length);
+    // Build load distribution indicator
+    const loadDistHtml = buildLoadDistribution(loadDistribution);
+    // Build member breakdown
+    const membersHtml = buildMemberList(memberBreakdown);
+    // Build insights
+    const insightsHtml = buildInsights(loadDistribution.insights);
+    return `
+    <div class="team-section">
+      ${summaryHtml}
+      ${loadDistHtml}
+      ${membersHtml}
+      ${insightsHtml}
+    </div>
+  `;
+}
+function buildSummaryCards(metrics, memberCount) {
+    return `
+    <div class="team-summary">
+      <div class="team-stat-card">
+        <span class="stat-value">${metrics.totalCommits.toLocaleString()}</span>
+        <span class="stat-label">Total Commits</span>
+      </div>
+      <div class="team-stat-card">
+        <span class="stat-value">${memberCount}</span>
+        <span class="stat-label">Team Members</span>
+      </div>
+      <div class="team-stat-card">
+        <span class="stat-value">${metrics.commitsPerMember.toFixed(1)}</span>
+        <span class="stat-label">Commits/Member</span>
+      </div>
+      <div class="team-stat-card">
+        <span class="stat-value">${metrics.activeDays}</span>
+        <span class="stat-label">Active Days</span>
+      </div>
+      <div class="team-stat-card">
+        <span class="stat-value">${metrics.qualityScore.toFixed(1)}</span>
+        <span class="stat-label">Avg Quality</span>
+      </div>
+    </div>
+  `;
+}
+function buildLoadDistribution(loadDist) {
+    const gini = loadDist.giniCoefficient;
+    const percentage = Math.round(gini * 100);
+    // Color based on assessment
+    let colorClass = 'balanced';
+    let statusIcon = '✅';
+    if (loadDist.assessment === 'moderate-imbalance') {
+        colorClass = 'moderate';
+        statusIcon = '⚠️';
+    }
+    else if (loadDist.assessment === 'high-imbalance') {
+        colorClass = 'imbalanced';
+        statusIcon = '🚨';
+    }
+    const assessmentLabel = loadDist.assessment.replace('-', ' ').replace(/\b\w/g, c => c.toUpperCase());
+    return `
+    <div class="load-distribution">
+      <h3>Load Distribution</h3>
+      <div class="gini-container">
+        <div class="gini-bar-bg">
+          <div class="gini-bar ${colorClass}" style="width: ${percentage}%"></div>
+        </div>
+        <div class="gini-info">
+          <span class="gini-value">Gini: ${gini.toFixed(2)}</span>
+          <span class="gini-assessment ${colorClass}">${statusIcon} ${assessmentLabel}</span>
+        </div>
+      </div>
+      <p class="gini-explanation">
+        ${gini < 0.3 ? 'Work is evenly distributed across the team.' :
+        gini < 0.5 ? 'Some team members are contributing more than others.' :
+            'Work is concentrated among a few contributors. Consider redistributing.'}
+      </p>
+    </div>
+  `;
+}
+function buildMemberList(members) {
+    // Sort by commits descending
+    const sorted = [...members].sort((a, b) => b.commits - a.commits);
+    const maxCommits = sorted[0]?.commits || 1;
+    const membersHtml = sorted.map((member, index) => {
+        const barWidth = (member.commits / maxCommits) * 100;
+        const rankBadge = index === 0 ? '👑' : index < 3 ? '⭐' : '';
+        return `
+      <div class="member-card">
+        <div class="member-rank">${index + 1}</div>
+        <div class="member-info">
+          <div class="member-name">${rankBadge} ${escapeHtml(member.author)}</div>
+          <div class="member-areas">${member.topAreas.slice(0, 3).map(a => `<span class="area-tag">${escapeHtml(a)}</span>`).join('')}</div>
+        </div>
+        <div class="member-bar-container">
+          <div class="member-bar" style="width: ${barWidth}%"></div>
+        </div>
+        <div class="member-stats">
+          <span class="member-commits">${member.commits}</span>
+          <span class="member-percentage">(${member.percentage.toFixed(1)}%)</span>
+        </div>
+        <div class="member-quality" title="Commit quality score">
+          <span class="quality-badge">${member.qualityScore.toFixed(1)}</span>
+        </div>
+      </div>
+    `;
+    }).join('');
+    return `
+    <div class="member-breakdown">
+      <h3>Team Members</h3>
+      <div class="member-list">
+        ${membersHtml}
+      </div>
+    </div>
+  `;
+}
+function buildInsights(insights) {
+    if (!insights || insights.length === 0) {
+        return '';
+    }
+    return `
+    <div class="team-insights">
+      <h3>Insights</h3>
+      <ul class="insights-list">
+        ${insights.map(insight => `<li class="insight-item">💡 ${escapeHtml(insight)}</li>`).join('')}
+      </ul>
+    </div>
+  `;
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}

package/dist/features/team/types.js

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