arcvision 0.1.12 → 0.1.14

package/README.md

@@ -35,12 +35,15 @@ Scan the current directory and generate architecture map.
 Options:
 - `-u, --upload`: Upload to database
 
+The scan command will also output a blast radius analysis showing the file with the highest blast radius and its potential impact on your codebase.
+
 ## Features
 
 - **Modern Import Resolution**: Handles path aliases (`@/components/*`), barrel files (`./utils` → `./utils/index.ts`), and directory imports
 - **AST-based Parsing**: Uses Babel parser for accurate import detection
 - **Multi-framework Support**: Works with React, Next.js, and other modern JavaScript frameworks
 - **Dependency Graph Generation**: Creates comprehensive node-edge relationships
+- **Blast Radius Analysis**: Identifies high-risk files that are imported by many other files
 - **Cloud Integration**: Uploads results to ArcVision dashboard for visualization
 
 ## Supported Import Patterns

package/dist/index.js

@@ -56442,92 +56442,127 @@ var require_path_resolver = __commonJS({
   "src/core/path-resolver.js"(exports2, module2) {
     var fs2 = require("fs");
     var path2 = require("path");
-    function resolveImport(importPath, fromFile, projectRoot, tsconfig) {
-      if (importPath.startsWith("node_modules/") || importPath.includes("node_modules/") || importPath.startsWith("http") || importPath.startsWith("//")) {
+    function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
+      if (importPath.startsWith("http://") || importPath.startsWith("https://") || importPath.startsWith("data:")) {
         return null;
       }
-      if (tsconfig && tsconfig.paths && importPath in tsconfig.paths) {
-        const pathMappings = tsconfig.paths[importPath];
-        if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-          const mappedPath = pathMappings[0].replace("*", importPath.substring(0, importPath.lastIndexOf("/")));
-          const realPath = path2.resolve(projectRoot, tsconfig.baseUrl || ".", mappedPath);
-          return resolveFile(realPath);
+      if (importPath.startsWith(".")) {
+        let resolvedPath = path2.resolve(path2.dirname(importerPath), importPath);
+        const extensions = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+        for (const ext of extensions) {
+          if (fs2.existsSync(resolvedPath + ext)) {
+            return resolvedPath + ext;
+          }
+        }
+        const indexFiles = ["index.js", "index.jsx", "index.ts", "index.tsx"];
+        for (const idxFile of indexFiles) {
+          const indexPath = path2.join(resolvedPath, idxFile);
+          if (fs2.existsSync(indexPath)) {
+            return indexPath;
+          }
+        }
+        if (fs2.existsSync(resolvedPath)) {
+          return resolvedPath;
         }
+        return null;
       }
       if (tsconfig && tsconfig.paths) {
-        const pathKeys = Object.keys(tsconfig.paths);
-        for (const pathKey of pathKeys) {
-          if (pathKey.endsWith("*")) {
-            const prefix = pathKey.slice(0, -1);
-            if (importPath.startsWith(prefix)) {
-              const suffix = importPath.substring(prefix.length);
-              const pathMappings = tsconfig.paths[pathKey];
-              if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-                const mappedPath = pathMappings[0].replace("*", suffix);
-                const realPath = path2.resolve(projectRoot, tsconfig.baseUrl || ".", mappedPath);
-                const resolved = resolveFile(realPath);
-                if (resolved)
-                  return resolved;
+        const paths = tsconfig.paths;
+        for (const [aliasPattern, aliasTargets] of Object.entries(paths)) {
+          const aliasBase = aliasPattern.replace(/\/\*$/, "");
+          if (importPath.startsWith(aliasBase + "/")) {
+            const relativePart = importPath.substring(aliasBase.length);
+            for (const target of aliasTargets) {
+              const targetPath = target.replace(/\/\*$/, "") + relativePart;
+              let resolvedPath = path2.resolve(projectRoot, targetPath);
+              const extensions = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+              for (const ext of extensions) {
+                if (fs2.existsSync(resolvedPath + ext)) {
+                  return resolvedPath + ext;
+                }
+              }
+              const indexFiles = ["index.js", "index.jsx", "index.ts", "index.tsx"];
+              for (const idxFile of indexFiles) {
+                const indexPath = path2.join(resolvedPath, idxFile);
+                if (fs2.existsSync(indexPath)) {
+                  return indexPath;
+                }
               }
             }
           }
         }
       }
       if (tsconfig && tsconfig.baseUrl && !importPath.startsWith(".")) {
-        const baseUrlPath = path2.resolve(projectRoot, tsconfig.baseUrl, importPath);
-        const resolved = resolveFile(baseUrlPath);
-        if (resolved)
-          return resolved;
-      }
-      if (importPath.startsWith("@") && tsconfig && tsconfig.baseUrl) {
-        const relativePath = importPath.substring(1);
-        const realPath = path2.resolve(projectRoot, tsconfig.baseUrl, relativePath);
-        const resolved = resolveFile(realPath);
-        if (resolved)
-          return resolved;
-        const wildcardPath = importPath + "/*";
-        if (tsconfig.paths && tsconfig.paths[wildcardPath]) {
-          const pathMappings = tsconfig.paths[wildcardPath];
-          if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-            const mappedPath = pathMappings[0].replace("*", "");
-            const realPath2 = path2.resolve(projectRoot, tsconfig.baseUrl || ".", mappedPath);
-            return resolveFile(realPath2);
+        let resolvedPath = path2.resolve(projectRoot, tsconfig.baseUrl, importPath);
+        const extensions = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+        for (const ext of extensions) {
+          if (fs2.existsSync(resolvedPath + ext)) {
+            return resolvedPath + ext;
+          }
+        }
+        const indexFiles = ["index.js", "index.jsx", "index.ts", "index.tsx"];
+        for (const idxFile of indexFiles) {
+          const indexPath = path2.join(resolvedPath, idxFile);
+          if (fs2.existsSync(indexPath)) {
+            return indexPath;
           }
         }
-      }
-      if (importPath.startsWith(".")) {
-        const realPath = path2.resolve(path2.dirname(fromFile), importPath);
-        return resolveFile(realPath);
-      }
-      if (!importPath.startsWith(".")) {
-        const realPath = path2.resolve(projectRoot, importPath);
-        return resolveFile(realPath);
       }
       return null;
     }
-    function resolveFile(basePath) {
-      const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-      const barrelFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
-      if (fs2.existsSync(basePath) && fs2.statSync(basePath).isFile()) {
-        return basePath;
-      }
-      for (const ext of extensions) {
-        const pathWithExt = basePath + ext;
-        if (fs2.existsSync(pathWithExt) && fs2.statSync(pathWithExt).isFile()) {
-          return pathWithExt;
+    module2.exports = { resolveImport };
+  }
+});
+
+// src/core/blastRadius.js
+var require_blastRadius = __commonJS({
+  "src/core/blastRadius.js"(exports2, module2) {
+    function buildReverseDependencyGraph(architectureMap) {
+      const reverseGraph = {};
+      architectureMap.nodes.forEach((node) => {
+        const filePath = node.id;
+        if (!reverseGraph[filePath]) {
+          reverseGraph[filePath] = [];
         }
+      });
+      architectureMap.edges.forEach((edge) => {
+        const importingFile = edge.source;
+        const importedFile = edge.target;
+        if (!reverseGraph[importedFile]) {
+          reverseGraph[importedFile] = [];
+        }
+        if (!reverseGraph[importedFile].includes(importingFile)) {
+          reverseGraph[importedFile].push(importingFile);
+        }
+      });
+      return reverseGraph;
+    }
+    function computeBlastRadius(reverseGraph) {
+      const blastRadiusMap = {};
+      for (const [filePath, importingFiles] of Object.entries(reverseGraph)) {
+        blastRadiusMap[filePath] = importingFiles.length;
       }
-      if (fs2.existsSync(basePath) && fs2.statSync(basePath).isDirectory()) {
-        for (const barrelFile of barrelFiles) {
-          const barrelPath = path2.join(basePath, barrelFile);
-          if (fs2.existsSync(barrelPath)) {
-            return barrelPath;
-          }
+      return blastRadiusMap;
+    }
+    function findHighestBlastRadius2(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 null;
+      return maxFile;
     }
-    module2.exports = { resolveImport, resolveFile };
+    module2.exports = {
+      buildReverseDependencyGraph,
+      computeBlastRadius,
+      findHighestBlastRadius: findHighestBlastRadius2
+    };
   }
 });
 
@@ -56540,6 +56575,7 @@ var require_scanner = __commonJS({
     var pluginManager = require_plugin_manager();
     var { loadTSConfig } = require_tsconfig_utils();
     var { resolveImport } = require_path_resolver();
+    var { buildReverseDependencyGraph, computeBlastRadius } = require_blastRadius();
     async function scan(directory) {
       const normalize = (p) => p.replace(/\\/g, "/");
       const options = {
@@ -56597,6 +56633,11 @@ var require_scanner = __commonJS({
             }
           });
         });
+        const reverseGraph = buildReverseDependencyGraph(architectureMap);
+        const blastRadiusMap = computeBlastRadius(reverseGraph);
+        architectureMap.nodes.forEach((node) => {
+          node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
+        });
         return architectureMap;
       } catch (err) {
         throw err;
@@ -56623,6 +56664,20 @@ try {
 }
 var CONFIG_FILE = path.join(os.homedir(), ".arcvisionrc");
 var API_URL = process.env.ARCVISION_API_URL || "https://arcvisiondev.vercel.app";
+var { findHighestBlastRadius } = require_blastRadius();
+function analyzeBlastRadius(architectureMap) {
+  const blastRadiusData = [];
+  architectureMap.nodes.forEach((node) => {
+    blastRadiusData.push({
+      file: node.id,
+      blast_radius: node.metadata.blast_radius || 0
+    });
+  });
+  return findHighestBlastRadius(blastRadiusData.reduce((acc, item) => {
+    acc[item.file] = item.blast_radius;
+    return acc;
+  }, {}));
+}
 function saveToken(token) {
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify({ token }));
@@ -56749,6 +56804,13 @@ program.command("scan").description("Scan the current directory and generate arc
   try {
     const map = await scanner.scan(targetDir);
     console.log(chalk.green("Scan complete!"));
+    const blastRadiusInfo = analyzeBlastRadius(map);
+    if (blastRadiusInfo && blastRadiusInfo.blast_radius > 0) {
+      console.log(`
+\u26A0\uFE0F  ${blastRadiusInfo.file} has the highest blast radius (${blastRadiusInfo.blast_radius}). Changes here may affect many parts of the system.`);
+    } else {
+      console.log("\nNo high-risk files detected based on import dependencies.");
+    }
     if (options.upload) {
       await uploadToDatabase(map);
     } else {

package/docs/blast-radius-implementation.md

@@ -0,0 +1,76 @@
+# Blast Radius Implementation
+
+## Architecture
+
+### Files Added/Modified
+1. `src/core/blastRadius.js` - Core blast radius calculation logic
+2. `src/core/scanner.js` - Modified to include blast radius in output
+3. `src/index.js` - Modified to display blast radius insight
+
+### Core Functions
+
+#### `buildReverseDependencyGraph(architectureMap)`
+- Creates a reverse dependency map where keys are imported files and values are arrays of files that import them
+- Takes the architecture map (with nodes and edges) as input
+- Returns a map: `{ [importedFile]: [importingFile1, importingFile2, ...] }`
+
+#### `computeBlastRadius(reverseGraph)`
+- Calculates the blast radius for each file as the count of files that import it
+- Takes the reverse dependency graph as input
+- Returns a map: `{ [filePath]: blastRadiusNumber }`
+
+#### `findHighestBlastRadius(blastRadiusMap)`
+- Finds the file with the highest blast radius value
+- Takes the blast radius map as input
+- Returns an object: `{ file: filePath, blast_radius: radius }` or null
+
+## Data Flow
+
+1. **Scanning Phase**: The scanner builds the architecture map with nodes and edges as before
+2. **Blast Radius Calculation Phase**: After the architecture map is built:
+   - Reverse dependency graph is built from the edges
+   - Blast radius is computed for each file
+   - Blast radius values are added to each node's metadata
+3. **Output Phase**: The CLI prints the architecture map as JSON and then shows the blast radius insight
+
+## Data Structure Changes
+
+### Node Metadata
+Each node in the architecture map now includes:
+```javascript
+{
+  id: "relative/file/path.js",
+  type: "file",
+  metadata: {
+    imports: [...],
+    exports: [...],
+    functions: [...],
+    apiCalls: [...],
+    blast_radius: 5  // NEW FIELD
+  }
+}
+```
+
+### CLI Output
+The CLI now prints an additional message after the scan:
+```
+⚠️  src/core/utils.js has the highest blast radius (5). Changes here may affect many parts of the system.
+```
+
+## Algorithm Complexity
+- **Time Complexity**: O(V + E) where V is the number of files and E is the number of import relationships
+- **Space Complexity**: O(V + E) for storing the reverse dependency graph
+
+## Error Handling
+- Handles empty repositories gracefully
+- Handles files with no imports or no dependents
+- Maintains backward compatibility with existing functionality
+- Preserves all existing fields in the architecture map
+
+## Testing Considerations
+The implementation should be tested with:
+- Empty repositories
+- Repositories with no dependencies
+- Repositories with complex dependency chains
+- Repositories with circular dependencies
+- Large repositories with many files

package/docs/blast-radius.md

@@ -0,0 +1,44 @@
+# Blast Radius Feature
+
+## Overview
+The Blast Radius feature analyzes your codebase to identify files that are most critical to your application. It calculates how many other files depend on each file, helping you identify high-risk areas where changes could have wide-ranging impacts.
+
+## How It Works
+- **Blast Radius Score**: For each file, the blast radius is calculated as the number of files that import it (direct dependencies only).
+- **Reverse Dependency Graph**: The system builds a reverse dependency graph to track which files import each file.
+- **Risk Assessment**: Files with higher blast radius scores are considered higher risk because changes to them could affect many other parts of the system.
+
+## Output
+The blast radius score is added to each file's metadata in the architecture map:
+
+```json
+{
+  "nodes": [
+    {
+      "id": "src/auth/session.ts",
+      "type": "file",
+      "metadata": {
+        "imports": ["src/db/client.ts", "src/utils/logger.ts"],
+        "exports": [],
+        "functions": [],
+        "apiCalls": [],
+        "blast_radius": 2
+      }
+    }
+  ],
+  "edges": [...]
+}
+```
+
+## CLI Output
+After scanning, the CLI will display a warning for the file with the highest blast radius:
+
+```
+⚠️  src/auth/session.ts has the highest blast radius (2). Changes here may affect many parts of the system.
+```
+
+## Use Cases
+- Identify critical files that require extra care during refactoring
+- Understand the potential impact of code changes
+- Prioritize code review efforts for high-risk files
+- Analyze architectural dependencies in your codebase

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Architecture scanner for modern codebases",
   "bin": {
     "arcvision": "./dist/index.js"

package/src/core/blastRadius.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+
+/**
+ * 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
+    architectureMap.nodes.forEach(node => {
+        const filePath = node.id;
+        if (!reverseGraph[filePath]) {
+            reverseGraph[filePath] = [];
+        }
+    });
+    
+    // Build reverse dependencies from edges
+    architectureMap.edges.forEach(edge => {
+        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] = importingFiles.length;
+    }
+    
+    return blastRadiusMap;
+}
+
+/**
+ * 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;
+}
+
+module.exports = {
+    buildReverseDependencyGraph,
+    computeBlastRadius,
+    findHighestBlastRadius
+};

package/src/core/path-resolver.js

@@ -2,126 +2,109 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * Resolve an import path to an actual file on disk
- * @param {string} importPath - The import string from the code (e.g., '@/components/Button', './utils')
- * @param {string} fromFile - The file that contains the import
+ * Resolve an import path to its actual file location
+ * Handles relative paths, path aliases, barrel files, and implicit extensions
+ * @param {string} importPath - The import path from the source code
+ * @param {string} importerPath - The path of the file doing the import
  * @param {string} projectRoot - The root directory of the project
- * @param {Object|null} tsconfig - The compilerOptions from tsconfig.json
+ * @param {Object|null} tsconfig - Loaded tsconfig with compilerOptions
  * @returns {string|null} The resolved absolute file path or null if not found
  */
-function resolveImport(importPath, fromFile, projectRoot, tsconfig) {
-  // Skip external packages and node_modules
-  if (importPath.startsWith('node_modules/') || 
-      importPath.includes('node_modules/') ||
-      importPath.startsWith('http') ||
-      importPath.startsWith('//')) {
+function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
+  // If it's an absolute path or URL, skip resolution
+  if (importPath.startsWith('http://') || importPath.startsWith('https://') || importPath.startsWith('data:')) {
     return null;
   }
 
-  // Handle path aliases (e.g., '@/components/Button', '@/lib/utils')
-  if (tsconfig && tsconfig.paths && importPath in tsconfig.paths) {
-    // Direct path mapping
-    const pathMappings = tsconfig.paths[importPath];
-    if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-      const mappedPath = pathMappings[0].replace('*', importPath.substring(0, importPath.lastIndexOf('/')));
-      const realPath = path.resolve(projectRoot, tsconfig.baseUrl || '.', mappedPath);
-      return resolveFile(realPath);
+  // Handle relative imports
+  if (importPath.startsWith('.')) {
+    // Resolve relative to importer
+    let resolvedPath = path.resolve(path.dirname(importerPath), importPath);
+    
+    // Try with various extensions
+    const extensions = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'];
+    for (const ext of extensions) {
+      if (fs.existsSync(resolvedPath + ext)) {
+        return resolvedPath + ext;
+      }
     }
+    
+    // Try as directory with index files
+    const indexFiles = ['index.js', 'index.jsx', 'index.ts', 'index.tsx'];
+    for (const idxFile of indexFiles) {
+      const indexPath = path.join(resolvedPath, idxFile);
+      if (fs.existsSync(indexPath)) {
+        return indexPath;
+      }
+    }
+    
+    // If original path exists as-is
+    if (fs.existsSync(resolvedPath)) {
+      return resolvedPath;
+    }
+    
+    return null;
   }
 
-  // Handle wildcard path aliases (e.g., '@/components/*' -> './src/components/*')
+  // Handle path aliases (like @/components/, ~/utils/, etc.)
   if (tsconfig && tsconfig.paths) {
-    const pathKeys = Object.keys(tsconfig.paths);
-    for (const pathKey of pathKeys) {
-      if (pathKey.endsWith('*')) {
-        const prefix = pathKey.slice(0, -1); // Remove the '*'
-        if (importPath.startsWith(prefix)) {
-          const suffix = importPath.substring(prefix.length);
-          const pathMappings = tsconfig.paths[pathKey];
-          if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-            const mappedPath = pathMappings[0].replace('*', suffix);
-            const realPath = path.resolve(projectRoot, tsconfig.baseUrl || '.', mappedPath);
-            const resolved = resolveFile(realPath);
-            if (resolved) return resolved;
+    const paths = tsconfig.paths;
+    
+    // Find matching path alias
+    for (const [aliasPattern, aliasTargets] of Object.entries(paths)) {
+      // Remove trailing * from pattern
+      const aliasBase = aliasPattern.replace(/\/\*$/, '');
+      
+      // If import starts with this alias
+      if (importPath.startsWith(aliasBase + '/')) {
+        // Get the part after the alias
+        const relativePart = importPath.substring(aliasBase.length);
+        
+        // Use the first target path
+        for (const target of aliasTargets) {
+          // Replace * in target with relative part
+          const targetPath = target.replace(/\/\*$/, '') + relativePart;
+          let resolvedPath = path.resolve(projectRoot, targetPath);
+          
+          // Try with extensions
+          const extensions = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'];
+          for (const ext of extensions) {
+            if (fs.existsSync(resolvedPath + ext)) {
+              return resolvedPath + ext;
+            }
+          }
+          
+          // Try as directory with index files
+          const indexFiles = ['index.js', 'index.jsx', 'index.ts', 'index.tsx'];
+          for (const idxFile of indexFiles) {
+            const indexPath = path.join(resolvedPath, idxFile);
+            if (fs.existsSync(indexPath)) {
+              return indexPath;
+            }
           }
         }
       }
     }
   }
 
-  // Handle baseUrl resolution (e.g., 'components/Button' -> './src/components/Button')
+  // Handle baseUrl if configured
   if (tsconfig && tsconfig.baseUrl && !importPath.startsWith('.')) {
-    const baseUrlPath = path.resolve(projectRoot, tsconfig.baseUrl, importPath);
-    const resolved = resolveFile(baseUrlPath);
-    if (resolved) return resolved;
-  }
-
-  // Handle @ imports that don't match specific paths mappings
-  if (importPath.startsWith('@') && tsconfig && tsconfig.baseUrl) {
-    // Remove @ and resolve relative to baseUrl
-    const relativePath = importPath.substring(1); // Remove @
-    const realPath = path.resolve(projectRoot, tsconfig.baseUrl, relativePath);
-    const resolved = resolveFile(realPath);
-    if (resolved) return resolved;
+    let resolvedPath = path.resolve(projectRoot, tsconfig.baseUrl, importPath);
     
-    // Also try adding '/*' to see if it matches a path mapping pattern
-    // e.g., '@/utils' might match '@/utils/*' -> './src/utils/*'
-    const wildcardPath = importPath + '/*';
-    if (tsconfig.paths && tsconfig.paths[wildcardPath]) {
-      const pathMappings = tsconfig.paths[wildcardPath];
-      if (Array.isArray(pathMappings) && pathMappings.length > 0) {
-        const mappedPath = pathMappings[0].replace('*', '');
-        const realPath = path.resolve(projectRoot, tsconfig.baseUrl || '.', mappedPath);
-        return resolveFile(realPath);
+    // Try with extensions
+    const extensions = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'];
+    for (const ext of extensions) {
+      if (fs.existsSync(resolvedPath + ext)) {
+        return resolvedPath + ext;
       }
     }
-  }
-
-  // Handle relative paths (e.g., './utils', '../components')
-  if (importPath.startsWith('.')) {
-    const realPath = path.resolve(path.dirname(fromFile), importPath);
-    return resolveFile(realPath);
-  }
-
-  // For absolute paths within the project that don't match tsconfig paths
-  if (!importPath.startsWith('.')) {
-    // Try resolving relative to project root
-    const realPath = path.resolve(projectRoot, importPath);
-    return resolveFile(realPath);
-  }
-
-  return null;
-}
-
-/**
- * Resolve a potential file path to an actual existing file
- * Handles implicit extensions and barrel files (index files)
- * @param {string} basePath - The base path to resolve
- * @returns {string|null} The resolved file path or null if no file exists
- */
-function resolveFile(basePath) {
-  const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-  const barrelFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
-
-  // First, try the exact path
-  if (fs.existsSync(basePath) && fs.statSync(basePath).isFile()) {
-    return basePath;
-  }
-
-  // Try with extensions
-  for (const ext of extensions) {
-    const pathWithExt = basePath + ext;
-    if (fs.existsSync(pathWithExt) && fs.statSync(pathWithExt).isFile()) {
-      return pathWithExt;
-    }
-  }
-
-  // Try as a directory with barrel files
-  if (fs.existsSync(basePath) && fs.statSync(basePath).isDirectory()) {
-    for (const barrelFile of barrelFiles) {
-      const barrelPath = path.join(basePath, barrelFile);
-      if (fs.existsSync(barrelPath)) {
-        return barrelPath;
+    
+    // Try as directory with index files
+    const indexFiles = ['index.js', 'index.jsx', 'index.ts', 'index.tsx'];
+    for (const idxFile of indexFiles) {
+      const indexPath = path.join(resolvedPath, idxFile);
+      if (fs.existsSync(indexPath)) {
+        return indexPath;
       }
     }
   }
@@ -129,4 +112,4 @@ function resolveFile(basePath) {
   return null;
 }
 
-module.exports = { resolveImport, resolveFile };
+module.exports = { resolveImport };

package/src/core/scanner.js

@@ -4,6 +4,7 @@ const parser = require('./parser');
 const pluginManager = require('../plugins/plugin-manager');
 const { loadTSConfig } = require('./tsconfig-utils');
 const { resolveImport } = require('./path-resolver');
+const { buildReverseDependencyGraph, computeBlastRadius } = require('./blastRadius');
 
 async function scan(directory) {
     // Normalize helper
@@ -87,6 +88,15 @@ async function scan(directory) {
             });
         });
 
+        // 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;
+        });
+        
         return architectureMap;
 
     } catch (err) {

package/src/index.js

@@ -24,6 +24,27 @@ try {
 const CONFIG_FILE = path.join(os.homedir(), '.arcvisionrc');
 const API_URL = process.env.ARCVISION_API_URL || 'https://arcvisiondev.vercel.app';
 
+// Blast radius analysis
+const { findHighestBlastRadius } = require('./core/blastRadius');
+
+function analyzeBlastRadius(architectureMap) {
+  // Extract blast radius information from nodes
+  const blastRadiusData = [];
+  
+  architectureMap.nodes.forEach(node => {
+    blastRadiusData.push({
+      file: node.id,
+      blast_radius: node.metadata.blast_radius || 0
+    });
+  });
+  
+  // Find the file with the highest blast radius
+  return findHighestBlastRadius(blastRadiusData.reduce((acc, item) => {
+    acc[item.file] = item.blast_radius;
+    return acc;
+  }, {}));
+}
+
 function saveToken(token) {
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify({ token }));
@@ -181,6 +202,14 @@ program
       const map = await scanner.scan(targetDir);
       console.log(chalk.green('Scan complete!'));
 
+      // Analyze and print blast radius insight
+      const blastRadiusInfo = analyzeBlastRadius(map);
+      if (blastRadiusInfo && blastRadiusInfo.blast_radius > 0) {
+        console.log(`\n⚠️  ${blastRadiusInfo.file} has the highest blast radius (${blastRadiusInfo.blast_radius}). Changes here may affect many parts of the system.`);
+      } else {
+        console.log('\nNo high-risk files detected based on import dependencies.');
+      }
+            
       // Upload to database if requested
       if (options.upload) {
         await uploadToDatabase(map);