repo-wrapped 0.0.3 → 0.0.4

package/dist/utils/fileHotspotAnalyzer.js

@@ -1,270 +1,269 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOwnershipIcon = exports.getRiskLevelColor = exports.analyzeFileHotspots = void 0;
-const child_process_1 = require("child_process");
-function analyzeFileHotspots(repoPath, startDate, endDate) {
-    try {
-        // Get file changes with author info from git log
-        const since = startDate.toISOString().split('T')[0];
-        const until = endDate.toISOString().split('T')[0];
-        let gitLog;
-        try {
-            gitLog = (0, child_process_1.execSync)(`git log --name-only --format="%H|%an|%ad" --date=short --since="${since}" --until="${until}"`, { cwd: repoPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }).trim();
-        }
-        catch (gitError) {
-            // Git command failed, likely not in a git repo or no commits in range
-            return getEmptyAnalysis();
-        }
-        if (!gitLog) {
-            return getEmptyAnalysis();
-        }
-        // Parse git log output
-        const fileMap = new Map();
-        const lines = gitLog.split('\n');
-        let currentCommit = null;
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.includes('|')) {
-                // Commit header line
-                const [hash, author, date] = trimmed.split('|');
-                currentCommit = { hash, author, date };
-            }
-            else if (trimmed && currentCommit) {
-                // File path line
-                const filePath = trimmed;
-                // Skip binary files, lock files, and common generated files
-                if (shouldIgnoreFile(filePath)) {
-                    continue;
-                }
-                if (!fileMap.has(filePath)) {
-                    fileMap.set(filePath, {
-                        path: filePath,
-                        changeCount: 0,
-                        authors: [],
-                        authorDistribution: {},
-                        firstChange: new Date(currentCommit.date),
-                        lastChange: new Date(currentCommit.date),
-                        complexityScore: 0
-                    });
-                }
-                const fileStats = fileMap.get(filePath);
-                fileStats.changeCount++;
-                // Track authors
-                if (!fileStats.authors.includes(currentCommit.author)) {
-                    fileStats.authors.push(currentCommit.author);
-                }
-                fileStats.authorDistribution[currentCommit.author] =
-                    (fileStats.authorDistribution[currentCommit.author] || 0) + 1;
-                // Update dates
-                const commitDate = new Date(currentCommit.date);
-                if (commitDate < fileStats.firstChange) {
-                    fileStats.firstChange = commitDate;
-                }
-                if (commitDate > fileStats.lastChange) {
-                    fileStats.lastChange = commitDate;
-                }
-            }
-        }
-        // Calculate complexity scores
-        for (const fileStats of fileMap.values()) {
-            fileStats.complexityScore = calculateComplexityScore(fileStats);
-        }
-        // Get top files
-        const topFiles = Array.from(fileMap.values())
-            .sort((a, b) => b.changeCount - a.changeCount)
-            .slice(0, 20);
-        // Analyze directories
-        const topDirectories = analyzeDirectories(fileMap);
-        // Identify technical debt
-        const technicalDebt = identifyTechnicalDebt(Array.from(fileMap.values()));
-        // Analyze ownership risks
-        const ownershipRisks = analyzeOwnership(Array.from(fileMap.values()));
-        return {
-            topFiles,
-            topDirectories,
-            technicalDebt,
-            ownershipRisks,
-            totalFilesAnalyzed: fileMap.size
-        };
-    }
-    catch (error) {
-        console.error('Error analyzing file hotspots:', error);
-        return getEmptyAnalysis();
-    }
-}
-exports.analyzeFileHotspots = analyzeFileHotspots;
-function shouldIgnoreFile(path) {
-    const ignoredExtensions = ['.lock', '.log', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
-    const ignoredPatterns = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'node_modules/', 'dist/', 'build/', '.next/', 'coverage/'];
-    // Check extensions
-    if (ignoredExtensions.some(ext => path.toLowerCase().endsWith(ext))) {
-        return true;
-    }
-    // Check patterns
-    if (ignoredPatterns.some(pattern => path.includes(pattern))) {
-        return true;
-    }
-    return false;
-}
-function calculateComplexityScore(fileStats) {
-    let score = 0;
-    // High churn
-    if (fileStats.changeCount > 100)
-        score += 3;
-    else if (fileStats.changeCount > 50)
-        score += 2;
-    else if (fileStats.changeCount > 25)
-        score += 1;
-    // Many authors
-    if (fileStats.authors.length > 10)
-        score += 2;
-    else if (fileStats.authors.length > 5)
-        score += 1;
-    // Time since last change (older = potentially more stable, but also potentially abandoned)
-    const daysSinceLastChange = Math.floor((Date.now() - fileStats.lastChange.getTime()) / (1000 * 60 * 60 * 24));
-    if (daysSinceLastChange > 180)
-        score += 1; // No changes in 6 months
-    return Math.min(10, score);
-}
-function analyzeDirectories(fileMap) {
-    const dirMap = new Map();
-    // Group files by directory
-    for (const file of fileMap.values()) {
-        const dirPath = file.path.includes('/')
-            ? file.path.substring(0, file.path.lastIndexOf('/'))
-            : '.';
-        if (!dirMap.has(dirPath)) {
-            dirMap.set(dirPath, { files: [], totalChanges: 0 });
-        }
-        const dirStats = dirMap.get(dirPath);
-        dirStats.files.push(file);
-        dirStats.totalChanges += file.changeCount;
-    }
-    // Create directory stats
-    const directories = [];
-    for (const [path, data] of dirMap) {
-        const mostActive = data.files.sort((a, b) => b.changeCount - a.changeCount)[0];
-        directories.push({
-            path,
-            totalChanges: data.totalChanges,
-            fileCount: data.files.length,
-            avgChangesPerFile: data.totalChanges / data.files.length,
-            mostActiveFile: mostActive.path
-        });
-    }
-    return directories
-        .sort((a, b) => b.totalChanges - a.totalChanges)
-        .slice(0, 10);
-}
-function identifyTechnicalDebt(files) {
-    const debtFiles = [];
-    for (const file of files) {
-        const score = file.complexityScore;
-        // Only flag files with complexity score >= 4
-        if (score < 4)
-            continue;
-        let riskLevel = 'low';
-        if (score >= 8)
-            riskLevel = 'critical';
-        else if (score >= 6)
-            riskLevel = 'high';
-        else if (score >= 4)
-            riskLevel = 'medium';
-        const recommendations = [];
-        if (file.changeCount > 50) {
-            recommendations.push('High change frequency - consider refactoring for stability');
-        }
-        if (file.authors.length > 8) {
-            recommendations.push('Many different authors - ensure clear ownership');
-        }
-        const daysSinceLastChange = Math.floor((Date.now() - file.lastChange.getTime()) / (1000 * 60 * 60 * 24));
-        if (daysSinceLastChange > 180) {
-            recommendations.push('No recent changes - may be stable or abandoned');
-        }
-        debtFiles.push({
-            file: file.path,
-            riskLevel,
-            changeCount: file.changeCount,
-            authorCount: file.authors.length,
-            lastModified: file.lastChange,
-            score,
-            recommendations
-        });
-    }
-    return debtFiles.sort((a, b) => b.score - a.score).slice(0, 10);
-}
-function analyzeOwnership(files) {
-    const ownershipData = [];
-    for (const file of files) {
-        // Only analyze files with multiple commits
-        if (file.changeCount < 3)
-            continue;
-        // Calculate owner percentages
-        const owners = Object.entries(file.authorDistribution)
-            .map(([author, commits]) => ({
-            author,
-            commits,
-            percentage: (commits / file.changeCount) * 100
-        }))
-            .sort((a, b) => b.commits - a.commits)
-            .slice(0, 5); // Top 5 contributors
-        // Determine ownership type
-        let ownershipType = 'collaborative';
-        let busFactorRisk = 0;
-        if (owners.length === 1 || owners[0].percentage >= 90) {
-            ownershipType = 'single-owner';
-            busFactorRisk = 9;
-        }
-        else if (owners[0].percentage >= 70) {
-            ownershipType = 'single-owner';
-            busFactorRisk = 7;
-        }
-        else if (owners[0].percentage >= 50) {
-            ownershipType = 'shared';
-            busFactorRisk = 4;
-        }
-        else {
-            ownershipType = 'collaborative';
-            busFactorRisk = 2;
-        }
-        ownershipData.push({
-            file: file.path,
-            owners,
-            ownershipType,
-            busFactorRisk
-        });
-    }
-    // Return files with ownership risks
-    return ownershipData
-        .filter(o => o.busFactorRisk >= 7)
-        .sort((a, b) => b.busFactorRisk - a.busFactorRisk)
-        .slice(0, 10);
-}
-function getEmptyAnalysis() {
-    return {
-        topFiles: [],
-        topDirectories: [],
-        technicalDebt: [],
-        ownershipRisks: [],
-        totalFilesAnalyzed: 0
-    };
-}
-function getRiskLevelColor(level) {
-    switch (level) {
-        case 'critical': return '🔴';
-        case 'high': return '🟠';
-        case 'medium': return '🟡';
-        case 'low': return '🟢';
-        default: return '⚪';
-    }
-}
-exports.getRiskLevelColor = getRiskLevelColor;
-function getOwnershipIcon(type) {
-    switch (type) {
-        case 'single-owner': return '🔴';
-        case 'shared': return '🟡';
-        case 'collaborative': return '🟢';
-        default: return '⚪';
-    }
-}
-exports.getOwnershipIcon = getOwnershipIcon;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFileHotspots = analyzeFileHotspots;
+exports.getRiskLevelColor = getRiskLevelColor;
+exports.getOwnershipIcon = getOwnershipIcon;
+const child_process_1 = require("child_process");
+function analyzeFileHotspots(repoPath, startDate, endDate) {
+    try {
+        // Get file changes with author info from git log
+        const since = startDate.toISOString().split('T')[0];
+        const until = endDate.toISOString().split('T')[0];
+        let gitLog;
+        try {
+            gitLog = (0, child_process_1.execSync)(`git log --name-only --format="%H|%an|%ad" --date=short --since="${since}" --until="${until}"`, { cwd: repoPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }).trim();
+        }
+        catch (gitError) {
+            // Git command failed, likely not in a git repo or no commits in range
+            return getEmptyAnalysis();
+        }
+        if (!gitLog) {
+            return getEmptyAnalysis();
+        }
+        // Parse git log output
+        const fileMap = new Map();
+        const lines = gitLog.split('\n');
+        let currentCommit = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.includes('|')) {
+                // Commit header line
+                const [hash, author, date] = trimmed.split('|');
+                currentCommit = { hash, author, date };
+            }
+            else if (trimmed && currentCommit) {
+                // File path line
+                const filePath = trimmed;
+                // Skip binary files, lock files, and common generated files
+                if (shouldIgnoreFile(filePath)) {
+                    continue;
+                }
+                if (!fileMap.has(filePath)) {
+                    fileMap.set(filePath, {
+                        path: filePath,
+                        changeCount: 0,
+                        authors: [],
+                        authorDistribution: {},
+                        firstChange: new Date(currentCommit.date),
+                        lastChange: new Date(currentCommit.date),
+                        complexityScore: 0
+                    });
+                }
+                const fileStats = fileMap.get(filePath);
+                fileStats.changeCount++;
+                // Track authors
+                if (!fileStats.authors.includes(currentCommit.author)) {
+                    fileStats.authors.push(currentCommit.author);
+                }
+                fileStats.authorDistribution[currentCommit.author] =
+                    (fileStats.authorDistribution[currentCommit.author] || 0) + 1;
+                // Update dates
+                const commitDate = new Date(currentCommit.date);
+                if (commitDate < fileStats.firstChange) {
+                    fileStats.firstChange = commitDate;
+                }
+                if (commitDate > fileStats.lastChange) {
+                    fileStats.lastChange = commitDate;
+                }
+            }
+        }
+        // Calculate complexity scores
+        for (const fileStats of fileMap.values()) {
+            fileStats.complexityScore = calculateComplexityScore(fileStats);
+        }
+        // Get top files
+        const topFiles = Array.from(fileMap.values())
+            .sort((a, b) => b.changeCount - a.changeCount)
+            .slice(0, 20);
+        // Analyze directories
+        const topDirectories = analyzeDirectories(fileMap);
+        // Identify technical debt
+        const technicalDebt = identifyTechnicalDebt(Array.from(fileMap.values()));
+        // Analyze ownership risks
+        const ownershipRisks = analyzeOwnership(Array.from(fileMap.values()));
+        return {
+            topFiles,
+            topDirectories,
+            technicalDebt,
+            ownershipRisks,
+            totalFilesAnalyzed: fileMap.size
+        };
+    }
+    catch (error) {
+        console.error('Error analyzing file hotspots:', error);
+        return getEmptyAnalysis();
+    }
+}
+function shouldIgnoreFile(path) {
+    const ignoredExtensions = ['.lock', '.log', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
+    const ignoredPatterns = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'node_modules/', 'dist/', 'build/', '.next/', 'coverage/'];
+    // Check extensions
+    if (ignoredExtensions.some(ext => path.toLowerCase().endsWith(ext))) {
+        return true;
+    }
+    // Check patterns
+    if (ignoredPatterns.some(pattern => path.includes(pattern))) {
+        return true;
+    }
+    return false;
+}
+function calculateComplexityScore(fileStats) {
+    let score = 0;
+    // High churn
+    if (fileStats.changeCount > 100)
+        score += 3;
+    else if (fileStats.changeCount > 50)
+        score += 2;
+    else if (fileStats.changeCount > 25)
+        score += 1;
+    // Many authors
+    if (fileStats.authors.length > 10)
+        score += 2;
+    else if (fileStats.authors.length > 5)
+        score += 1;
+    // Time since last change (older = potentially more stable, but also potentially abandoned)
+    const daysSinceLastChange = Math.floor((Date.now() - fileStats.lastChange.getTime()) / (1000 * 60 * 60 * 24));
+    if (daysSinceLastChange > 180)
+        score += 1; // No changes in 6 months
+    return Math.min(10, score);
+}
+function analyzeDirectories(fileMap) {
+    const dirMap = new Map();
+    // Group files by directory
+    for (const file of fileMap.values()) {
+        const dirPath = file.path.includes('/')
+            ? file.path.substring(0, file.path.lastIndexOf('/'))
+            : '.';
+        if (!dirMap.has(dirPath)) {
+            dirMap.set(dirPath, { files: [], totalChanges: 0 });
+        }
+        const dirStats = dirMap.get(dirPath);
+        dirStats.files.push(file);
+        dirStats.totalChanges += file.changeCount;
+    }
+    // Create directory stats
+    const directories = [];
+    for (const [path, data] of dirMap) {
+        const mostActive = data.files.sort((a, b) => b.changeCount - a.changeCount)[0];
+        directories.push({
+            path,
+            totalChanges: data.totalChanges,
+            fileCount: data.files.length,
+            avgChangesPerFile: data.totalChanges / data.files.length,
+            mostActiveFile: mostActive.path
+        });
+    }
+    return directories
+        .sort((a, b) => b.totalChanges - a.totalChanges)
+        .slice(0, 10);
+}
+function identifyTechnicalDebt(files) {
+    const debtFiles = [];
+    for (const file of files) {
+        const score = file.complexityScore;
+        // Only flag files with complexity score >= 4
+        if (score < 4)
+            continue;
+        let riskLevel = 'low';
+        if (score >= 8)
+            riskLevel = 'critical';
+        else if (score >= 6)
+            riskLevel = 'high';
+        else if (score >= 4)
+            riskLevel = 'medium';
+        const recommendations = [];
+        if (file.changeCount > 50) {
+            recommendations.push('High change frequency - consider refactoring for stability');
+        }
+        if (file.authors.length > 8) {
+            recommendations.push('Many different authors - ensure clear ownership');
+        }
+        const daysSinceLastChange = Math.floor((Date.now() - file.lastChange.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysSinceLastChange > 180) {
+            recommendations.push('No recent changes - may be stable or abandoned');
+        }
+        debtFiles.push({
+            file: file.path,
+            riskLevel,
+            changeCount: file.changeCount,
+            authorCount: file.authors.length,
+            lastModified: file.lastChange,
+            score,
+            recommendations
+        });
+    }
+    return debtFiles.sort((a, b) => b.score - a.score).slice(0, 10);
+}
+function analyzeOwnership(files) {
+    const ownershipData = [];
+    for (const file of files) {
+        // Only analyze files with multiple commits
+        if (file.changeCount < 3)
+            continue;
+        // Calculate owner percentages
+        const owners = Object.entries(file.authorDistribution)
+            .map(([author, commits]) => ({
+            author,
+            commits,
+            percentage: (commits / file.changeCount) * 100
+        }))
+            .sort((a, b) => b.commits - a.commits)
+            .slice(0, 5); // Top 5 contributors
+        // Determine ownership type
+        let ownershipType = 'collaborative';
+        let busFactorRisk = 0;
+        if (owners.length === 1 || owners[0].percentage >= 90) {
+            ownershipType = 'single-owner';
+            busFactorRisk = 9;
+        }
+        else if (owners[0].percentage >= 70) {
+            ownershipType = 'single-owner';
+            busFactorRisk = 7;
+        }
+        else if (owners[0].percentage >= 50) {
+            ownershipType = 'shared';
+            busFactorRisk = 4;
+        }
+        else {
+            ownershipType = 'collaborative';
+            busFactorRisk = 2;
+        }
+        ownershipData.push({
+            file: file.path,
+            owners,
+            ownershipType,
+            busFactorRisk
+        });
+    }
+    // Return files with ownership risks
+    return ownershipData
+        .filter(o => o.busFactorRisk >= 7)
+        .sort((a, b) => b.busFactorRisk - a.busFactorRisk)
+        .slice(0, 10);
+}
+function getEmptyAnalysis() {
+    return {
+        topFiles: [],
+        topDirectories: [],
+        technicalDebt: [],
+        ownershipRisks: [],
+        totalFilesAnalyzed: 0
+    };
+}
+function getRiskLevelColor(level) {
+    switch (level) {
+        case 'critical': return '🔴';
+        case 'high': return '🟠';
+        case 'medium': return '🟡';
+        case 'low': return '🟢';
+        default: return '⚪';
+    }
+}
+function getOwnershipIcon(type) {
+    switch (type) {
+        case 'single-owner': return '🔴';
+        case 'shared': return '🟡';
+        case 'collaborative': return '🟢';
+        default: return '⚪';
+    }
+}