repo-wrapped 0.0.2

package/dist/utils/impactAnalyzer.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImpact = void 0;
+// 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 [];
+}
+/**
+ * Analyze impact of commits
+ */
+function analyzeImpact(commits, changedFiles) {
+    if (commits.length === 0) {
+        return 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
+    };
+}
+exports.analyzeImpact = analyzeImpact;
+/**
+ * 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
+}
+/**
+ * Return empty analysis for no commits
+ */
+function getEmptyImpactAnalysis() {
+    return {
+        overallScore: 0,
+        scoreBreakdown: {
+            coreContributions: 0,
+            featureWork: 0,
+            maintenanceWork: 0,
+            documentationWork: 0,
+        },
+        topImpactFiles: [],
+        impactTrend: 'stable',
+        insights: ['No commit data available for analysis']
+    };
+}

package/dist/utils/knowledgeDistributionAnalyzer.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeKnowledgeDistribution = void 0;
+const child_process_1 = require("child_process");
+/**
+ * Extract directory from file path
+ */
+function getDirectory(filePath) {
+    const parts = filePath.replace(/\\/g, '/').split('/');
+    if (parts.length <= 1)
+        return '/';
+    return parts.slice(0, -1).join('/');
+}
+/**
+ * Calculate bus factor risk score
+ * 1 owner = 10 (critical), 2 = 7 (high), 3 = 4 (medium), 4+ = 1 (low)
+ */
+function calculateRiskScore(significantOwners) {
+    if (significantOwners === 0)
+        return 10;
+    if (significantOwners === 1)
+        return 10;
+    if (significantOwners === 2)
+        return 7;
+    if (significantOwners === 3)
+        return 4;
+    return 1;
+}
+/**
+ * Determine ownership type based on contribution percentages
+ */
+function determineOwnershipType(owners) {
+    if (owners.length === 0)
+        return 'solo';
+    const topOwnerPercentage = owners[0]?.percentage || 0;
+    if (topOwnerPercentage >= 100)
+        return 'solo';
+    if (topOwnerPercentage >= 70)
+        return 'primary';
+    if (topOwnerPercentage >= 40)
+        return 'shared';
+    return 'collaborative';
+}
+/**
+ * Get risk level from score
+ */
+function getRiskLevel(score) {
+    if (score >= 9)
+        return 'critical';
+    if (score >= 6)
+        return 'high';
+    if (score >= 3)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Calculate knowledge age in human-readable format
+ */
+function calculateKnowledgeAge(lastActive) {
+    const now = new Date();
+    const diffMs = now.getTime() - lastActive.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w`;
+    if (diffDays < 365)
+        return `${Math.floor(diffDays / 30)}mo`;
+    return `${Math.floor(diffDays / 365)}y`;
+}
+/**
+ * Determine if an area is high risk
+ * High risk = bus factor 1 OR (bus factor ≤ 2 AND knowledge age > 3 months)
+ */
+function isHighRisk(busFactorRisk, lastActive) {
+    const daysSinceActive = Math.floor((Date.now() - lastActive.getTime()) / (1000 * 60 * 60 * 24));
+    const threeMonths = 90;
+    if (busFactorRisk >= 10)
+        return true; // Bus factor 1
+    if (busFactorRisk >= 7 && daysSinceActive > threeMonths)
+        return true; // Bus factor 2 + stale
+    return false;
+}
+/**
+ * Parse git log with file names for deep analysis
+ */
+function parseGitLogWithFiles(repoPath) {
+    const fileStats = new Map();
+    try {
+        // Get git log with files: format is "hash|author|date" followed by file names
+        const gitLog = (0, child_process_1.execSync)('git log --name-only --pretty=format:"%H|%an|%ad" --date=iso', { cwd: repoPath, encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 });
+        const lines = gitLog.split('\n');
+        let currentAuthor = '';
+        let currentDate = new Date();
+        for (const line of lines) {
+            if (line.includes('|')) {
+                // This is a commit header line
+                const parts = line.split('|');
+                currentAuthor = parts[1]?.trim() || 'Unknown';
+                currentDate = new Date(parts[2]?.trim() || Date.now());
+            }
+            else if (line.trim()) {
+                // This is a file path
+                const filePath = line.trim().replace(/\\/g, '/');
+                // Skip common non-code files
+                if (filePath.includes('node_modules/') ||
+                    filePath.includes('.git/') ||
+                    filePath.endsWith('.lock') ||
+                    filePath.endsWith('.log')) {
+                    continue;
+                }
+                if (!fileStats.has(filePath)) {
+                    fileStats.set(filePath, { authors: new Map() });
+                }
+                const fileData = fileStats.get(filePath);
+                const authorData = fileData.authors.get(currentAuthor) || { commits: 0, lastActive: currentDate };
+                fileData.authors.set(currentAuthor, {
+                    commits: authorData.commits + 1,
+                    lastActive: currentDate > authorData.lastActive ? currentDate : authorData.lastActive
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Silent fail - return empty map if git log fails
+    }
+    return fileStats;
+}
+/**
+ * Build file ownership data for a directory
+ */
+function buildFileOwnership(fileStats, directoryPath) {
+    const files = [];
+    fileStats.forEach((data, filePath) => {
+        const dir = getDirectory(filePath);
+        if (dir !== directoryPath && !filePath.startsWith(directoryPath + '/')) {
+            return;
+        }
+        const totalCommits = Array.from(data.authors.values()).reduce((sum, a) => sum + a.commits, 0);
+        let primaryOwner = 'Unknown';
+        let maxCommits = 0;
+        let lastModified = new Date(0);
+        data.authors.forEach((authorData, author) => {
+            if (authorData.commits > maxCommits) {
+                maxCommits = authorData.commits;
+                primaryOwner = author;
+            }
+            if (authorData.lastActive > lastModified) {
+                lastModified = authorData.lastActive;
+            }
+        });
+        const ownershipPercentage = Math.round((maxCommits / totalCommits) * 100);
+        const knowledgeAge = calculateKnowledgeAge(lastModified);
+        const significantOwners = Array.from(data.authors.values()).filter(a => (a.commits / totalCommits) >= 0.2).length;
+        const busFactorRiskScore = calculateRiskScore(significantOwners);
+        const riskLevel = getRiskLevel(busFactorRiskScore);
+        files.push({
+            path: filePath,
+            primaryOwner,
+            ownershipPercentage,
+            lastModified,
+            knowledgeAge,
+            riskLevel,
+            busFactorRisk: busFactorRiskScore >= 7
+        });
+    });
+    // Sort by risk (high risk first), then by ownership percentage (high percentage = more concentrated = more risk)
+    return files
+        .filter(f => f.path.startsWith(directoryPath + '/') || getDirectory(f.path) === directoryPath)
+        .sort((a, b) => {
+        if (a.busFactorRisk !== b.busFactorRisk)
+            return a.busFactorRisk ? -1 : 1;
+        return b.ownershipPercentage - a.ownershipPercentage;
+    })
+        .slice(0, 20); // Limit to 20 files per directory
+}
+/**
+ * Analyze knowledge distribution across the codebase
+ */
+function analyzeKnowledgeDistribution(commits, repoPath, deepAnalysis = false) {
+    if (commits.length === 0) {
+        return getEmptyKnowledgeDistribution();
+    }
+    // For deep analysis, parse git log with file names
+    let fileStats = null;
+    if (deepAnalysis && repoPath) {
+        fileStats = parseGitLogWithFiles(repoPath);
+    }
+    // Build directory → author → commits mapping
+    const directoryStats = new Map();
+    if (fileStats && fileStats.size > 0) {
+        // Use actual file data for directory stats
+        fileStats.forEach((data, filePath) => {
+            const dir = getDirectory(filePath);
+            if (!directoryStats.has(dir)) {
+                directoryStats.set(dir, new Map());
+            }
+            const dirAuthors = directoryStats.get(dir);
+            data.authors.forEach((authorData, author) => {
+                const existing = dirAuthors.get(author) || { commits: 0, lastActive: authorData.lastActive };
+                dirAuthors.set(author, {
+                    commits: existing.commits + authorData.commits,
+                    lastActive: authorData.lastActive > existing.lastActive ? authorData.lastActive : existing.lastActive
+                });
+            });
+        });
+    }
+    else {
+        // Fallback: use heuristics based on commit messages
+        commits.forEach(commit => {
+            const author = commit.author;
+            const commitDate = new Date(commit.date);
+            const directories = new Set();
+            // Try to extract directories from commit message (simplified)
+            const pathMatch = commit.message.match(/(?:in|for|to)\s+([a-zA-Z0-9_\-./]+)/g);
+            if (pathMatch) {
+                pathMatch.forEach(match => {
+                    const path = match.replace(/^(?:in|for|to)\s+/, '');
+                    if (path.includes('/')) {
+                        directories.add(getDirectory(path));
+                    }
+                });
+            }
+            // Default directory based on commit type
+            if (directories.size === 0) {
+                const type = commit.message.match(/^(feat|fix|docs|test|refactor)/i)?.[1]?.toLowerCase();
+                switch (type) {
+                    case 'feat':
+                    case 'fix':
+                    case 'refactor':
+                        directories.add('src');
+                        break;
+                    case 'docs':
+                        directories.add('docs');
+                        break;
+                    case 'test':
+                        directories.add('test');
+                        break;
+                    default:
+                        directories.add('src');
+                }
+            }
+            directories.forEach(dir => {
+                if (!directoryStats.has(dir)) {
+                    directoryStats.set(dir, new Map());
+                }
+                const dirAuthors = directoryStats.get(dir);
+                const existing = dirAuthors.get(author) || { commits: 0, lastActive: commitDate };
+                dirAuthors.set(author, {
+                    commits: existing.commits + 1,
+                    lastActive: commitDate > existing.lastActive ? commitDate : existing.lastActive
+                });
+            });
+        });
+    }
+    // Build directory ownership array
+    const directories = [];
+    const knowledgeSilos = [];
+    const sharedKnowledge = [];
+    const criticalPaths = [];
+    let totalRiskScore = 0;
+    let dirCount = 0;
+    directoryStats.forEach((authorStats, dirPath) => {
+        const totalCommits = Array.from(authorStats.values()).reduce((sum, a) => sum + a.commits, 0);
+        // Get the latest activity date for the directory
+        let latestActivity = new Date(0);
+        authorStats.forEach(stats => {
+            if (stats.lastActive > latestActivity) {
+                latestActivity = stats.lastActive;
+            }
+        });
+        const owners = Array.from(authorStats.entries())
+            .map(([author, stats]) => ({
+            author,
+            commits: stats.commits,
+            percentage: Math.round((stats.commits / totalCommits) * 100),
+            lastActive: stats.lastActive,
+            knowledgeAge: calculateKnowledgeAge(stats.lastActive)
+        }))
+            .sort((a, b) => b.commits - a.commits);
+        // Calculate significant owners (>= 20% contribution)
+        const significantOwners = owners.filter(o => o.percentage >= 20).length;
+        const busFactorRisk = calculateRiskScore(significantOwners);
+        const ownershipType = determineOwnershipType(owners);
+        // Build high-risk files list if deep analysis is enabled
+        let highRiskFiles;
+        if (deepAnalysis && fileStats && isHighRisk(busFactorRisk, latestActivity)) {
+            highRiskFiles = buildFileOwnership(fileStats, dirPath);
+        }
+        directories.push({
+            path: dirPath,
+            totalCommits,
+            owners,
+            ownershipType,
+            busFactorRisk,
+            highRiskFiles
+        });
+        // Track silos and shared knowledge
+        if (ownershipType === 'solo') {
+            knowledgeSilos.push(`${dirPath} — ${owners[0]?.author || 'Unknown'} (100%)`);
+            criticalPaths.push(dirPath);
+        }
+        else if (ownershipType === 'collaborative' || significantOwners >= 3) {
+            sharedKnowledge.push(dirPath);
+        }
+        totalRiskScore += busFactorRisk;
+        dirCount++;
+    });
+    // Calculate overall bus factor risk
+    const overallRisk = dirCount > 0 ? Math.round(totalRiskScore / dirCount) : 0;
+    // Generate recommendations
+    const recommendations = generateRecommendations({
+        knowledgeSilos,
+        sharedKnowledge,
+        directories,
+        overallRisk
+    });
+    return {
+        directories: directories.sort((a, b) => b.busFactorRisk - a.busFactorRisk).slice(0, 15),
+        busFactorRisk: {
+            overall: overallRisk,
+            level: getRiskLevel(overallRisk),
+            criticalPaths
+        },
+        knowledgeSilos: knowledgeSilos.slice(0, 10),
+        sharedKnowledge: sharedKnowledge.slice(0, 10),
+        recommendations,
+        isDeepAnalysis: deepAnalysis
+    };
+}
+exports.analyzeKnowledgeDistribution = analyzeKnowledgeDistribution;
+/**
+ * Generate recommendations based on knowledge distribution
+ */
+function generateRecommendations(data) {
+    const recommendations = [];
+    if (data.knowledgeSilos.length > 0) {
+        recommendations.push(`Consider cross-training on ${data.knowledgeSilos.length} knowledge silo(s) to reduce bus factor risk`);
+    }
+    if (data.overallRisk >= 7) {
+        recommendations.push('High bus factor risk detected — prioritize knowledge sharing sessions');
+    }
+    const soloDirectories = data.directories.filter(d => d.ownershipType === 'solo');
+    if (soloDirectories.length > 3) {
+        recommendations.push(`${soloDirectories.length} directories have single owners — pair programming recommended`);
+    }
+    if (data.sharedKnowledge.length > 0) {
+        recommendations.push(`Good knowledge distribution in ${data.sharedKnowledge.length} area(s) — maintain this pattern`);
+    }
+    const inactiveOwners = data.directories.flatMap(d => d.owners.filter(o => {
+        const daysSinceActive = Math.floor((Date.now() - o.lastActive.getTime()) / (1000 * 60 * 60 * 24));
+        return daysSinceActive > 60 && o.percentage > 30;
+    }));
+    if (inactiveOwners.length > 0) {
+        recommendations.push('Some significant contributors have been inactive — ensure knowledge transfer');
+    }
+    return recommendations.slice(0, 5);
+}
+/**
+ * Return empty distribution for no commits
+ */
+function getEmptyKnowledgeDistribution() {
+    return {
+        directories: [],
+        busFactorRisk: {
+            overall: 0,
+            level: 'low',
+            criticalPaths: []
+        },
+        knowledgeSilos: [],
+        sharedKnowledge: [],
+        recommendations: ['No commit data available for analysis']
+    };
+}