arcvision 0.2.3 → 0.2.4

package/src/core/parser.js

@@ -1,343 +0,0 @@
-const parser = require('@babel/parser');
-const traverse = require('@babel/traverse').default;
-const fs = require('fs');
-const path = require('path');
-
-function parseFile(filePath) {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    let ast;
-    
-    // Enhanced parser options with more comprehensive plugin support
-    const parserOptions = {
-        sourceType: 'unambiguous', // Auto-detect between script and module
-        allowImportExportEverywhere: true,
-        allowReturnOutsideFunction: true,
-        allowSuperOutsideMethod: true,
-        plugins: [
-            'jsx',
-            'typescript',
-            'decorators-legacy',
-            'classProperties',
-            'exportDefaultFrom',
-            'exportNamespaceFrom',
-            'dynamicImport',
-            'functionBind',
-            'nullishCoalescingOperator',
-            'optionalChaining',
-            'numericSeparator',
-            'bigInt',
-            'importMeta',
-            'asyncGenerators',
-            'optionalCatchBinding',
-            'throwExpressions',
-            'logicalAssignment',
-            'nullishCoalescingOperator',
-            'doExpressions',
-            'pipeOperator',
-            'recordAndTuple',
-            'moduleBlocks',
-            'topLevelAwait',
-            'v8intrinsic',
-            'partialApplication',
-            'regexpUnicodeSets',
-            'destructuringPrivate',
-            'decoratorAutoAccessors'
-        ]
-    };
-    
-    try {
-        ast = parser.parse(content, parserOptions);
-    } catch (error) {
-        // Log the parsing error but don't throw - let the scanner continue
-        console.warn(`⚠️  Failed to parse ${filePath}: ${error.message}`);
-        // Return minimal metadata for files that can't be parsed
-        return {
-            id: filePath,
-            imports: [],
-            exports: [],
-            functions: [],
-            apiCalls: []
-        };
-    }
-
-    const metadata = {
-        id: filePath,
-        imports: [],
-        exports: [],
-        functions: [],
-        apiCalls: [],
-        classes: [],
-        variables: [],
-        dependencies: []
-    };
-
-    traverse(ast, {
-        ImportDeclaration({ node }) {
-            const importSource = node.source.value;
-            const specifiers = [];
-            
-            node.specifiers.forEach(spec => {
-                if (spec.imported && spec.local) {
-                    // Named import: import { name as alias } from 'source'
-                    specifiers.push({
-                        imported: spec.imported.name || spec.imported.value,
-                        local: spec.local.name
-                    });
-                } else if (spec.local) {
-                    // Default import: import name from 'source'
-                    specifiers.push({
-                        imported: 'default',
-                        local: spec.local.name
-                    });
-                }
-            });
-            
-            metadata.imports.push({
-                source: importSource,
-                specifiers: specifiers
-            });
-        },
-        ImportExpression({ node }) {
-            // Handle dynamic imports: import('module')
-            if (node.source && node.source.type === 'StringLiteral') {
-                metadata.imports.push({
-                    source: node.source.value,
-                    specifiers: [],
-                    dynamic: true
-                });
-            }
-        },
-        ExportNamedDeclaration({ node }) {
-            // Handle export { X, Y, Z } from './file' statements
-            if (node.source) {
-                const specifiers = [];
-                if (node.specifiers) {
-                    node.specifiers.forEach(spec => {
-                        specifiers.push({
-                            exported: spec.exported.name || spec.exported.value || spec.exported.value,
-                            local: spec.local ? spec.local.name : spec.exported.name || spec.exported.value
-                        });
-                    });
-                }
-                
-                metadata.imports.push({
-                    source: node.source.value,
-                    specifiers: specifiers,
-                    type: 'export-from'
-                });
-            }
-            // Handle export declarations without source (local exports)
-            if (node.declaration) {
-                if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-                    metadata.exports.push({
-                        name: node.declaration.id.name,
-                        type: 'function',
-                        loc: node.declaration.loc
-                    });
-                } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
-                    metadata.exports.push({
-                        name: node.declaration.id.name,
-                        type: 'class',
-                        loc: node.declaration.loc
-                    });
-                } else if (node.declaration.type === 'VariableDeclaration') {
-                    node.declaration.declarations.forEach(decl => {
-                        if (decl.id.name) {
-                            metadata.exports.push({
-                                name: decl.id.name,
-                                type: 'variable',
-                                loc: decl.loc
-                            });
-                        } else if (decl.id.type === 'ObjectPattern') {
-                            // Handle destructuring exports: export const { a, b } = obj
-                            decl.id.properties.forEach(prop => {
-                                if (prop.key.name) {
-                                    metadata.exports.push({
-                                        name: prop.key.name,
-                                        type: 'variable',
-                                        loc: prop.loc
-                                    });
-                                }
-                            });
-                        } else if (decl.id.type === 'ArrayPattern') {
-                            // Handle array destructuring exports: export const [a, b] = arr
-                            decl.id.elements.forEach(element => {
-                                if (element && element.name) {
-                                    metadata.exports.push({
-                                        name: element.name,
-                                        type: 'variable',
-                                        loc: element.loc
-                                    });
-                                }
-                            });
-                        }
-                    });
-                }
-            }
-        },
-        ExportAllDeclaration({ node }) {
-            // Handle export * from './file' statements
-            metadata.imports.push({
-                source: node.source.value,
-                specifiers: ['*'],
-                type: 'export-all'
-            });
-        },
-        ExportDefaultDeclaration({ node }) {
-            let exportName = 'default';
-            
-            if (node.declaration) {
-                if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-                    exportName = node.declaration.id.name || 'default';
-                } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
-                    exportName = node.declaration.id.name || 'default';
-                }
-            }
-            
-            metadata.exports.push({
-                name: exportName,
-                type: 'default',
-                loc: node.loc
-            });
-        },
-        FunctionDeclaration({ node }) {
-            if (node.id && node.id.name) {
-                metadata.functions.push({
-                    name: node.id.name,
-                    params: node.params.map(p => {
-                        if (p.type === 'Identifier') {
-                            return p.name;
-                        } else if (p.type === 'ObjectPattern') {
-                            return 'ObjectPattern';
-                        } else if (p.type === 'ArrayPattern') {
-                            return 'ArrayPattern';
-                        } else {
-                            return '?';
-                        }
-                    }),
-                    loc: node.loc
-                });
-            }
-        },
-        FunctionExpression({ node }) {
-            // Capture anonymous function assignments
-            if (node.id && node.id.name) {
-                metadata.functions.push({
-                    name: node.id.name,
-                    params: node.params.map(p => p.name || '?'),
-                    loc: node.loc
-                });
-            }
-        },
-        ArrowFunctionExpression({ node }) {
-            // Capture arrow functions if they're part of variable declarations
-            // This helps identify function definitions in modern JS
-        },
-        ClassDeclaration({ node }) {
-            if (node.id && node.id.name) {
-                metadata.classes.push({
-                    name: node.id.name,
-                    superClass: node.superClass ? node.superClass.name : null,
-                    loc: node.loc
-                });
-            }
-        },
-        VariableDeclaration({ node }) {
-            node.declarations.forEach(decl => {
-                if (decl.id.name) {
-                    metadata.variables.push({
-                        name: decl.id.name,
-                        type: 'variable',
-                        loc: decl.loc
-                    });
-                } else if (decl.id.type === 'ObjectPattern') {
-                    // Handle destructuring: const { a, b } = obj
-                    decl.id.properties.forEach(prop => {
-                        if (prop.key && prop.key.name) {
-                            metadata.variables.push({
-                                name: prop.key.name,
-                                type: 'destructured',
-                                loc: prop.loc
-                            });
-                        }
-                    });
-                } else if (decl.id.type === 'ArrayPattern') {
-                    // Handle array destructuring: const [a, b] = arr
-                    decl.id.elements.forEach((element, index) => {
-                        if (element && element.name) {
-                            metadata.variables.push({
-                                name: element.name,
-                                type: 'destructured',
-                                loc: element.loc
-                            });
-                        }
-                    });
-                }
-            });
-        },
-        CallExpression({ node }) {
-            if (node.callee.name === 'fetch') {
-                const arg = node.arguments[0];
-                metadata.apiCalls.push({
-                    type: 'fetch',
-                    url: arg && arg.type === 'StringLiteral' ? arg.value : 'dynamic',
-                    loc: node.loc
-                });
-            }
-            if (node.callee.name === 'require' && node.arguments.length > 0) {
-                const sourceArg = node.arguments[0];
-                if (sourceArg && sourceArg.type === 'StringLiteral') {
-                    metadata.imports.push({
-                        source: sourceArg.value,
-                        specifiers: [],
-                        type: 'require'
-                    });
-                }
-            }
-            // Handle other common API calls
-            if (node.callee.type === 'MemberExpression' &&
-                node.callee.object &&
-                node.callee.object.name === 'axios') {
-                metadata.apiCalls.push({
-                    type: 'axios',
-                    method: node.callee.property.name,
-                    loc: node.loc
-                });
-            }
-            
-            // Handle other common import patterns like import() in function calls
-            if (node.callee.type === 'Import' && node.arguments.length > 0) {
-                const sourceArg = node.arguments[0];
-                if (sourceArg && sourceArg.type === 'StringLiteral') {
-                    metadata.imports.push({
-                        source: sourceArg.value,
-                        specifiers: [],
-                        type: 'dynamic-import'
-                    });
-                }
-            }
-        },
-        
-        VariableDeclarator({ node }) {
-            // Handle import assignments like: const { something } = require('module')
-            if (node.init && node.init.type === 'CallExpression' && 
-                node.init.callee.name === 'require' && 
-                node.init.arguments.length > 0 &&
-                node.init.arguments[0].type === 'StringLiteral') {
-                metadata.imports.push({
-                    source: node.init.arguments[0].value,
-                    specifiers: [],
-                    type: 'require-assignment'
-                });
-            }
-        },
-        
-        MemberExpression({ node }) {
-            // Additional member expression handling for complex import patterns
-        }
-    });
-
-    return metadata;
-}
-
-module.exports = { parseFile };

package/src/core/path-resolver.js

@@ -1,174 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- * 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 - Loaded tsconfig with compilerOptions
- * @returns {string|null} The resolved absolute file path or null if not found
- */
-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:') || importPath.startsWith('file:')) {
-    return null;
-  }
-
-  // Handle relative imports
-  if (importPath.startsWith('.')) {
-    // Resolve relative to importer
-    let resolvedPath = path.resolve(path.dirname(importerPath), importPath);
-    
-    // Try with various extensions in order of preference
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
-    for (const ext of extensions) {
-      if (fs.existsSync(resolvedPath + ext)) {
-        return resolvedPath + ext;
-      }
-    }
-    
-    // Try as directory with index files
-    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
-    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 path aliases (like @/components/, ~/utils/, etc.)
-  if (tsconfig && tsconfig.paths) {
-    const paths = tsconfig.paths;
-    
-    // Sort aliases by length (descending) to match longer patterns first
-    const sortedAliases = Object.keys(paths).sort((a, b) => b.length - a.length);
-    
-    for (const aliasPattern of sortedAliases) {
-      const aliasTargets = paths[aliasPattern];
-      
-      // Handle pattern like "@/*" -> ["./src/*"]
-      if (aliasPattern.includes('*')) {
-        const patternBase = aliasPattern.replace(/\*.*$/, '');
-        
-        if (importPath.startsWith(patternBase)) {
-          const suffix = importPath.substring(patternBase.length);
-          
-          for (const target of aliasTargets) {
-            const targetBase = target.replace(/\*.*$/, '');
-            const targetPath = path.resolve(projectRoot, path.join(targetBase, suffix));
-            
-            // Try with extensions
-            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
-            for (const ext of extensions) {
-              if (fs.existsSync(targetPath + ext)) {
-                return targetPath + ext;
-              }
-            }
-            
-            // Try as directory with index files
-            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
-            for (const idxFile of indexFiles) {
-              const indexPath = path.join(targetPath, idxFile);
-              if (fs.existsSync(indexPath)) {
-                return indexPath;
-              }
-            }
-            
-            // Try exact path
-            if (fs.existsSync(targetPath)) {
-              return targetPath;
-            }
-          }
-        }
-      } else {
-        // Handle exact match patterns
-        if (importPath === aliasPattern || importPath.startsWith(aliasPattern + '/')) {
-          for (const target of aliasTargets) {
-            let targetPath = path.resolve(projectRoot, target);
-            
-            // If importPath is longer than the alias pattern, add the remaining part
-            if (importPath.length > aliasPattern.length) {
-              const remainingPath = importPath.substring(aliasPattern.length);
-              targetPath = path.join(targetPath, remainingPath);
-            }
-            
-            // Try with extensions
-            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
-            for (const ext of extensions) {
-              if (fs.existsSync(targetPath + ext)) {
-                return targetPath + ext;
-              }
-            }
-            
-            // Try as directory with index files
-            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
-            for (const idxFile of indexFiles) {
-              const indexPath = path.join(targetPath, idxFile);
-              if (fs.existsSync(indexPath)) {
-                return indexPath;
-              }
-            }
-            
-            // Try exact path
-            if (fs.existsSync(targetPath)) {
-              return targetPath;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Handle baseUrl if configured
-  if (tsconfig && tsconfig.baseUrl && !importPath.startsWith('.')) {
-    let resolvedPath = path.resolve(projectRoot, tsconfig.baseUrl, importPath);
-    
-    // Try with extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
-    for (const ext of extensions) {
-      if (fs.existsSync(resolvedPath + ext)) {
-        return resolvedPath + ext;
-      }
-    }
-    
-    // Try as directory with index files
-    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
-    for (const idxFile of indexFiles) {
-      const indexPath = path.join(resolvedPath, idxFile);
-      if (fs.existsSync(indexPath)) {
-        return indexPath;
-      }
-    }
-    
-    // Try exact path
-    if (fs.existsSync(resolvedPath)) {
-      return resolvedPath;
-    }
-  }
-
-  // Handle node_modules resolution
-  if (!importPath.startsWith('.')) {
-    // Check if it's a node module
-    try {
-      const resolved = require.resolve(importPath, { paths: [path.dirname(importerPath)] });
-      return resolved;
-    } catch (e) {
-      // If require.resolve fails, it's not a node module
-    }
-  }
-
-  return null;
-}
-
-module.exports = { resolveImport };