entkapp 4.5.1 → 5.1.0

package/src/ast/OxcAnalyzer.js

@@ -1,5 +1,9 @@
 import path from 'path';
 
+/**
+ * Production-Grade Native Rust AST Parser Bridge (OXC)
+ * Enterprise Edition: Enhanced with Call Graph support, Data Flow hints, and Symbol Tracking.
+ */
 export class OxcAnalyzer {
   constructor(context) {
     this.context = context;
@@ -8,9 +12,12 @@ export class OxcAnalyzer {
   }
 
   async init() {
+    // FIX: Always mark oxc-parser as used if this analyzer is even instantiated
+    if (this.context.usedExternalPackages) this.context.usedExternalPackages.add("oxc-parser");
     if (this.isAvailable) return true;
     try {
-      this.oxc = await import("oxc-parser");
+      const oxc = await import("oxc-parser");
+      this.oxc = oxc;
       this.isAvailable = true;
       return true;
     } catch (e) {
@@ -22,9 +29,6 @@ export class OxcAnalyzer {
         return true;
       } catch (err) {
         this.isAvailable = false;
-        if (this.context.verbose) {
-          console.warn("[OxcAnalyzer] oxc-parser not found or failed to load.");
-        }
         return false;
       }
     }
@@ -37,115 +41,56 @@ export class OxcAnalyzer {
     }
 
     try {
-      // Fix: Remove BOM if present (confuses some Rust parsers)
       const cleanContent = content.startsWith('\uFEFF') ? content.slice(1) : content;
-      
-      // Fix: Use absolute path with forward slashes for OXC (most stable for Rust on Windows)
       const normalizedPath = filePath.replace(/\\/g, '/');
-      // FIX: The previous regex was too aggressive and matched patterns that are NOT regex literals
-      // (like paths in strings or comments), causing it to strip characters and create invalid regex flags
-      // for OXC. We now only target what looks like a regex literal at the end of a line or statement.
-      const normalizedContent = cleanContent.replace(/\/([gimuy]*)([nh]+)([gimuy]*)(?=\s|[;,\)]|$)/g, (match, p1, p2, p3) => {
-        // Only normalize if it's likely a regex (flags p1/p3 are valid JS flags)
-        const validJSFlags = /^[gimuy]*$/;
-        if (validJSFlags.test(p1) && validJSFlags.test(p3)) {
-          if (this.context.verbose) console.log(`[OXC] Normalizing regex flag: ${p2} at ${filePath}`);
-          return `/${p1}${p3}`;
-        }
-        return match;
-      });
+      
       let result;
       try {
-        // ONLY USE FLAT SIGNATURE: parseSync(sourceText, sourceFilename)
-        // This avoids the "rust type String" conversion error seen with configuration objects.
-        result = this.oxc.parseSync(normalizedContent, normalizedPath);
+        result = this.oxc.parseSync(cleanContent, {
+          sourceType: "module",
+          sourceFilename: normalizedPath,
+          lang: "typescript"
+        });
       } catch (e) {
-        // Silent fallback to TS Compiler if OXC fails
-        return false;
-      }
-
-      if (this.context.verbose) {
-        console.log(`[OXC] Parsed ${filePath} using flat signature`);
+        try {
+          result = this.oxc.parseSync(cleanContent, normalizedPath);
+        } catch (innerErr) {
+          return false;
+        }
       }
 
-      // Fix: Handle cases where OXC returns a JSON string instead of an object
-      // Stabilize result through JSON round-trip to fix N-API conversion issues on Windows
-let parsedResult;
+      let parsedResult;
       try {
         parsedResult = typeof result === 'string' ? JSON.parse(result) : JSON.parse(JSON.stringify(result));
       } catch (err) {
-        parsedResult = result;
-      }
-      // REPORT OXC ERRORS: If the parser found syntax errors, show them in verbose mode
-      if (this.context.verbose && parsedResult.errors && parsedResult.errors.length > 0) {
-        console.log(`[OXC] ❌ Parser reported ${parsedResult.errors.length} errors for ${normalizedPath}:`);
-        parsedResult.errors.forEach(err => console.log(`  - ${err.message || err}`));
-      }
-
-      let ast = (parsedResult && parsedResult.program) ? parsedResult : { program: parsedResult };
-      fileNode.ast = ast.program;
-      fileNode.jsxComponents = new Set();
-      fileNode.jsxProps = new Set();
-      fileNode.decorators = new Set();
-      if (parsedResult && typeof parsedResult === 'object') {
-        if (parsedResult.program) {
-          ast = parsedResult;
-        } else if (parsedResult.ast) {
-          ast = { program: parsedResult.ast };
-        } else if (parsedResult.body || parsedResult.type === 'Program') {
-          ast = { program: parsedResult };
+        if (result && typeof result === 'object') {
+          parsedResult = result;
         } else {
-          ast = { program: parsedResult };
+          return false;
         }
-      } else {
-        throw new Error("OXC returned an invalid AST format");
       }
 
-      fileNode.ast = ast.program; // Store the AST for advanced analysis
-      fileNode.jsxComponents = new Set();
-      fileNode.jsxProps = new Set();
-      fileNode.decorators = new Set();
-
-      if (this.context.verbose) {
-        console.log(`[OXC] Analyzing ${filePath}`);
-      }
-      this.walkOxcAst(ast.program, fileNode, content);
-      
-      // 7. Success confirmation
-      if (this.context.verbose) {
-        console.log(`[OXC] Successfully parsed and analyzed ${filePath}`);
+      let programRoot = null;
+      if (parsedResult && typeof parsedResult === 'object') {
+        if (parsedResult.program) programRoot = parsedResult.program;
+        else if (parsedResult.ast) programRoot = parsedResult.ast;
+        else if (parsedResult.type === 'Program' || parsedResult.body) programRoot = parsedResult;
       }
-      // Fallback: If OXC found 0 imports but the file has content that looks like it has imports, 
-      // return false to trigger the TS Compiler API fallback. This is a safety anchor.
-      if (fileNode.explicitImports.size === 0 && (content.includes('import') || content.includes('export')) && content.length > 50) {
-        if (this.context.verbose) {
-          console.log(`[OXC] ⚠️ Parser yielded 0 imports/exports for ${filePath}. Engaging TS Compiler fallback for accuracy.`);
-          
-          // DEEP DIAGNOSTICS: Inspect the first few nodes of the AST to see what OXC is actually producing
-          if (ast.program && ast.program.body && ast.program.body.length > 0) {
-            console.log(`[OXC-DEBUG] AST Program Body Length: ${ast.program.body.length}`);
-            const firstNodes = ast.program.body.slice(0, 3).map(n => ({
-              type: n.type,
-              hasSource: !!n.source,
-              hasDeclaration: !!n.declaration,
-              specifiersCount: n.specifiers ? n.specifiers.length : 0
-            }));
-            console.log(`[OXC-DEBUG] First 3 Nodes structure: ${JSON.stringify(firstNodes, null, 2)}`);
-          } else {
-            console.log(`[OXC-DEBUG] AST Program Body is EMPTY or UNDEFINED.`);
-          }
-        }
+
+      if (!programRoot || !programRoot.body) {
         return false;
       }
 
-      if (this.context.verbose) {
-        console.log(`[OXC] Found ${fileNode.explicitImports.size} imports in ${filePath}`);
-        if (fileNode.explicitImports.size > 0) {
-          console.log(`[OXC] Imports for ${filePath}: ${Array.from(fileNode.explicitImports).join(', ')}`);
-        }
-      }
+      fileNode.ast = programRoot; 
+      fileNode.symbolTable = new Map(); // Local scope tracking
+      
+      // Pass 1: Structural Analysis (Definitions, Imports, Exports)
+      this.walkOxcAst(programRoot, fileNode, cleanContent, 1);
       
-      const lines = content.split('\n');
+      // Pass 2: Logical Analysis (References, Call Sites, Property Access)
+      this.walkOxcAst(programRoot, fileNode, cleanContent, 2);
+      
+      const lines = cleanContent.split('\n');
       const getLineCol = (pos) => {
         let count = 0;
         for (let i = 0; i < lines.length; i++) {
@@ -161,57 +106,109 @@ let parsedResult;
         if (meta.start !== undefined) {
           fileNode.symbolSourceLocations.set(name, getLineCol(meta.start));
         }
+        if (meta.members) {
+            meta.members.forEach(member => {
+                if (member.start !== undefined) {
+                    fileNode.symbolSourceLocations.set(`${name}.${member.name}`, getLineCol(member.start));
+                }
+            });
+        }
       }
 
       return true;
     } catch (e) {
-      if (this.context.verbose) {
-        console.warn(`[OXC] Failed to parse ${filePath}. Error: ${e.message}`);
-        if (e.stack) console.debug(e.stack);
-        console.info(`[OXC] Switching back to TypeScript Compiler API for ${filePath}`);
-      }
       return false;
     }
   }
 
-  walkOxcAst(node, fileNode, content) {
+  walkOxcAst(node, fileNode, content, pass) {
     if (!node) return;
 
-    switch (node.type) {
-      case "ImportDeclaration":
-        this.handleImportDeclaration(node, fileNode);
-        break;
-      case "ExportNamedDeclaration":
-      case "ExportDefaultDeclaration":
-      case "ExportAllDeclaration":
-        this.handleExportDeclaration(node, fileNode, content);
-        break;
-      case "CallExpression":
-        this.handleCallExpression(node, fileNode);
-        break;
-      case "JSXElement":
-      case "JSXFragment":
-        this.handleJsxElement(node, fileNode);
-        break;
-      case "Decorator":
-        this.handleDecorator(node, fileNode);
-        break;
-      case "StringLiteral":
-        fileNode.rawStringReferences.add(node.value);
-        break;
+    if (pass === 1) {
+        switch (node.type) {
+          case "ImportDeclaration":
+            this.handleImportDeclaration(node, fileNode);
+            break;
+          case "ImportExpression":
+            this.handleImportExpression(node, fileNode);
+            break;
+          case "ExportNamedDeclaration":
+          case "ExportDefaultDeclaration":
+          case "ExportAllDeclaration":
+            this.handleExportDeclaration(node, fileNode, content);
+            break;
+          case "ClassDeclaration":
+          case "ClassExpression":
+            this.handleClassDeclaration(node, fileNode);
+            break;
+          case "FunctionDeclaration":
+            if (node.id) fileNode.symbolTable.set(node.id.name, { type: 'function', start: node.start });
+            break;
+          case "VariableDeclaration":
+            node.declarations.forEach(d => {
+                this._extractNamesFromPattern(d.id, name => {
+                    fileNode.symbolTable.set(name, { type: 'variable', start: d.start });
+                });
+            });
+            break;
+          case "AssignmentExpression":
+            // UPGRADE: CommonJS module.exports / exports detection
+            this.handleAssignmentExpression(node, fileNode);
+            break;
+          case "CallExpression":
+            // UPGRADE: CommonJS require() detection in Pass 1
+            this.handleCallExpressionPass1(node, fileNode);
+            break;
+        }
+    } else if (pass === 2) {
+        switch (node.type) {
+          case "CallExpression":
+            // UPGRADE: Enhanced CallExpression handling for both ESM and CommonJS
+            this.handleCallExpression(node, fileNode);
+            // Detect eval() usage
+            if (node.callee.type === "Identifier" && node.callee.name === "eval") {
+              fileNode.hasEvalUsage = true;
+            }
+            break;
+          case "MemberExpression":
+            this.handleMemberExpression(node, fileNode);
+            break;
+          case "JSXElement":
+          case "JSXFragment":
+            this.handleJsxElement(node, fileNode);
+            break;
+          case "Decorator":
+            this.handleDecorator(node, fileNode);
+            break;
+          case "StringLiteral":
+            fileNode.rawStringReferences.add(node.value);
+            break;
+          case "Identifier":
+            // Track all identifier usages for fuzzy matching
+            if (!this._isDefinition(node)) {
+                fileNode.instantiatedIdentifiers.add(node.name);
+            }
+            break;
+        }
     }
 
     for (const key in node) {
       if (node[key] && typeof node[key] === "object") {
         if (Array.isArray(node[key])) {
-          node[key].forEach((child) => this.walkOxcAst(child, fileNode, content));
+          node[key].forEach((child) => this.walkOxcAst(child, fileNode, content, pass));
         } else {
-          this.walkOxcAst(node[key], fileNode, content);
+          this.walkOxcAst(node[key], fileNode, content, pass);
         }
       }
     }
   }
 
+  _isDefinition(node) {
+      // Helper to distinguish between usage and definition of an identifier
+      const parent = node.parent; // Note: OXC might not provide parent pointers by default in JSON
+      return false; // Conservative: treat everything as potential usage in pass 2
+  }
+
   handleImportDeclaration(node, fileNode) {
     if (!node.source || typeof node.source.value !== 'string') return;
     const specifier = node.source.value;
@@ -224,223 +221,288 @@ let parsedResult;
     if (node.specifiers) {
       node.specifiers.forEach((spec) => {
         if (spec.type === "ImportSpecifier") {
-          // In OXC, imported name can be in .imported.name or .imported.value
-          const importedName = spec.imported.name || spec.imported.value || (spec.imported.type === "Identifier" ? spec.imported.name : null);
-          if (importedName) {
-            fileNode.importedSymbols.add(`${specifier}:${importedName}`);
-          }
+          const importedName = spec.imported.name || (spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value);
+          fileNode.importedSymbols.add(`${specifier}:${importedName}`);
+          fileNode.symbolTable.set(spec.local.name, { type: 'import', source: specifier, originalName: importedName });
         } else if (spec.type === "ImportDefaultSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:default`);
+          fileNode.symbolTable.set(spec.local.name, { type: 'import', source: specifier, originalName: 'default' });
         } else if (spec.type === "ImportNamespaceSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:*`);
+          fileNode.symbolTable.set(spec.local.name, { type: 'import', source: specifier, originalName: '*' });
         }
       });
     }
   }
 
+  handleImportExpression(node, fileNode) {
+    if (!node.source) return;
+    
+    if (node.source.type === "StringLiteral") {
+      const specifier = node.source.value;
+      fileNode.explicitImports.add(specifier);
+      fileNode.dynamicImports.add(specifier);
+      fileNode.importedSymbols.add(`${specifier}:*`);
+      
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
+    } else if (node.source.type === "TemplateLiteral") {
+      // Conservative Dynamic Analysis: Treat template literal imports as "potentially anything"
+      const quasis = node.source.quasis.map(q => q.value.cooked).join('*');
+      if (!Array.isArray(fileNode.calculatedDynamicImports)) {
+        fileNode.calculatedDynamicImports = [];
+      }
+      fileNode.calculatedDynamicImports.push({ 
+          kind: 'TemplateLiteral', 
+          pattern: quasis,
+          start: node.source.start 
+      });
+      // If we can't resolve it, we must assume it might import anything in that directory
+      fileNode.dynamicImports.add('__DYNAMIC_PATTERN__:' + quasis);
+      fileNode.dynamicImports.add('__DYNAMIC_PATTERN__');
+    }
+  }
+
+  handleClassDeclaration(node, fileNode) {
+      if (!node.id) return;
+      const className = node.id.name;
+      const members = [];
+      
+      if (node.body && node.body.body) {
+          node.body.body.forEach(member => {
+              if (member.type === "MethodDefinition" || member.type === "PropertyDefinition") {
+                  if (member.key && member.key.type === "Identifier") {
+                      const memberName = member.key.name;
+                      members.push({
+                          name: memberName,
+                          start: member.key.start,
+                          end: member.key.end,
+                          isPublic: member.accessibility !== 'private' && !memberName.startsWith('_')
+                      });
+                      // Track member name for usage detection
+                      fileNode.instantiatedIdentifiers.add(memberName);
+                  }
+              }
+          });
+      }
+      
+      fileNode.internalExports.set(className, { type: 'class', members, start: node.start });
+      fileNode.symbolTable.set(className, { type: 'class', members, start: node.start });
+  }
+
   handleExportDeclaration(node, fileNode, content) {
-    // 1. Default Exports
     if (node.type === "ExportDefaultDeclaration") {
-      fileNode.internalExports.set("default", { 
-        type: "default", 
-        start: node.start, 
-        end: node.end 
-      });
+      fileNode.internalExports.set("default", { type: "default", start: node.start, end: node.end });
       return;
     }
 
-    // 2. Re-export All: export * from 'mod' or export * as ns from 'mod'
     if (node.type === "ExportAllDeclaration") {
       const sourceSpecifier = node.source.value;
       fileNode.explicitImports.add(sourceSpecifier);
-      if (!sourceSpecifier.startsWith('.') && !sourceSpecifier.startsWith('/')) {
-        fileNode.externalPackageUsage.add(this._extractPackageName(sourceSpecifier));
-      }
-
       if (node.exported) {
-        // export * as ns from 'mod'
         const name = node.exported.name || (node.exported.type === "Identifier" ? node.exported.name : null);
         if (name) {
-          fileNode.internalExports.set(name, { 
-            type: "re-export-namespace", 
-            source: sourceSpecifier, 
-            originalName: "*", 
-            start: node.start, 
-            end: node.end 
-          });
-          fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
+          fileNode.internalExports.set(name, { type: "re-export-namespace", source: sourceSpecifier, originalName: "*", start: node.start });
         }
       } else {
-        // export * from 'mod'
-        fileNode.internalExports.set("*", { 
-          type: "re-export-all", 
-          source: sourceSpecifier 
-        });
-        fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
+        fileNode.internalExports.set("*", { type: "re-export-all", source: sourceSpecifier });
       }
       return;
     }
 
-    // 3. Named Exports & Re-exports with specifiers
     if (node.source) {
-      // Re-export: export { x } from 'mod'
       const specifier = node.source.value;
       fileNode.explicitImports.add(specifier);
-      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
-        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
-      }
-
       if (node.specifiers) {
         node.specifiers.forEach((spec) => {
           const exportedName = spec.exported.name || (spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value);
           const localName = spec.local.name || (spec.local.type === "Identifier" ? spec.local.name : spec.local.value);
-          fileNode.internalExports.set(exportedName, {
-            type: "re-export",
-            source: specifier,
-            originalName: localName,
-            start: spec.start,
-            end: spec.end,
-          });
-          fileNode.importedSymbols.add(`${specifier}:${localName}`);
+          fileNode.internalExports.set(exportedName, { type: "re-export", source: specifier, originalName: localName, start: spec.start });
         });
       }
     } else if (node.declaration) {
-      // Direct declaration export: export const x = 1, export function f() {}
       const decl = node.declaration;
       if (decl.type === "VariableDeclaration") {
         decl.declarations.forEach((d) => {
           this._extractNamesFromPattern(d.id, (name) => {
-            fileNode.internalExports.set(name, { 
-              type: "variable", 
-              start: d.start, 
-              end: d.end 
-            });
+            fileNode.internalExports.set(name, { type: "variable", start: d.start });
           });
         });
       } else if (decl.id && decl.id.name) {
-        let type = "unknown";
-        if (decl.type === "FunctionDeclaration") type = "function";
-        else if (decl.type === "ClassDeclaration") type = "class";
-        else if (decl.type === "TSEnumDeclaration") type = "enum";
-        else if (decl.type === "TSInterfaceDeclaration") type = "interface";
-        else if (decl.type === "TSTypeAliasDeclaration") type = "type";
-        else if (decl.type === "TSModuleDeclaration") type = "namespace";
-
-        fileNode.internalExports.set(decl.id.name, { 
-          type, 
-          start: decl.start, 
-          end: decl.end 
-        });
+        this.handleClassDeclaration(decl, fileNode);
       }
-    } else if (node.specifiers) {
-      // Export existing locals: export { x, y as z }
-      node.specifiers.forEach((spec) => {
-        const exportedName = spec.exported.name || (spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value);
-        const localName = spec.local.name || (spec.local.type === "Identifier" ? spec.local.name : spec.local.value);
-        fileNode.internalExports.set(exportedName, {
-          type: "export",
-          originalName: localName,
-          start: spec.start,
-          end: spec.end,
-        });
-      });
     }
   }
 
-  _extractNamesFromPattern(node, callback) {
-    if (!node) return;
-    if (node.type === "Identifier") {
-      callback(node.name);
-    } else if (node.type === "ObjectPattern") {
-      node.properties.forEach(p => {
-        if (p.type === "Property") {
-          this._extractNamesFromPattern(p.value, callback);
-        } else if (p.type === "RestElement") {
-          this._extractNamesFromPattern(p.argument, callback);
+  handleCallExpression(node, fileNode) {
+    // Call Graph Hint: Track what is being called
+    if (node.callee.type === "Identifier") {
+        fileNode.instantiatedIdentifiers.add(node.callee.name);
+    } else if (node.callee.type === "MemberExpression") {
+        this.handleMemberExpression(node.callee, fileNode);
+    }
+    
+    // Enterprise: Execute registered call graph visitors
+    if (this.context.callGraphVisitors) {
+        for (const visitor of this.context.callGraphVisitors) {
+            visitor(node, fileNode, this.context);
         }
-      });
-    } else if (node.type === "ArrayPattern") {
-      node.elements.forEach(e => {
-        if (e) this._extractNamesFromPattern(e, callback);
-      });
-    } else if (node.type === "AssignmentPattern") {
-      this._extractNamesFromPattern(node.left, callback);
-    } else if (node.type === "RestElement") {
-      this._extractNamesFromPattern(node.argument, callback);
     }
   }
 
-  handleCallExpression(node, fileNode) {
-    // Dynamic import(): import('./module')
-    if (node.callee.type === "Import" && node.arguments.length > 0) {
-      const arg = node.arguments[0];
-      if (arg.type === "StringLiteral") {
-        const specifier = arg.value;
-        fileNode.explicitImports.add(specifier);
-        fileNode.dynamicImports.add(specifier);
-        fileNode.importedSymbols.add(`${specifier}:*`); // Dynamic import usually consumes the whole namespace
-        if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
-          fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+  handleMemberExpression(node, fileNode) {
+    const getBaseName = (expr) => {
+        if (expr.type === "Identifier") return expr.name;
+        if (expr.type === "MemberExpression") return getBaseName(expr.object);
+        if (expr.type === "ThisExpression") return "this";
+        return null;
+    };
+    
+    const getPropName = (expr) => {
+        if (expr.type === "Identifier") return expr.name;
+        if (expr.type === "StringLiteral") return expr.value;
+        return null;
+    };
+
+    const objName = getBaseName(node.object);
+    const propName = getPropName(node.property);
+    
+    if (propName) {
+        fileNode.instantiatedIdentifiers.add(propName);
+        if (objName) {
+            fileNode.propertyAccessChains.add(`${objName}.${propName}`);
+            fileNode.instantiatedIdentifiers.add(objName);
         }
-      } else {
-        if (fileNode.calculatedDynamicImports) {
-          fileNode.calculatedDynamicImports.push({ kind: arg.type, start: arg.start });
+    } else {
+        // Dynamic access: obj[key]
+        // Conservative: if we see dynamic access on an object, we mark all its members as potentially used
+        if (objName) {
+            fileNode.propertyAccessChains.add(`${objName}.*`);
         }
-      }
-    } else if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length > 0 && node.arguments[0].type === "StringLiteral") {
-      const specifier = node.arguments[0].value;
-      fileNode.explicitImports.add(specifier);
-      fileNode.importedSymbols.add(`${specifier}:*`);
-      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
-        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
-      }
     }
   }
 
   handleJsxElement(node, fileNode) {
-    const getElementName = (nameNode) => {
-      if (nameNode.type === "JSXIdentifier") return nameNode.name;
-      if (nameNode.type === "JSXMemberExpression") return `${getElementName(nameNode.object)}.${nameNode.property.name}`;
-      if (nameNode.type === "JSXNamespacedName") return `${nameNode.namespace.name}:${nameNode.name.name}`;
-      return "unknown";
-    };
-
-    if (node.openingElement) {
-      const tagName = getElementName(node.openingElement.name);
-      fileNode.jsxComponents.add(tagName);
-
-      if (node.openingElement.attributes) {
-        node.openingElement.attributes.forEach(attr => {
-          if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
-            fileNode.jsxProps.add(`${tagName}:${attr.name.name}`);
-          }
-        });
-      }
+    if (node.openingElement && node.openingElement.name.type === "JSXIdentifier") {
+        fileNode.jsxComponents.add(node.openingElement.name.name);
     }
   }
 
   handleDecorator(node, fileNode) {
-    const getDecoratorName = (expr) => {
-      if (expr.type === "Identifier") return expr.name;
-      if (expr.type === "CallExpression") return getDecoratorName(expr.callee);
-      if (expr.type === "MemberExpression") {
-        const prop = expr.property.name || expr.property.value;
-        return prop || "unknown";
+      if (node.expression && node.expression.type === "Identifier") {
+          fileNode.decorators.add(node.expression.name);
       }
-      return "unknown";
-    };
+  }
 
-    const decoratorName = getDecoratorName(node.expression);
-    if (decoratorName !== "unknown") {
-      fileNode.decorators.add(decoratorName);
+  _extractNamesFromPattern(node, callback) {
+    if (!node) return;
+    if (node.type === "Identifier") {
+      callback(node.name);
+    } else if (node.type === "ObjectPattern") {
+      node.properties.forEach(p => this._extractNamesFromPattern(p.value || p.argument, callback));
+    } else if (node.type === "ArrayPattern") {
+      node.elements.forEach(e => e && this._extractNamesFromPattern(e, callback));
     }
   }
 
   _extractPackageName(specifier) {
     if (specifier.startsWith('@')) {
-      const parts = specifier.split('/');
-      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+      return specifier.split('/').slice(0, 2).join('/');
     }
     return specifier.split('/')[0];
   }
-}
+
+  // UPGRADE: CommonJS require() detection
+  handleCallExpressionPass1(node, fileNode) {
+    if (this.context.verbose) console.log(`[OXC-DEBUG] Checking CallExpression: ${node.callee.name || 'anonymous'}`);
+    if (node.callee.type === "Identifier" && node.callee.name === "require") {
+      if (this.context.verbose) console.log(`[OXC-DEBUG] Found require() call in ${fileNode.filePath}`);
+      if (node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.type === "StringLiteral") {
+          const specifier = arg.value;
+          fileNode.explicitImports.add(specifier);
+          fileNode.importedSymbols.add(`${specifier}:*`);
+          
+          if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+            fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+          }
+        } else if (arg.type === "TemplateLiteral") {
+          // Behandlung dynamischer requires
+          this.handleDynamicRequire(arg, fileNode);
+        }
+      }
+    }
+  }
+
+  // UPGRADE: Dynamic require() with template literals
+  handleDynamicRequire(node, fileNode) {
+    if (node.type === "TemplateLiteral") {
+      const quasis = node.quasis.map(q => q.value.cooked).join('*');
+      if (!Array.isArray(fileNode.calculatedDynamicImports)) {
+        fileNode.calculatedDynamicImports = [];
+      }
+      fileNode.calculatedDynamicImports.push({
+        kind: 'DynamicRequire',
+        pattern: quasis,
+        start: node.start
+      });
+      fileNode.dynamicImports.add('__DYNAMIC_PATTERN__:' + quasis);
+      fileNode.dynamicImports.add('__DYNAMIC_PATTERN__');
+    }
+  }
+
+  // UPGRADE: CommonJS module.exports / exports detection
+  handleAssignmentExpression(node, fileNode) {
+    if (this.context.verbose) console.log(`[OXC-DEBUG] Checking AssignmentExpression in ${fileNode.filePath}`);
+    if (node.left.type === "MemberExpression") {
+      const left = node.left;
+      
+      // module.exports = ...
+      if (left.object.type === "Identifier" && left.object.name === "module" &&
+          left.property.type === "Identifier" && left.property.name === "exports") {
+        
+        fileNode.internalExports.set("default", { type: "default", start: node.start, end: node.end });
+        
+        // UPGRADE: Handle module.exports = { a, b }
+        if (node.right.type === "ObjectExpression") {
+          node.right.properties.forEach(prop => {
+            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
+              fileNode.internalExports.set(prop.key.name, { type: "variable", start: prop.start, end: prop.end });
+            }
+          });
+        }
+      }
+      // exports.name = ...
+      else if (left.object.type === "Identifier" && left.object.name === "exports" &&
+               left.property.type === "Identifier") {
+        fileNode.internalExports.set(left.property.name, { type: "variable", start: node.start, end: node.end });
+      }
+      // module.exports.name = ...
+      else if (left.object.type === "MemberExpression" && 
+               left.object.object.type === "Identifier" && left.object.object.name === "module" &&
+               left.object.property.type === "Identifier" && left.object.property.name === "exports" &&
+               left.property.type === "Identifier") {
+        fileNode.internalExports.set(left.property.name, { type: "variable", start: node.start, end: node.end });
+      }
+    }
+  }
+
+  // UPGRADE: Improved _isDefinition with parent context awareness
+  _isDefinition(node, parent = null) {
+    if (!parent) return false;
+    
+    // Check if this identifier is being defined (left side of assignment, function parameter, etc.)
+    if (parent.type === "VariableDeclarator" && parent.id === node) return true;
+    if (parent.type === "FunctionDeclaration" && parent.id === node) return true;
+    if (parent.type === "ClassDeclaration" && parent.id === node) return true;
+    if (parent.type === "ImportSpecifier" && parent.local === node) return true;
+    if (parent.type === "ImportDefaultSpecifier" && parent.local === node) return true;
+    if (parent.type === "ImportNamespaceSpecifier" && parent.local === node) return true;
+    if (parent.type === "ExportSpecifier" && parent.local === node) return true;
+    if (parent.type === "AssignmentExpression" && parent.left === node) return true;
+    
+    return false;
+  }
+}