arcvision 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # ArcVision CLI
 
-Architecture scanner for modern codebases. ArcVision analyzes your codebase and creates visual representations of file relationships and dependencies.
+Architecture scanner for modern codebases that generates dependency graphs and visualizes your project structure.
 
 ## Installation
 
@@ -10,82 +10,56 @@ npm install -g arcvision
 
 ## Usage
 
-### Link to a Project
+### Quick Start
+1. Sign up at the ArcVision dashboard
+2. Create a project and name it
+3. Generate a CLI token
+4. Run: `arcvision link <token>`
+5. Run: `arcvision scan --upload`
+6. Open dashboard to see results
 
+### Commands
+
+#### Link to Project
 ```bash
-arcvision link <upload-token>
+arcvision link <token>
 ```
+Link this CLI to a project via upload token.
 
-### Scan a Directory
-
+#### Scan Project
 ```bash
-# Scan current directory
-arcvision scan
-
-# Scan specific directory
-arcvision scan path/to/directory
-
-# Scan and upload to dashboard
-arcvision scan --upload
+arcvision scan [directory] [options]
 ```
+Scan the current directory and generate architecture map.
 
-## Commands
-
-- `arcvision link <token>` - Link the CLI to a project using an upload token
-- `arcvision scan [directory]` - Scan a directory and generate architecture map
-  - `-u, --upload` - Upload the scan results to the dashboard
+Options:
+- `-u, --upload`: Upload to database
 
 ## Features
 
-- Scans JavaScript, TypeScript, JSX, and TSX files
-- Detects import/export relationships
-- Supports plugin system for enhanced analysis (React components, Express routes, etc.)
-- Uploads results to ArcVision dashboard
-- Cross-platform support
-
-## Plugin System
-
-The CLI includes a plugin system that enhances code analysis:
-
-- **React Plugin**: Detects React components and hooks
-- **Express Plugin**: Identifies Express routes and endpoints
-- **Custom Plugins**: Extend functionality with your own plugins
-
-## Development
-
-To build the CLI from source:
+- **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
+- **Cloud Integration**: Uploads results to ArcVision dashboard for visualization
 
-```bash
-# Clone the repository
-git clone <repository-url>
-
-# Navigate to CLI directory
-cd cli
-
-# Install dependencies
-npm install
-
-# Build the CLI
-npm run build
-
-# Run in development mode
-npm run dev
-```
-
-## Configuration
-
-The CLI stores authentication tokens in `~/.arcvisionrc` in your home directory. This file is created automatically when you run `arcvision link <token>`.
+## Supported Import Patterns
 
-## API Integration
+- Relative imports: `./utils`, `../components`
+- Path aliases: `@/components/Button`, `~/lib/utils`
+- Barrel files: `./utils` resolves to `./utils/index.ts(x)`
+- Directory imports: `@/utils` resolves to `src/utils/index.ts(x)`
+- Implicit extensions: `.ts`, `.tsx`, `.js`, `.jsx`
 
-The CLI uploads scan results to the ArcVision dashboard API. You can configure the API endpoint using the `ARCVISION_API_URL` environment variable:
+## Architecture
 
-```bash
-export ARCVISION_API_URL="https://your-deployment-url.com"
-```
+The ArcVision CLI runs locally on your machine and:
+1. Scans your project files using AST parsing
+2. Detects import relationships between files
+3. Resolves path aliases using tsconfig.json/jsconfig.json
+4. Generates a dependency graph in JSON format
+5. Uploads the graph to the ArcVision dashboard via API
 
-## Troubleshooting
+## License
 
-- **Permission errors**: Ensure you have write permissions to the scan directory and config file location
-- **Network errors**: Check your internet connection and API endpoint accessibility
-- **Parse errors**: The scanner skips TypeScript declaration files (.d.ts) by default
+MIT

package/dist/index.js

@@ -56388,6 +56388,118 @@ var require_plugin_manager = __commonJS({
   }
 });
 
+// src/core/tsconfig-utils.js
+var require_tsconfig_utils = __commonJS({
+  "src/core/tsconfig-utils.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var path2 = require("path");
+    function loadTSConfig(projectRoot) {
+      const tsconfigPaths = [
+        path2.join(projectRoot, "tsconfig.json"),
+        path2.join(projectRoot, "jsconfig.json")
+      ];
+      for (const tsconfigPath of tsconfigPaths) {
+        if (fs2.existsSync(tsconfigPath)) {
+          try {
+            const raw = JSON.parse(fs2.readFileSync(tsconfigPath, "utf-8"));
+            return raw.compilerOptions || {};
+          } catch (error) {
+            console.warn(`Warning: Could not parse ${tsconfigPath}:`, error.message);
+            return null;
+          }
+        }
+      }
+      return null;
+    }
+    module2.exports = { loadTSConfig };
+  }
+});
+
+// src/core/path-resolver.js
+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("//")) {
+        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 (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;
+              }
+            }
+          }
+        }
+      }
+      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;
+      }
+      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;
+        }
+      }
+      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 null;
+    }
+    module2.exports = { resolveImport, resolveFile };
+  }
+});
+
 // src/core/scanner.js
 var require_scanner = __commonJS({
   "src/core/scanner.js"(exports2, module2) {
@@ -56395,6 +56507,8 @@ var require_scanner = __commonJS({
     var path2 = require("path");
     var parser = require_parser();
     var pluginManager = require_plugin_manager();
+    var { loadTSConfig } = require_tsconfig_utils();
+    var { resolveImport } = require_path_resolver();
     async function scan(directory) {
       const options = {
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
@@ -56427,25 +56541,26 @@ var require_scanner = __commonJS({
           }
         }
         const normalize = (p) => p.replace(/\\/g, "/");
-        const normalizedFileMap = /* @__PURE__ */ new Set();
-        architectureMap.nodes.forEach((n) => normalizedFileMap.add(normalize(n.id)));
+        const tsconfig = loadTSConfig(directory);
+        const normalizedFileMap = /* @__PURE__ */ new Map();
+        architectureMap.nodes.forEach((n) => normalizedFileMap.set(normalize(n.id), n.id));
         architectureMap.nodes.forEach((node) => {
           node.metadata.imports.forEach((imp) => {
-            let target = imp.source;
-            if (target.startsWith(".")) {
-              const dir = path2.dirname(node.id);
-              let resolved = path2.join(dir, target);
-              const extensions = ["", ".js", ".jsx", ".ts", ".tsx"];
-              for (const ext of extensions) {
-                const probe = normalize(resolved + ext);
-                if (normalizedFileMap.has(probe)) {
-                  architectureMap.edges.push({
-                    source: normalize(node.id),
-                    target: probe,
-                    type: "import"
-                  });
-                  break;
-                }
+            const resolvedPath = resolveImport(
+              imp.source,
+              path2.join(directory, node.id),
+              directory,
+              tsconfig
+            );
+            if (resolvedPath) {
+              const relativeResolvedPath = path2.relative(directory, resolvedPath);
+              const normalizedResolvedPath = normalize(relativeResolvedPath);
+              if (normalizedFileMap.has(normalizedResolvedPath)) {
+                architectureMap.edges.push({
+                  source: normalize(node.id),
+                  target: normalizedResolvedPath,
+                  type: "import"
+                });
               }
             }
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Architecture scanner for modern codebases",
   "bin": {
     "arcvision": "./dist/index.js"
@@ -34,4 +34,4 @@
   ],
   "author": "ArcVision",
   "license": "MIT"
-}
+}

package/src/core/path-resolver.js

@@ -0,0 +1,120 @@
+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
+ * @param {string} projectRoot - The root directory of the project
+ * @param {Object|null} tsconfig - The compilerOptions from tsconfig.json
+ * @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('//')) {
+    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 wildcard path aliases (e.g., '@/components/*' -> './src/components/*')
+  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;
+          }
+        }
+      }
+    }
+  }
+
+  // Handle baseUrl resolution (e.g., 'components/Button' -> './src/components/Button')
+  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;
+  }
+
+  // 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;
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = { resolveImport, resolveFile };

package/src/core/scanner.js

@@ -2,6 +2,8 @@ const { glob } = require('glob');
 const path = require('path');
 const parser = require('./parser');
 const pluginManager = require('../plugins/plugin-manager');
+const { loadTSConfig } = require('./tsconfig-utils');
+const { resolveImport } = require('./path-resolver');
 
 async function scan(directory) {
     const options = {
@@ -50,27 +52,34 @@ async function scan(directory) {
         // Normalize helper
         const normalize = p => p.replace(/\\/g, '/');
 
-        const normalizedFileMap = new Set();
-        architectureMap.nodes.forEach(n => normalizedFileMap.add(normalize(n.id)));
+        // Load tsconfig for path resolution
+        const tsconfig = loadTSConfig(directory);
+        
+        const normalizedFileMap = new Map();
+        architectureMap.nodes.forEach(n => normalizedFileMap.set(normalize(n.id), n.id));
 
         architectureMap.nodes.forEach(node => {
             node.metadata.imports.forEach(imp => {
-                let target = imp.source;
-                if (target.startsWith('.')) {
-                    const dir = path.dirname(node.id);
-                    let resolved = path.join(dir, target);
-                    const extensions = ['', '.js', '.jsx', '.ts', '.tsx'];
-
-                    for (const ext of extensions) {
-                        const probe = normalize(resolved + ext);
-                        if (normalizedFileMap.has(probe)) {
-                            architectureMap.edges.push({
-                                source: normalize(node.id),
-                                target: probe,
-                                type: 'import'
-                            });
-                            break;
-                        }
+                // Resolve the import path using the new resolver
+                const resolvedPath = resolveImport(
+                    imp.source,
+                    path.join(directory, node.id),
+                    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 (normalizedFileMap.has(normalizedResolvedPath)) {
+                        architectureMap.edges.push({
+                            source: normalize(node.id),
+                            target: normalizedResolvedPath,
+                            type: 'import'
+                        });
                     }
                 }
             });
@@ -83,4 +92,4 @@ async function scan(directory) {
     }
 }
 
-module.exports = { scan };
+module.exports = { scan };

package/src/core/tsconfig-utils.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load and parse tsconfig.json from project root
+ * @param {string} projectRoot - The root directory of the project
+ * @returns {Object|null} The compilerOptions from tsconfig.json or null if not found
+ */
+function loadTSConfig(projectRoot) {
+  const tsconfigPaths = [
+    path.join(projectRoot, 'tsconfig.json'),
+    path.join(projectRoot, 'jsconfig.json')
+  ];
+
+  for (const tsconfigPath of tsconfigPaths) {
+    if (fs.existsSync(tsconfigPath)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
+        return raw.compilerOptions || {};
+      } catch (error) {
+        console.warn(`Warning: Could not parse ${tsconfigPath}:`, error.message);
+        return null;
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = { loadTSConfig };

package/jest.config.json

@@ -1,6 +0,0 @@
-{
-  "testEnvironment": "node",
-  "testMatch": [
-    "**/tests/**/*.test.js"
-  ]
-}

package/tests/plugins.test.js

@@ -1,49 +0,0 @@
-const pluginManager = require('./src/plugins/plugin-manager');
-const path = require('path');
-
-describe('Plugin System', () => {
-    test('should register a plugin', () => {
-        const testPlugin = {
-            name: 'test-plugin',
-            process: async (filePath, metadata) => {
-                return { testField: 'test-value' };
-            }
-        };
-
-        pluginManager.register(testPlugin);
-        expect(pluginManager.plugins.length).toBeGreaterThan(0);
-    });
-
-    test('should process file with plugin', async () => {
-        const testPlugin = {
-            name: 'test-enhancer',
-            process: async (filePath, metadata) => {
-                return { enhanced: true };
-            }
-        };
-
-        pluginManager.register(testPlugin);
-
-        const metadata = { id: 'test.js', imports: [] };
-        const result = await pluginManager.processFile('test.js', metadata);
-
-        expect(result.enhanced).toBe(true);
-    });
-
-    test('should handle plugin errors gracefully', async () => {
-        const faultyPlugin = {
-            name: 'faulty-plugin',
-            process: async () => {
-                throw new Error('Plugin error');
-            }
-        };
-
-        pluginManager.register(faultyPlugin);
-
-        const metadata = { id: 'test.js' };
-        const result = await pluginManager.processFile('test.js', metadata);
-
-        // Should not crash
-        expect(result).toBeDefined();
-    });
-});

package/tests/scanner.test.js

@@ -1,52 +0,0 @@
-const scanner = require('./src/core/scanner');
-const parser = require('./src/core/parser');
-const path = require('path');
-
-describe('ArcVision Scanner', () => {
-    test('should parse a simple JavaScript file', () => {
-        const testFile = path.join(__dirname, '../example-project/utils.js');
-        const metadata = parser.parseFile(testFile);
-
-        expect(metadata).toBeDefined();
-        expect(metadata.exports).toContain('helper');
-        expect(metadata.functions).toBeDefined();
-    });
-
-    test('should scan a directory and return architecture map', async () => {
-        const testDir = path.join(__dirname, '../example-project');
-        const map = await scanner.scan(testDir);
-
-        expect(map).toBeDefined();
-        expect(map.nodes).toBeDefined();
-        expect(map.edges).toBeDefined();
-        expect(map.nodes.length).toBeGreaterThan(0);
-    }, 30000);
-
-    test('should detect imports and create edges', async () => {
-        const testDir = path.join(__dirname, '../example-project');
-        const map = await scanner.scan(testDir);
-
-        expect(map.edges.length).toBeGreaterThan(0);
-        const hasImportEdge = map.edges.some(e => e.type === 'import');
-        expect(hasImportEdge).toBe(true);
-    });
-
-    test('should detect API calls', async () => {
-        const testDir = path.join(__dirname, '../example-project');
-        const map = await scanner.scan(testDir);
-
-        const apiFile = map.nodes.find(n => n.id.includes('api.js'));
-        expect(apiFile).toBeDefined();
-        expect(apiFile.metadata.apiCalls).toBeDefined();
-        expect(apiFile.metadata.apiCalls.length).toBeGreaterThan(0);
-    });
-
-    test('should handle circular dependencies', async () => {
-        // This is a basic test - in real scenarios we'd create files with circular deps
-        const testDir = path.join(__dirname, '../example-project');
-        const map = await scanner.scan(testDir);
-
-        // Should not crash
-        expect(map).toBeDefined();
-    });
-});