arcvision 0.2.2 → 0.2.3

package/src/core/scanner.js

@@ -1,7 +1,7 @@
 const { glob } = require('glob');
 const path = require('path');
 const fs = require('fs');
-const parser = require('./parser');
+const parser = require('./parser-enhanced'); // Use enhanced parser
 const pluginManager = require('../plugins/plugin-manager');
 const { loadTSConfig } = require('./tsconfig-utils');
 const { resolveImport } = require('./path-resolver');
@@ -12,10 +12,13 @@ const { buildContext } = require('../engine/context_builder');
 const { validateContext } = require('../engine/context_validator');
 const { sortContext } = require('../engine/context_sorter');
 
+// Import semantic analyzer for cross-file analysis
+const { analyzeSemantics } = require('./semantic-analyzer');
+
 async function scan(directory) {
     // Normalize helper
     const normalize = p => p.replace(/\\/g, '/');
-    
+
     const options = {
         ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
         cwd: directory,
@@ -42,10 +45,10 @@ async function scan(directory) {
             try {
                 const relativePath = path.relative(directory, file);
                 const normalizedRelativePath = normalize(relativePath);
-                
+
                 // Handle different file types appropriately
                 let metadata;
-                
+
                 if (file.endsWith('.json')) {
                     // Handle JSON files separately
                     try {
@@ -71,7 +74,7 @@ async function scan(directory) {
 
                 // Process with plugins
                 metadata = await pluginManager.processFile(file, metadata);
-                
+
                 // Count imports found in this file
                 if (metadata.imports && Array.isArray(metadata.imports)) {
                     totalImportsFound += metadata.imports.length;
@@ -90,21 +93,26 @@ async function scan(directory) {
                 console.warn(`⚠️ Failed to process ${file} — file skipped, you should check manually (${e.message})`);
             }
         }
-        
+
+        // NEW: Perform semantic analysis to build cross-file usage edges
+        console.log('Performing semantic analysis...');
+        const semanticResults = analyzeSemantics(architectureMap.nodes);
+        console.log(`Semantic analysis complete: ${semanticResults.stats.totalSymbols} symbols, ${semanticResults.stats.totalUsages} usage edges`);
+
         // Load tsconfig for path resolution
         const tsconfig = loadTSConfig(directory);
-        
+
         // Create a mapping of all possible normalized paths that could match imports
         // This includes both the direct file paths and possible variations
         const allPossiblePaths = new Set();
         const pathToNodeIdMap = new Map(); // This maps normalized paths to node IDs
-        
+
         architectureMap.nodes.forEach(node => {
             const normalizedPath = normalize(node.id);
             allPossiblePaths.add(normalizedPath);
             pathToNodeIdMap.set(normalizedPath, node.id);
         });
-        
+
         // Process imports to create edges
         let unresolvedImports = 0;
         let resolvedImports = 0;
@@ -113,7 +121,7 @@ async function scan(directory) {
                 node.metadata.imports.forEach(imp => {
                     if (imp.source && typeof imp.source === 'string') {
                         let targetFound = false;
-                        
+
                         try {
                             // First, check if imp.source directly matches any node path (exact match)
                             if (allPossiblePaths.has(imp.source)) {
@@ -125,7 +133,7 @@ async function scan(directory) {
                                 resolvedImports++;
                                 targetFound = true;
                             }
-                            
+
                             if (!targetFound) {
                                 // Try to resolve the import path using the resolver
                                 const resolvedPath = resolveImport(
@@ -134,12 +142,12 @@ async function scan(directory) {
                                     directory,
                                     tsconfig
                                 );
-                                
+
                                 if (resolvedPath) {
                                     // Convert resolved absolute path back to relative path
                                     const relativeResolvedPath = path.relative(directory, resolvedPath);
                                     const normalizedResolvedPath = normalize(relativeResolvedPath);
-                                    
+
                                     // Check if the resolved file exists in our scanned files
                                     if (allPossiblePaths.has(normalizedResolvedPath)) {
                                         architectureMap.edges.push({
@@ -152,7 +160,7 @@ async function scan(directory) {
                                     }
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // As a fallback, check if the import path could match by simple relative path calculation
                                 // For example, if node is 'src/core/scanner.js' and import is './parser.js',
@@ -162,7 +170,7 @@ async function scan(directory) {
                                     const calculatedAbsolutePath = path.resolve(baseDir, imp.source);
                                     const calculatedRelativePath = path.relative(directory, calculatedAbsolutePath);
                                     const calculatedNormalizedPath = normalize(calculatedRelativePath);
-                                    
+
                                     if (allPossiblePaths.has(calculatedNormalizedPath)) {
                                         architectureMap.edges.push({
                                             source: normalize(node.id),
@@ -177,27 +185,27 @@ async function scan(directory) {
                                     // If path calculation fails, continue to unresolved
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // Another fallback: if import starts with ./ or ../, try to find a match
                                 // by appending common extensions to the import path
                                 if (imp.source.startsWith('./') || imp.source.startsWith('../')) {
                                     // Try various extensions that might match
                                     const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
-                                    
+
                                     for (const ext of extensions) {
                                         let testPath = imp.source;
                                         if (!imp.source.endsWith(ext)) {
                                             testPath = imp.source + ext;
                                         }
-                                        
+
                                         // Calculate the relative path from the project directory
                                         try {
                                             const baseDir = path.dirname(path.join(directory, node.id));
                                             const calculatedAbsolutePath = path.resolve(baseDir, testPath);
                                             const calculatedRelativePath = path.relative(directory, calculatedAbsolutePath);
                                             const calculatedNormalizedPath = normalize(calculatedRelativePath);
-                                            
+
                                             if (allPossiblePaths.has(calculatedNormalizedPath)) {
                                                 architectureMap.edges.push({
                                                     source: normalize(node.id),
@@ -215,7 +223,7 @@ async function scan(directory) {
                                     }
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // Additional fallback: Check for index files when importing a directory
                                 if (imp.source.startsWith('./') || imp.source.startsWith('../')) {
@@ -223,14 +231,14 @@ async function scan(directory) {
                                         const baseDir = path.dirname(path.join(directory, node.id));
                                         const calculatedAbsolutePath = path.resolve(baseDir, imp.source);
                                         const directoryPath = calculatedAbsolutePath;
-                                        
+
                                         // Check for index files in the directory
                                         const indexFiles = ['index.js', 'index.ts', 'index.jsx', 'index.tsx', 'index.mjs', 'index.cjs'];
                                         for (const indexFile of indexFiles) {
                                             const indexPath = path.join(directoryPath, indexFile);
                                             const indexRelativePath = path.relative(directory, indexPath);
                                             const indexNormalizedPath = normalize(indexRelativePath);
-                                            
+
                                             if (allPossiblePaths.has(indexNormalizedPath)) {
                                                 architectureMap.edges.push({
                                                     source: normalize(node.id),
@@ -248,7 +256,7 @@ async function scan(directory) {
                                     }
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // Additional fallback: Check for absolute imports that might map to common directories
                                 // For example, if tsconfig has paths like "@/*": ["src/*"], an import like "@/utils/helper" 
@@ -256,13 +264,13 @@ async function scan(directory) {
                                 if (imp.source.startsWith('@') || imp.source.startsWith('/') || !imp.source.startsWith('.')) {
                                     // Try to match against common source directories
                                     const commonSourceDirs = ['src', 'app', 'lib', 'components', 'utils', 'services', 'assets'];
-                                    
+
                                     for (const srcDir of commonSourceDirs) {
                                         // Try appending to common source directories
                                         const potentialPath = path.join(srcDir, imp.source);
                                         const potentialRelativePath = path.relative(directory, path.resolve(directory, potentialPath));
                                         const potentialNormalizedPath = normalize(potentialRelativePath);
-                                        
+
                                         if (allPossiblePaths.has(potentialNormalizedPath)) {
                                             architectureMap.edges.push({
                                                 source: normalize(node.id),
@@ -273,11 +281,11 @@ async function scan(directory) {
                                             targetFound = true;
                                             break; // Found a match, exit the loop
                                         }
-                                        
+
                                         // Also try with extensions
                                         const extensions = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs',
-                                                           'index.js', 'index.ts', 'index.jsx', 'index.tsx', 'index.mjs', 'index.cjs'];
-                                        
+                                            'index.js', 'index.ts', 'index.jsx', 'index.tsx', 'index.mjs', 'index.cjs'];
+
                                         for (const ext of extensions) {
                                             let testPath;
                                             if (ext.startsWith('index')) {
@@ -285,10 +293,10 @@ async function scan(directory) {
                                             } else {
                                                 testPath = path.join(srcDir, imp.source + ext);
                                             }
-                                            
+
                                             const testRelativePath = path.relative(directory, path.resolve(directory, testPath));
                                             const testNormalizedPath = normalize(testRelativePath);
-                                            
+
                                             if (allPossiblePaths.has(testNormalizedPath)) {
                                                 architectureMap.edges.push({
                                                     source: normalize(node.id),
@@ -300,12 +308,12 @@ async function scan(directory) {
                                                 break; // Found a match, exit the loops
                                             }
                                         }
-                                        
+
                                         if (targetFound) break;
                                     }
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // Additional fallback: Try to handle barrel files (index.js that exports from other files)
                                 // If import is '@/components/Header' but only '@/components/index.js' exists
@@ -317,17 +325,17 @@ async function scan(directory) {
                                             // Remove the last part and add index
                                             const dirParts = parts.slice(0, -1);
                                             const fileName = parts[parts.length - 1];
-                                            
+
                                             // Look for patterns like: components/index.js exporting { Header }
                                             // or components/index.js containing export * from './Header'
                                             const dirPath = dirParts.join('/') + '/index';
                                             const indexFiles = ['index.js', 'index.ts', 'index.jsx', 'index.tsx', 'index.mjs', 'index.cjs'];
-                                            
+
                                             for (const indexFile of indexFiles) {
                                                 const indexPath = path.join(dirParts.join('/'), indexFile);
                                                 const indexRelativePath = path.relative(directory, path.resolve(directory, indexPath));
                                                 const indexNormalizedPath = normalize(indexRelativePath);
-                                                
+
                                                 if (allPossiblePaths.has(indexNormalizedPath)) {
                                                     architectureMap.edges.push({
                                                         source: normalize(node.id),
@@ -346,7 +354,7 @@ async function scan(directory) {
                                     }
                                 }
                             }
-                            
+
                             if (!targetFound) {
                                 // Additional fallback: Check for exact path matches with different capitalization
                                 // This handles cases where import uses different casing than actual file
@@ -369,7 +377,7 @@ async function scan(directory) {
                             // Even if there's an error processing this import, increment unresolved counter
                             unresolvedImports++;
                         }
-                        
+
                         if (!targetFound) {
                             // Track imports that couldn't be matched to existing nodes
                             unresolvedImports++;
@@ -380,35 +388,53 @@ async function scan(directory) {
         });
         console.log('RESOLVED IMPORTS:', resolvedImports);
         console.log('UNRESOLVED IMPORTS:', unresolvedImports);
-        console.log('EDGES CREATED:', architectureMap.edges.length);
+        console.log('IMPORT EDGES CREATED:', architectureMap.edges.length);
+
+        // NEW: Add semantic usage edges
+        if (semanticResults && semanticResults.usageEdges) {
+            semanticResults.usageEdges.forEach(usageEdge => {
+                // Only add if both source and target exist in our nodes
+                const sourceExists = architectureMap.nodes.some(n => n.id === usageEdge.source);
+                const targetExists = architectureMap.nodes.some(n => n.id === usageEdge.target);
+
+                if (sourceExists && targetExists) {
+                    architectureMap.edges.push({
+                        source: normalize(usageEdge.source),
+                        target: normalize(usageEdge.target),
+                        type: usageEdge.type // 'function_call', 'constructor_call', 'component_usage'
+                    });
+                }
+            });
+        }
+        console.log('TOTAL EDGES (with usage):', architectureMap.edges.length);
 
         // Calculate blast radius for each file
         const reverseGraph = buildReverseDependencyGraph(architectureMap);
         const blastRadiusMap = computeBlastRadius(reverseGraph);
-        
+
         // Add blast_radius to each node
         architectureMap.nodes.forEach(node => {
             node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
         });
-        
+
         console.log('BEFORE DEDUPLICATION EDGES:', architectureMap.edges.length);
-        
+
         // Process edges to ensure they match existing nodes and remove duplicates
         const validEdges = [];
         const edgeSet = new Set(); // To track unique edges
-        
+
         architectureMap.edges.forEach(edge => {
             // Normalize both source and target paths for consistent matching
             const normalizedSource = normalize(edge.source);
             const normalizedTarget = normalize(edge.target);
-            
+
             // Create a unique key for the edge to avoid duplicates
             const edgeKey = `${normalizedSource}→${normalizedTarget}`;
-            
+
             // Check if both source and target nodes exist in our architecture map
             const sourceNodeExists = architectureMap.nodes.some(node => node.id === normalizedSource);
             const targetNodeExists = architectureMap.nodes.some(node => node.id === normalizedTarget);
-            
+
             if (sourceNodeExists && targetNodeExists && !edgeSet.has(edgeKey)) {
                 edgeSet.add(edgeKey);
                 validEdges.push({
@@ -418,28 +444,28 @@ async function scan(directory) {
                 });
             }
         });
-        
+
         console.log('AFTER DEDUPLICATION EDGES:', validEdges.length);
-        
+
         // Replace the edges with only valid ones
         architectureMap.edges = validEdges;
-        
+
         // Add top blast radius files to the architecture map
         const totalFiles = architectureMap.nodes.length;
         const { computeBlastRadiusWithPercentage, analyzeCriticality } = require('./blastRadius');
         const allFilesWithPercentage = computeBlastRadiusWithPercentage(blastRadiusMap, totalFiles);
-        
+
         // Analyze criticality of files
         const criticalityAnalysis = analyzeCriticality(blastRadiusMap, reverseGraph, architectureMap.nodes);
-        
+
         // Sort by blast radius descending and take top 3
         const topFiles = allFilesWithPercentage.slice(0, 3);
-        
+
         architectureMap.contextSurface = {
             topBlastRadiusFiles: topFiles,
             criticalityAnalysis: criticalityAnalysis.slice(0, 5) // Top 5 most critical files
         };
-        
+
         // Build the new context object that conforms to the schema
         let context = buildContext(architectureMap.nodes, architectureMap.edges, {
             directory: directory,
@@ -447,9 +473,9 @@ async function scan(directory) {
             language: 'javascript',
             contextSurface: architectureMap.contextSurface
         });
-        
+
         console.log('Validating structural context...');
-        
+
         // Validate the context against the schema
         let validation = validateContext(context);
 
@@ -458,7 +484,7 @@ async function scan(directory) {
             validation.errors.forEach(e => console.error(' -', e));
 
             console.log('Re-running generation deterministically...');
-            
+
             // Rebuild context deterministically
             context = buildContext(architectureMap.nodes, architectureMap.edges, {
                 directory: directory,
@@ -476,12 +502,12 @@ async function scan(directory) {
                 process.exit(1);
             }
         }
-        
+
         // Sort the context deterministically
         const sortedContext = sortContext(context);
-        
+
         console.log('STRUCTURAL CONTEXT VALIDATED — READY FOR UPLOAD');
-        
+
         return sortedContext;
 
     } catch (err) {

package/src/core/semantic-analyzer.js

@@ -0,0 +1,204 @@
+/**
+ * Semantic Analyzer
+ * 
+ * Builds cross-file symbol resolution and tracks actual usage of imported symbols.
+ * This enables detection of which files actually USE imported functions/classes,
+ * not just which files import them.
+ */
+
+/**
+ * Build a global symbol table from all file exports
+ * @param {Array} nodes - All scanned file nodes with metadata
+ * @returns {Map} Symbol table mapping symbol names to their source files
+ */
+function buildSymbolTable(nodes) {
+    const symbolTable = new Map();
+    
+    nodes.forEach(node => {
+        const filePath = node.id;
+        const metadata = node.metadata;
+        
+        if (!metadata) return;
+        
+        // Register all exports from this file
+        if (metadata.exports && Array.isArray(metadata.exports)) {
+            metadata.exports.forEach(exp => {
+                const symbolName = exp.name;
+                if (!symbolTable.has(symbolName)) {
+                    symbolTable.set(symbolName, []);
+                }
+                symbolTable.get(symbolName).push({
+                    file: filePath,
+                    type: exp.type,
+                    loc: exp.loc
+                });
+            });
+        }
+        
+        // Register all functions
+        if (metadata.functions && Array.isArray(metadata.functions)) {
+            metadata.functions.forEach(func => {
+                const symbolName = func.name;
+                if (!symbolTable.has(symbolName)) {
+                    symbolTable.set(symbolName, []);
+                }
+                symbolTable.get(symbolName).push({
+                    file: filePath,
+                    type: 'function',
+                    loc: func.loc
+                });
+            });
+        }
+        
+        // Register all classes
+        if (metadata.classes && Array.isArray(metadata.classes)) {
+            metadata.classes.forEach(cls => {
+                const symbolName = cls.name;
+                if (!symbolTable.has(symbolName)) {
+                    symbolTable.set(symbolName, []);
+                }
+                symbolTable.get(symbolName).push({
+                    file: filePath,
+                    type: 'class',
+                    loc: cls.loc
+                });
+            });
+        }
+    });
+    
+    return symbolTable;
+}
+
+/**
+ * Resolve symbol usage to their definitions
+ * @param {Object} node - File node with metadata
+ * @param {Map} symbolTable - Global symbol table
+ * @returns {Array} Array of resolved symbol usages
+ */
+function resolveSymbolUsage(node, symbolTable) {
+    const resolvedUsages = [];
+    const metadata = node.metadata;
+    
+    if (!metadata) return resolvedUsages;
+    
+    // Track which symbols this file imports
+    const importedSymbols = new Map();
+    if (metadata.imports && Array.isArray(metadata.imports)) {
+        metadata.imports.forEach(imp => {
+            if (imp.specifiers && Array.isArray(imp.specifiers)) {
+                imp.specifiers.forEach(spec => {
+                    const localName = spec.local || spec.imported || spec;
+                    const importedName = spec.imported || spec.local || spec;
+                    importedSymbols.set(localName, {
+                        source: imp.source,
+                        originalName: importedName
+                    });
+                });
+            }
+        });
+    }
+    
+    // Check function calls against imported symbols
+    if (metadata.functionCalls && Array.isArray(metadata.functionCalls)) {
+        metadata.functionCalls.forEach(call => {
+            const callName = call.name;
+            if (importedSymbols.has(callName)) {
+                const importInfo = importedSymbols.get(callName);
+                resolvedUsages.push({
+                    type: 'function_call',
+                    symbol: callName,
+                    source: importInfo.source,
+                    loc: call.loc
+                });
+            }
+        });
+    }
+    
+    // Check constructor calls against imported symbols
+    if (metadata.constructorCalls && Array.isArray(metadata.constructorCalls)) {
+        metadata.constructorCalls.forEach(call => {
+            const className = call.className;
+            if (importedSymbols.has(className)) {
+                const importInfo = importedSymbols.get(className);
+                resolvedUsages.push({
+                    type: 'constructor_call',
+                    symbol: className,
+                    source: importInfo.source,
+                    loc: call.loc
+                });
+            }
+        });
+    }
+    
+    // Check component usage (React/JSX)
+    if (metadata.componentUsage && Array.isArray(metadata.componentUsage)) {
+        metadata.componentUsage.forEach(comp => {
+            const componentName = comp.component;
+            if (importedSymbols.has(componentName)) {
+                const importInfo = importedSymbols.get(componentName);
+                resolvedUsages.push({
+                    type: 'component_usage',
+                    symbol: componentName,
+                    source: importInfo.source,
+                    loc: comp.loc
+                });
+            }
+        });
+    }
+    
+    return resolvedUsages;
+}
+
+/**
+ * Track cross-file references and build usage edges
+ * @param {Array} nodes - All scanned file nodes
+ * @param {Map} symbolTable - Global symbol table
+ * @returns {Array} Array of usage edges
+ */
+function trackCrossFileReferences(nodes, symbolTable) {
+    const usageEdges = [];
+    
+    nodes.forEach(node => {
+        const filePath = node.id;
+        const resolvedUsages = resolveSymbolUsage(node, symbolTable);
+        
+        resolvedUsages.forEach(usage => {
+            // Create an edge from this file to the source of the symbol
+            usageEdges.push({
+                source: filePath,
+                target: usage.source,
+                type: usage.type,
+                symbol: usage.symbol,
+                loc: usage.loc
+            });
+        });
+    });
+    
+    return usageEdges;
+}
+
+/**
+ * Analyze semantic relationships in the codebase
+ * @param {Array} nodes - All scanned file nodes
+ * @returns {Object} Semantic analysis results
+ */
+function analyzeSemantics(nodes) {
+    const symbolTable = buildSymbolTable(nodes);
+    const usageEdges = trackCrossFileReferences(nodes, symbolTable);
+    
+    return {
+        symbolTable,
+        usageEdges,
+        stats: {
+            totalSymbols: symbolTable.size,
+            totalUsages: usageEdges.length
+        }
+    };
+}
+
+module.exports = {
+    buildSymbolTable,
+    resolveSymbolUsage,
+    trackCrossFileReferences,
+    analyzeSemantics
+};