arcvision 0.2.12 → 0.2.15

package/src/core/blastRadius.js

@@ -0,0 +1,299 @@
+/**
+ * Blast Radius Analysis
+ * 
+ * This module computes the blast radius for each file in the architecture map.
+ * Blast radius is defined as the number of files that import a given file.
+ * It also includes transitive dependencies analysis for more comprehensive impact assessment.
+ */
+
+/**
+ * Builds a reverse dependency graph from the architecture map
+ * @param {Object} architectureMap - The architecture map with nodes and edges
+ * @returns {Object} Reverse dependency map where key is imported file and value is array of importing files
+ */
+function buildReverseDependencyGraph(architectureMap) {
+    const reverseGraph = {};
+
+    // Initialize all files in the reverse graph
+    if (architectureMap.nodes && Array.isArray(architectureMap.nodes)) {
+        architectureMap.nodes.forEach(node => {
+            const filePath = node.id;
+            if (filePath && !reverseGraph[filePath]) {
+                reverseGraph[filePath] = [];
+            }
+        });
+    }
+
+    // Build reverse dependencies from edges
+    if (architectureMap.edges && Array.isArray(architectureMap.edges)) {
+        architectureMap.edges.forEach(edge => {
+            if (edge.source && edge.target) {
+                const importingFile = edge.source; // file that imports
+                const importedFile = edge.target;  // file that is imported
+
+                if (!reverseGraph[importedFile]) {
+                    reverseGraph[importedFile] = [];
+                }
+
+                // Add the importing file to the list of files that depend on importedFile
+                if (!reverseGraph[importedFile].includes(importingFile)) {
+                    reverseGraph[importedFile].push(importingFile);
+                }
+            }
+        });
+    }
+
+    return reverseGraph;
+}
+
+/**
+ * Computes blast radius for each file
+ * @param {Object} reverseGraph - The reverse dependency graph
+ * @returns {Object} Map of file paths to their blast radius (number of files that import them)
+ */
+function computeBlastRadius(reverseGraph) {
+    const blastRadiusMap = {};
+
+    for (const [filePath, importingFiles] of Object.entries(reverseGraph)) {
+        blastRadiusMap[filePath] = Array.isArray(importingFiles) ? importingFiles.length : 0;
+    }
+
+    return blastRadiusMap;
+}
+
+/**
+ * Computes transitive blast radius (indirect dependencies)
+ * @param {Object} reverseGraph - The reverse dependency graph
+ * @param {Object} directBlastRadius - Direct blast radius map
+ * @returns {Object} Map of file paths to their total blast radius (direct + transitive)
+ */
+function computeTransitiveBlastRadius(reverseGraph, directBlastRadius) {
+    const transitiveBlastRadius = {};
+
+    for (const [filePath] of Object.entries(reverseGraph)) {
+        // Calculate transitive dependencies using a breadth-first search
+        const visited = new Set();
+        const queue = [...(reverseGraph[filePath] || [])];
+        let transitiveCount = 0;
+
+        while (queue.length > 0) {
+            const currentFile = queue.shift();
+
+            if (!visited.has(currentFile)) {
+                visited.add(currentFile);
+                transitiveCount++;
+
+                // Add dependencies of this file to the queue
+                if (reverseGraph[currentFile] && Array.isArray(reverseGraph[currentFile])) {
+                    queue.push(...reverseGraph[currentFile]);
+                }
+            }
+        }
+
+        // Total blast radius = direct + transitive
+        transitiveBlastRadius[filePath] = (directBlastRadius[filePath] || 0) + transitiveCount;
+    }
+
+    return transitiveBlastRadius;
+}
+
+/**
+ * Finds the file with the highest blast radius
+ * @param {Object} blastRadiusMap - Map of file paths to their blast radius
+ * @returns {Object|null} Object containing the file path and blast radius, or null if no files
+ */
+function findHighestBlastRadius(blastRadiusMap) {
+    if (Object.keys(blastRadiusMap).length === 0) {
+        return null;
+    }
+
+    let maxFile = null;
+    let maxRadius = -1;
+
+    for (const [filePath, radius] of Object.entries(blastRadiusMap)) {
+        if (radius > maxRadius) {
+            maxRadius = radius;
+            maxFile = { file: filePath, blast_radius: radius };
+        }
+    }
+
+    return maxFile;
+}
+
+/**
+ * Gets the top N files by blast radius
+ * @param {Object} blastRadiusMap - Map of file paths to their blast radius
+ * @param {number} limit - Number of top files to return (default: 3)
+ * @returns {Array} Array of top N files with their blast radius
+ */
+function getTopBlastRadiusFiles(blastRadiusMap, limit = 3) {
+    if (Object.keys(blastRadiusMap).length === 0) {
+        return [];
+    }
+
+    // Convert to array and sort by blast radius descending
+    const sortedFiles = Object.entries(blastRadiusMap)
+        .map(([file, blast_radius]) => ({ file, blast_radius }))
+        .sort((a, b) => {
+            // Sort by blast radius first, then by filename for consistency
+            if (b.blast_radius !== a.blast_radius) {
+                return b.blast_radius - a.blast_radius;
+            }
+            return a.file.localeCompare(b.file);
+        });
+
+    return sortedFiles.slice(0, limit);
+}
+
+/**
+ * Computes blast radius results with percentage of total files
+ * @param {Object} blastRadiusMap - Map of file paths to their blast radius
+ * @param {number} totalFiles - Total number of files in the project
+ * @returns {Array} Array of files with blast radius and percentage
+ */
+function computeBlastRadiusWithPercentage(blastRadiusMap, totalFiles) {
+    if (Object.keys(blastRadiusMap).length === 0 || totalFiles === 0) {
+        return [];
+    }
+
+    return Object.entries(blastRadiusMap)
+        .map(([file, blastRadius]) => {
+            const percentOfGraph = Number(((blastRadius / totalFiles) * 100).toFixed(2));
+            return {
+                file,
+                blastRadius,
+                percentOfGraph
+            };
+        })
+        .sort((a, b) => {
+            // Sort by blast radius first, then by filename for consistency
+            if (b.blastRadius !== a.blastRadius) {
+                return b.blastRadius - a.blastRadius;
+            }
+            return a.file.localeCompare(b.file);
+        });
+}
+
+/**
+ * Analyzes the criticality of files based on multiple factors
+ * @param {Object} blastRadiusMap - Direct blast radius map
+ * @param {Object} reverseGraph - The reverse dependency graph
+ * @param {Array} nodes - The list of nodes in the architecture map
+ * @returns {Array} Array of files with criticality scores
+ */
+function analyzeCriticality(blastRadiusMap, reverseGraph, nodes) {
+    const criticalityAnalysis = [];
+
+    for (const [file, blastRadius] of Object.entries(blastRadiusMap)) {
+        const node = nodes.find(n => n.id === file);
+
+        // Calculate various metrics for criticality
+        const dependencies = reverseGraph[file] ? reverseGraph[file].length : 0; // How many files depend on this file
+        const dependencyStrength = calculateDependencyStrength(reverseGraph, file);
+
+        // Determine criticality score based on multiple factors
+        let criticalityScore = blastRadius; // Start with direct blast radius
+
+        // Add weight for dependency strength
+        criticalityScore += dependencyStrength * 0.5;
+
+        // Add weight if the file has special characteristics (has functions, exports, etc.)
+        if (node && node.metadata) {
+            if (node.metadata.functions && node.metadata.functions.length > 0) {
+                criticalityScore += 1; // Files with functions are more critical
+            }
+            if (node.metadata.classes && node.metadata.classes.length > 0) {
+                criticalityScore += 1.5; // Classes tend to be more central
+            }
+            if (node.metadata.types && node.metadata.types.length > 0) {
+                criticalityScore += 0.5; // Types are foundational
+            }
+            if (node.metadata.exports && node.metadata.exports.length > 0) {
+                criticalityScore += 0.7; // Exporting files are more critical
+            }
+            if (node.metadata.apiCalls && node.metadata.apiCalls.length > 0) {
+                criticalityScore += 1.2; // API calls connect to external systems
+            }
+        }
+        
+        // Add weight based on file path patterns (e.g., auth, core, utils)
+        if (file.toLowerCase().includes('auth')) {
+            criticalityScore += 2;
+        } else if (file.toLowerCase().includes('core') || file.toLowerCase().includes('util') || file.toLowerCase().includes('utils')) {
+            criticalityScore += 1.5;
+        } else if (file.toLowerCase().includes('config') || file.toLowerCase().includes('index')) {
+            criticalityScore += 0.8;
+        }
+        
+        // Boost score for files with higher blast radius
+        if (blastRadius > 10) {
+            criticalityScore *= 1.8; // Very high impact files get more boost
+        } else if (blastRadius > 5) {
+            criticalityScore *= 1.5; // Higher impact files get a boost
+        } else if (blastRadius > 0) {
+            criticalityScore *= 1.1; // Any connected file gets slight boost
+        }
+        
+        // Additional factors for criticality
+        // Files with many outgoing dependencies are also critical
+        if (node && node.dependencies && node.dependencies.length > 5) {
+            criticalityScore += 2; // Highly coupled files
+        } else if (node && node.dependencies && node.dependencies.length > 10) {
+            criticalityScore += 5; // Extremely coupled files
+        }
+        
+        // Files that appear in multiple contexts (e.g. shared folders)
+        if (file.includes('/shared/') || file.includes('/common/') || file.includes('/utils/') || file.includes('/lib/')) {
+            criticalityScore += 1.5; // Shared components are typically more critical
+        }
+
+        criticalityAnalysis.push({
+            file,
+            blastRadius,
+            dependencies,
+            dependencyStrength,
+            criticalityScore: Number(criticalityScore.toFixed(2)),
+            isHub: blastRadius > 5 // Consider files with blast radius > 5 as hubs
+        });
+    }
+
+    // Sort by criticality score descending, then by file name ascending
+    return criticalityAnalysis.sort((a, b) => {
+        if (b.criticalityScore !== a.criticalityScore) {
+            return b.criticalityScore - a.criticalityScore;
+        }
+        return a.file.localeCompare(b.file);
+    });
+}
+
+/**
+ * Calculates the strength of dependencies for a file (how many dependencies it has)
+ * @param {Object} reverseGraph - The reverse dependency graph
+ * @param {string} file - The file to analyze
+ * @returns {number} The dependency strength score
+ */
+function calculateDependencyStrength(reverseGraph, file) {
+    if (!reverseGraph[file] || !Array.isArray(reverseGraph[file])) {
+        return 0;
+    }
+
+    // Calculate the cumulative strength of dependencies
+    let strength = 0;
+    for (const dep of reverseGraph[file]) {
+        if (reverseGraph[dep]) {
+            strength += reverseGraph[dep].length; // How many files the dependency affects
+        }
+    }
+
+    return strength;
+}
+
+module.exports = {
+    buildReverseDependencyGraph,
+    computeBlastRadius,
+    computeTransitiveBlastRadius,
+    findHighestBlastRadius,
+    getTopBlastRadiusFiles,
+    computeBlastRadiusWithPercentage,
+    analyzeCriticality
+};

package/src/core/call-resolver.js

@@ -0,0 +1,196 @@
+/**
+ * Resolves CallExpressions and NewExpressions to symbols using the import graph.
+ * Emits typed edges: CALLS, INSTANTIATES
+ */
+class CallResolver {
+    constructor(symbolIndex, fileMap) {
+        this.symbolIndex = symbolIndex; // Map<symbolId, Symbol>
+        this.fileMap = fileMap; // Map<fileId, FileObject> (to access imports)
+    }
+
+    /**
+     * Resolve calls in all files
+     * @returns {Array<Object>} List of edges
+     */
+    resolve(rawFiles) {
+        const edges = [];
+        console.log(`Resolving calls for ${rawFiles.length} files...`);
+
+        for (const file of rawFiles) {
+            const fileEdges = this._resolveFile(file);
+            edges.push(...fileEdges);
+        }
+
+        console.log(`Resolved ${edges.length} call/instantiate edges.`);
+        return edges;
+    }
+
+    _resolveFile(file) {
+        const edges = [];
+        if (!file.methodCalls) return edges; // generated by method-tracker.js
+
+        const fileId = file.id;
+        const { functionCalls, constructorCalls, methodCalls } = file.methodCalls;
+        const imports = file.metadata.imports || [];
+
+        // Helper to find imported symbol source
+        const resolveImportedSymbol = (symbolName) => {
+            // Check imports
+            for (const imp of imports) {
+                // imp.specifiers: [{local, imported}]
+                if (imp.specifiers) {
+                    const spec = imp.specifiers.find(s => s.local === symbolName);
+                    if (spec) {
+                        // Found import. Now we need the resolved file path of this import.
+                        // This requires the 'resolvedPath' to be present on the import object.
+                        // This implies PathResolver must run BEFORE CallResolver and annotate imports.
+                        if (imp.resolvedPath) {
+                            const targetFileId = imp.resolvedPath;
+                            const targetSymbolName = spec.imported === 'default' ? 'default' : spec.imported; // Or default export name?
+
+                            // Construct potential symbol ID
+                            // Note: If target is a file, we look for 'targetFileId::targetSymbolName'
+                            // Special handling for default exports might be needed if they are named differently in target.
+                            // For now assuming named exports match or 'default'.
+
+                            // Retry finding the exact symbol ID in the target file
+                            // This usually requires a lookup in fileToSymbols or just constructing ID if deterministic
+
+                            // Attempt 1: Named export
+                            let candidateId = `${targetFileId}::${targetSymbolName}`;
+                            if (this.symbolIndex.has(candidateId)) return candidateId;
+
+                            // Attempt 2: If default import, we need to find what is exported as default
+                            if (spec.imported === 'default') {
+                                // Find the symbol in target file that has type 'default' or name 'default'
+                                // The SymbolIndexer indexes 'default' if it's named 'default' or if we handled it.
+                                candidateId = `${targetFileId}::default`;
+                                if (this.symbolIndex.has(candidateId)) return candidateId;
+
+                                // fallback: look for ANY default export in target file via SymbolIndex iteration (expensive but necessary?)
+                                // Better: SymbolIndexer ensure 'default' is the name for default exports.
+                            }
+                            
+                            // Additional attempts for common patterns
+                            // Attempt 3: Try with common function prefixes
+                            const commonPatterns = [
+                                `${targetFileId}::use${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                                `${targetFileId}::get${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                                `${targetFileId}::create${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                                `${targetFileId}::_${targetSymbolName}`, // underscore prefix
+                                `${targetFileId}::${targetSymbolName}Impl`, // implementation suffix
+                                `${targetFileId}::${targetSymbolName}Handler` // handler suffix
+                            ];
+                            
+                            for (const patternId of commonPatterns) {
+                                if (this.symbolIndex.has(patternId)) return patternId;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // If not imported, it might be local
+            const localId = `${fileId}::${symbolName}`;
+            if (this.symbolIndex.has(localId)) {
+                return localId;
+            }
+            
+            // Additional local patterns
+            const localPatterns = [
+                `${fileId}::use${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+                `${fileId}::get${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+                `${fileId}::create${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+                `${fileId}::_${symbolName}`, // underscore prefix
+                `${fileId}::${symbolName}Impl`, // implementation suffix
+                `${fileId}::${symbolName}Handler` // handler suffix
+            ];
+            
+            for (const patternId of localPatterns) {
+                if (this.symbolIndex.has(patternId)) return patternId;
+            }
+
+            return null;
+        };
+
+        // 1. Resolve Function Calls
+        if (functionCalls) {
+            for (const call of functionCalls) {
+                const targetSymbolId = resolveImportedSymbol(call.name);
+                if (targetSymbolId) {
+                    edges.push({
+                        sourceFileId: fileId,
+                        targetSymbolId: targetSymbolId,
+                        type: 'CALLS',
+                        line: call.loc ? call.loc.start.line : 0,
+                        confidence: 1.0
+                    });
+                }
+            }
+        }
+
+        // 2. Resolve Constructor Calls
+        if (constructorCalls) {
+            for (const call of constructorCalls) {
+                const targetSymbolId = resolveImportedSymbol(call.className);
+                if (targetSymbolId) {
+                    edges.push({
+                        sourceFileId: fileId,
+                        targetSymbolId: targetSymbolId,
+                        type: 'INSTANTIATES',
+                        line: call.loc ? call.loc.start.line : 0,
+                        confidence: 1.0
+                    });
+                }
+            }
+        }
+
+        // 3. Resolve Method Calls (Namespace & Object Property Resolution)
+        // e.g., import * as api from './api'; api.fetchData();
+        // OR import { actions } from './actions'; actions.login();
+        if (methodCalls) {
+            for (const call of methodCalls) {
+                const imp = imports.find(i => i.specifiers?.some(s => s.local === call.object));
+                if (imp && imp.resolvedPath) {
+                    const targetFileId = imp.resolvedPath;
+                    const spec = imp.specifiers.find(s => s.local === call.object);
+                    const importedAs = spec ? spec.imported : null;
+
+                    // Strategy A: Namespace Resolution
+                    let candidateId = `${targetFileId}::${call.method}`;
+                    if (this.symbolIndex.has(candidateId)) {
+                        edges.push({
+                            sourceFileId: fileId, targetSymbolId: candidateId,
+                            type: 'CALLS', line: call.loc ? call.loc.start.line : 0, confidence: 1.0
+                        });
+                        continue;
+                    }
+
+                    // Strategy B: Object Property Resolution
+                    if (importedAs) {
+                        const targetSymbolName = importedAs === 'default' ? 'default' : importedAs;
+                        candidateId = `${targetFileId}::${targetSymbolName}.${call.method}`;
+                        if (this.symbolIndex.has(candidateId)) {
+                            edges.push({
+                                sourceFileId: fileId, targetSymbolId: candidateId,
+                                type: 'CALLS', line: call.loc ? call.loc.start.line : 0, confidence: 1.0
+                            });
+                            continue;
+                        }
+                    }
+                }
+                const localObjectId = `${fileId}::${call.object}.${call.method}`;
+                if (this.symbolIndex.has(localObjectId)) {
+                    edges.push({
+                        sourceFileId: fileId, targetSymbolId: localObjectId,
+                        type: 'CALLS', line: call.loc ? call.loc.start.line : 0, confidence: 1.0
+                    });
+                }
+            }
+        }
+
+        return edges;
+    }
+}
+
+module.exports = { CallResolver };