arcvision 0.1.13 → 0.1.15

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

@@ -56514,6 +56514,58 @@ var require_path_resolver = __commonJS({
   }
 });
 
+// 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;
+      }
+      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 maxFile;
+    }
+    module2.exports = {
+      buildReverseDependencyGraph,
+      computeBlastRadius,
+      findHighestBlastRadius: findHighestBlastRadius2
+    };
+  }
+});
+
 // src/core/scanner.js
 var require_scanner = __commonJS({
   "src/core/scanner.js"(exports2, module2) {
@@ -56523,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 = {
@@ -56580,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;
@@ -56606,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 }));
@@ -56643,7 +56715,7 @@ async function uploadToDatabase(jsonData) {
   try {
     console.log(chalk.blue(`Uploading to ${API_URL}/api/upload...`));
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    const timeoutId = setTimeout(() => controller.abort(), 6e4);
     const response = await fetch(`${API_URL}/api/upload`, {
       method: "POST",
       headers: {
@@ -56732,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.13",
+  "version": "0.1.15",
   "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/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 }));
@@ -67,7 +88,7 @@ async function uploadToDatabase(jsonData) {
     
     // Add timeout to fetch request
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+    const timeoutId = setTimeout(() => controller.abort(), 60000); // 60 second timeout
     
     const response = await fetch(`${API_URL}/api/upload`, {
       method: 'POST',
@@ -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);