arcvision 0.1.10 → 0.1.13

package/dist/index.js

@@ -56442,92 +56442,75 @@ 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;
           }
         }
-      }
-      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;
+        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;
           }
         }
       }
       return null;
     }
-    module2.exports = { resolveImport, resolveFile };
+    module2.exports = { resolveImport };
   }
 });
 
@@ -56541,6 +56524,7 @@ var require_scanner = __commonJS({
     var { loadTSConfig } = require_tsconfig_utils();
     var { resolveImport } = require_path_resolver();
     async function scan(directory) {
+      const normalize = (p) => p.replace(/\\/g, "/");
       const options = {
         ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
         cwd: directory,
@@ -56572,7 +56556,6 @@ var require_scanner = __commonJS({
             console.warn(`\u26A0\uFE0F Failed to parse ${file} \u2014 file skipped, you should check manually`);
           }
         }
-        const normalize = (p) => p.replace(/\\/g, "/");
         const tsconfig = loadTSConfig(directory);
         const normalizedFileMap = /* @__PURE__ */ new Map();
         architectureMap.nodes.forEach((n) => normalizedFileMap.set(normalize(n.id), n.id));

package/package.json

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

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

@@ -6,6 +6,9 @@ const { loadTSConfig } = require('./tsconfig-utils');
 const { resolveImport } = require('./path-resolver');
 
 async function scan(directory) {
+    // Normalize helper
+    const normalize = p => p.replace(/\\/g, '/');
+    
     const options = {
         ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
         cwd: directory,
@@ -50,10 +53,7 @@ async function scan(directory) {
                 console.warn(`⚠️ Failed to parse ${file} — file skipped, you should check manually`);
             }
         }
-
-        // Normalize helper
-        const normalize = p => p.replace(/\\/g, '/');
-
+        
         // Load tsconfig for path resolution
         const tsconfig = loadTSConfig(directory);