repo-wrapped 0.0.2 → 0.0.4

package/dist/utils/knowledgeDistributionAnalyzer.js

@@ -1,374 +1,373 @@
-"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']
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeKnowledgeDistribution = analyzeKnowledgeDistribution;
+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
+    };
+}
+/**
+ * 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']
+    };
+}