arcvision 0.2.14 → 0.2.15

package/src/core/parser-enhanced.js

@@ -0,0 +1,80 @@
+/**
+ * Enhanced Parser Wrapper
+ * 
+ * Wraps the existing parser and adds enhanced metadata extraction
+ * using all the new analyzer modules.
+ */
+
+const { parseFile: originalParseFile } = require('./parser');
+const { detectDependencyInjection } = require('./di-detector');
+const { trackMethodCalls } = require('./method-tracker');
+const { analyzeTypeDependencies } = require('./type-analyzer');
+const { detectReactNextJSPatterns } = require('./react-nextjs-detector');
+const fs = require('fs');
+
+/**
+ * Enhanced parseFile that includes all new analysis
+ * @param {string} filePath - Path to file to parse
+ * @returns {Object} Enhanced metadata
+ */
+function parseFileEnhanced(filePath) {
+    // Get basic metadata from original parser
+    const metadata = originalParseFile(filePath);
+
+    // If parsing failed, return as-is
+    if (!metadata.ast) {
+        return metadata;
+    }
+
+    const ast = metadata.ast;
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    
+    // Skip enhanced analysis for markdown files
+    if (filePath.endsWith('.md')) {
+        // Remove AST from final metadata to reduce memory usage
+        delete metadata.ast;
+        return metadata;
+    }
+
+    // Apply all new analyzers
+    try {
+        // Dependency Injection detection
+        const diPatterns = detectDependencyInjection(ast);
+        metadata.constructorInjections = diPatterns.constructorInjections || [];
+        metadata.contextUsages = diPatterns.contextUsages || [];
+        metadata.hookDependencies = diPatterns.hookDependencies || [];
+
+        // Method call tracking
+        const callTracking = trackMethodCalls(ast, metadata.imports);
+        metadata.functionCalls = callTracking.functionCalls || [];
+        metadata.constructorCalls = callTracking.constructorCalls || [];
+        metadata.methodCalls = callTracking.methodCalls || [];
+
+        // Type dependency analysis
+        const typeDeps = analyzeTypeDependencies(ast);
+        metadata.typeImports = typeDeps.typeImports || [];
+        metadata.interfaceDependencies = typeDeps.interfaceDependencies || [];
+        metadata.genericDependencies = typeDeps.genericDependencies || [];
+
+        // React/Next.js pattern detection
+        const reactPatterns = detectReactNextJSPatterns(ast, fileContent, filePath);
+        metadata.componentUsage = reactPatterns.componentUsages || [];
+        metadata.serverClientBoundaries = reactPatterns.boundaries || {};
+        metadata.apiDependencies = reactPatterns.apiDependencies || [];
+        metadata.middlewareDependencies = reactPatterns.middlewareDependencies || [];
+
+    } catch (error) {
+        console.warn(`⚠️ Enhanced analysis failed for ${filePath}: ${error.message}`);
+        // Continue with basic metadata if enhanced analysis fails
+    }
+
+    // Remove AST from final metadata to reduce memory usage
+    delete metadata.ast;
+
+    return metadata;
+}
+
+module.exports = {
+    parseFile: parseFileEnhanced,
+    parseFileBasic: originalParseFile
+};

package/src/core/parser.js

@@ -0,0 +1,610 @@
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const fs = require('fs');
+const path = require('path');
+
+// File content cache to avoid repeated disk reads
+const fileContentCache = new Map();
+
+function parseFile(filePath) {
+    let content;
+    
+    // Check cache first
+    if (fileContentCache.has(filePath)) {
+        const cached = fileContentCache.get(filePath);
+        try {
+            const stat = fs.statSync(filePath);
+            if (cached.mtime && stat.mtimeMs <= cached.mtime) {
+                // Cache is still valid, use cached content
+                content = cached.content;
+            } else {
+                // Cache is stale, read fresh content and update cache
+                content = fs.readFileSync(filePath, 'utf-8');
+                fileContentCache.set(filePath, {
+                    content: content,
+                    mtime: stat.mtimeMs
+                });
+            }
+        } catch (statError) {
+            // If stat fails, fall back to reading file and caching
+            content = fs.readFileSync(filePath, 'utf-8');
+            try {
+                const stat = fs.statSync(filePath);
+                fileContentCache.set(filePath, {
+                    content: content,
+                    mtime: stat.mtimeMs
+                });
+            } catch (cacheError) {
+                // If caching fails, continue without cache
+            }
+        }
+    } else {
+        // File not in cache, read and add to cache
+        content = fs.readFileSync(filePath, 'utf-8');
+        try {
+            const stat = fs.statSync(filePath);
+            fileContentCache.set(filePath, {
+                content: content,
+                mtime: stat.mtimeMs
+            });
+        } catch (cacheError) {
+            // If caching fails, continue without cache
+        }
+    }
+    
+    let ast;
+    
+    // Determine if this is a TypeScript declaration file
+    const isDeclarationFile = filePath.endsWith('.d.ts');
+
+    // Enhanced parser options with more comprehensive plugin support
+    const parserOptions = {
+        sourceType: 'unambiguous', // Auto-detect between script and module
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+        allowSuperOutsideMethod: true,
+        errorRecovery: true, // Allow parser to continue after errors
+        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'
+        ]
+    };
+
+    // Add declaration file specific options if this is a declaration file
+    if (isDeclarationFile) {
+        parserOptions.plugins.push('typescript');
+    }
+
+    try {
+        ast = parser.parse(content, parserOptions);
+    } catch (error) {
+        // Try alternative parser options for files with complex syntax
+        const fallbackParserOptions = {
+            ...parserOptions,
+            // Allow more flexible parsing
+            errorRecovery: true, // Allow parser to continue after errors
+            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',
+                'typescript',
+                'decorators'
+            ]
+        };
+        
+        // Add declaration file specific options
+        if (isDeclarationFile) {
+            fallbackParserOptions.plugins.push('typescript');
+        }
+        
+        try {
+            ast = parser.parse(content, fallbackParserOptions);
+        } catch (fallbackError) {
+            // If both attempts fail, try with even more lenient settings
+            const ultraFallbackParserOptions = {
+                sourceType: 'unambiguous',
+                allowImportExportEverywhere: true,
+                allowReturnOutsideFunction: true,
+                allowSuperOutsideMethod: true,
+                errorRecovery: true,
+                plugins: [
+                    'typescript',
+                    'jsx',
+                    'decorators-legacy',
+                    'classProperties',
+                    'typescript',
+                    'optionalChaining',
+                    'nullishCoalescingOperator',
+                    'logicalAssignment',
+                    'numericSeparator',
+                    'optionalCatchBinding',
+                    'importMeta',
+                    'functionBind',
+                    'throwExpressions'
+                ]
+            };
+            
+            // Add declaration file specific options
+            if (isDeclarationFile) {
+                ultraFallbackParserOptions.plugins.push('typescript');
+            }
+            
+            try {
+                ast = parser.parse(content, ultraFallbackParserOptions);
+            } catch (ultraFallbackError) {
+                // If all attempts fail, collect error info for reporting but continue with minimal processing
+                const errorInfo = {
+                    file: filePath,
+                    error: error.message,
+                    line: error.loc ? error.loc.line : 'unknown',
+                    column: error.loc ? error.loc.column : 'unknown'
+                };
+                
+                // Store error for later reporting instead of immediate console output
+                if (!global.parserErrors) {
+                    global.parserErrors = [];
+                }
+                global.parserErrors.push(errorInfo);
+                
+                // Return minimal metadata for files that can't be parsed
+                return {
+                    id: filePath,
+                    imports: [],
+                    exports: [],
+                    functions: [],
+                    apiCalls: [],
+                    potentialInvocations: extractPotentialLuaInvocations(content)
+                };
+            }
+        }
+    }
+
+    const metadata = {
+        id: filePath,
+        ast: ast, // Include AST for enhanced analyzers
+        imports: [],
+        exports: [],
+        functions: [],
+        apiCalls: [],
+        classes: [],
+        variables: [],
+        types: [],
+        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
+                                    });
+                                }
+                            });
+                        }
+                    });
+                } else if (node.declaration.type === 'TSInterfaceDeclaration' && node.declaration.id) {
+                    metadata.exports.push({
+                        name: node.declaration.id.name,
+                        type: 'interface',
+                        loc: node.declaration.loc
+                    });
+                } else if (node.declaration.type === 'TSTypeAliasDeclaration' && node.declaration.id) {
+                    metadata.exports.push({
+                        name: node.declaration.id.name,
+                        type: 'type',
+                        loc: node.declaration.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(path) {
+            // Capture arrow functions assigned to variables
+            const parent = path.parent;
+            if (parent.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+                metadata.functions.push({
+                    name: parent.id.name,
+                    params: path.node.params.map(p => p.name || '?'),
+                    loc: parent.loc
+                });
+            }
+        },
+        TSInterfaceDeclaration({ node }) {
+            if (node.id && node.id.name) {
+                metadata.types.push({
+                    name: node.id.name,
+                    kind: 'interface',
+                    loc: node.loc
+                });
+            }
+        },
+        TSTypeAliasDeclaration({ node }) {
+            if (node.id && node.id.name) {
+                metadata.types.push({
+                    name: node.id.name,
+                    kind: 'type',
+                    loc: node.loc
+                });
+            }
+        },
+        VariableDeclaration({ node }) {
+            node.declarations.forEach(decl => {
+                if (decl.id.name) {
+                    const variableData = {
+                        name: decl.id.name,
+                        type: 'variable',
+                        loc: decl.loc
+                    };
+
+                    // Capture properties of object literals
+                    if (decl.init && decl.init.type === 'ObjectExpression') {
+                        variableData.properties = decl.init.properties
+                            .map(p => {
+                                if (p.key && (p.key.name || p.key.value)) {
+                                    return {
+                                        name: p.key.name || p.key.value,
+                                        loc: p.loc
+                                    };
+                                }
+                                return null;
+                            })
+                            .filter(Boolean);
+                    }
+
+                    metadata.variables.push(variableData);
+                } 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.callee.property && node.init.callee.property.name === 'require') ||
+                 (node.init.callee.type === 'MemberExpression' && node.init.callee.property.name === 'import')) &&
+                node.init.arguments.length > 0 &&
+                (node.init.arguments[0].type === 'StringLiteral' || node.init.arguments[0].type === 'TemplateLiteral')) {
+                
+                // Extract the source from either StringLiteral or TemplateLiteral
+                let sourceValue = '';
+                if (node.init.arguments[0].type === 'StringLiteral') {
+                    sourceValue = node.init.arguments[0].value;
+                } else if (node.init.arguments[0].type === 'TemplateLiteral') {
+                    // For template literals, extract the quasis (static parts) and expressions
+                    sourceValue = node.init.arguments[0].quasis.map(q => q.value.cooked).join('');
+                }
+                
+                const specifiers = [];
+                if (node.id.type === 'ObjectPattern') {
+                    node.id.properties.forEach(prop => {
+                        const importedName = (prop.key && (prop.key.name || prop.key.value)) || null;
+                        const localName = (prop.value && prop.value.name) || importedName;
+                        if (importedName) {
+                            specifiers.push({
+                                imported: importedName,
+                                local: localName
+                            });
+                        }
+                    });
+                } else if (node.id.type === 'Identifier') {
+                    specifiers.push({
+                        imported: 'default',
+                        local: node.id.name
+                    });
+                } else if (node.id.type === 'ArrayPattern') {
+                    // Handle array destructuring: const [a, b] = require('module')
+                    node.id.elements.forEach((element, index) => {
+                        if (element && element.name) {
+                            specifiers.push({
+                                imported: String(index),
+                                local: element.name
+                            });
+                        }
+                    });
+                }
+
+                metadata.imports.push({
+                    source: sourceValue,
+                    specifiers: specifiers,
+                    type: 'require-assignment'
+                });
+            }
+        },
+
+        MemberExpression({ node }) {
+            // Additional member expression handling for complex import patterns
+        }
+    });
+
+    return metadata;
+}
+
+function extractPotentialLuaInvocations(content) {
+    const invocations = [];
+    
+    // Look for common Lua invocation patterns in the content
+    const patterns = [
+        /defineCommand\(\s*['"].*?['"]\s*,\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /defineCommand\(\s*[^,)]+\s*,\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /defineCommand\(\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /readFileSync\(['"].*\.lua['"].*\)/gi,
+        /require\(['"].*\.lua['"].*\)/gi,
+        /fs\.readFileSync\(['"].*\.lua['"].*\)/gi,
+        /loadScript\(['"].*\.lua['"].*\)/gi,
+        /loadLua\(['"].*\.lua['"].*\)/gi,
+        /load\(['"].*\.lua['"].*\)/gi
+    ];
+    
+    patterns.forEach(pattern => {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            invocations.push({
+                pattern: match[0],
+                type: 'lua_invocation'
+            });
+        }
+    });
+    
+    return invocations;
+}
+
+module.exports = { parseFile };