entkapp 4.5.1 → 5.1.0

package/src/ast/AdvancedAnalysis.js

@@ -112,6 +112,7 @@ export class AdvancedAnalysis {
    * Package.json Export Reachability
    */
   analyzeExportReachability(projectGraph, packageManifests) {
+    if (!packageManifests) return;
     for (const [pkgName, metadata] of packageManifests.entries()) {
       const publicEntries = new Set(metadata.entryPoints);
       
@@ -557,13 +558,13 @@ export class AdvancedAnalysis {
         this.analyzeDataIntegrity(filePath, node.ast);
         this.analyzeEventLeaks(filePath, node.ast);
         this.analyzeBinaryShaking(filePath, node.ast);
+        this.analyzeDereferences(filePath, node.ast);
+        this.analyzeClones(filePath, node.ast);
+        this.analyzeEscapes(filePath, node.ast);
+        this.analyzeLoops(filePath, node.ast);
+        this.analyzeConfigSanity(filePath, node.ast);
       }
       this.analyzeSandboxing(filePath, projectGraph);
-      this.analyzeDereferences(filePath, node.ast);
-      this.analyzeClones(filePath, node.ast);
-      this.analyzeEscapes(filePath, node.ast);
-      this.analyzeLoops(filePath, node.ast);
-      this.analyzeConfigSanity(filePath, node.ast);
     }
     this.analyzeExportReachability(projectGraph, packageManifests);
     

package/src/ast/BarrelParser.js

@@ -7,7 +7,7 @@ import fs from 'fs/promises';
  */
 export class BarrelParser {
   constructor(context, resolver) {
-    this.context = context;
+    this.context = context; // Enthält globale Konfigurationen (z.B. context.entrypoints)
     this.resolver = resolver;
     this.cachedSpecifications = new Map();
   }
@@ -23,28 +23,43 @@ export class BarrelParser {
 
     const specification = {
       isBarrelInstance: false,
+      isApplicationEntrypoint: false,     // FIX: Schutzschicht für Einstiegspunkte gegen Fehldetektion
       wildcardExports: new Set(),         // export * from './module';
       namespacedWildcardExports: new Map(), // export * as Utils from './module';
       forwardedNamedExports: new Map(),   // export { token as alias } from './module';
       declaredLocalExports: new Set()      // export const a = 1;
     };
 
+    // FIX: Überprüfe, ob die aktuelle Datei als App-Einstiegspunkt deklariert ist
+    if (this.context && this.context.entrypoints) {
+      const isEntry = this.context.entrypoints.some(entry => 
+        this.resolver.resolveModulePath(filePath, entry) === filePath || entry === filePath
+      );
+      if (isEntry) {
+        specification.isApplicationEntrypoint = true;
+      }
+    }
+
     try {
       const code = await fs.readFile(filePath, 'utf8');
       const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
 
       this.harvestExportSignatures(sourceFile, specification);
 
-      if (specification.wildcardExports.size > 0 || 
+      // FIX: Eine Datei ist NUR DANN ein rein kosmetisches Barrel, wenn sie Re-Exports besitzt
+      // UND NICHT der geschützte Haupteinstiegspunkt (Entrypoint) der Anwendung ist!
+      if (!specification.isApplicationEntrypoint && (
+          specification.wildcardExports.size > 0 || 
           specification.namespacedWildcardExports.size > 0 || 
-          specification.forwardedNamedExports.size > 0) {
+          specification.forwardedNamedExports.size > 0
+      )) {
         specification.isBarrelInstance = true;
       }
 
       this.cachedSpecifications.set(filePath, specification);
       return specification;
     } catch {
-      return specification; // Error state defaults to safe boundaries layout manifest
+      return specification; // Error-State fällt auf sicheres Standard-Layout zurück
     }
   }
 
@@ -117,14 +132,7 @@ export class BarrelParser {
         break;
       }
 
-      // Track default exports declared directly within the file boundary:
-      // Handles both `export default function foo()` and `export default expression`.
-      // The canonical symbol name stored is 'default' so that forwardedNamedExports
-      // entries whose sourceSymbol is 'default' can resolve correctly via Rule A.
       case ts.SyntaxKind.ExportAssignment: {
-        // ExportAssignment covers `export default <expr>` (isExportEquals === false)
-        // as well as `export = <expr>` (isExportEquals === true, CommonJS style).
-        // We register 'default' for both to ensure the barrel tracer can settle here.
         spec.declaredLocalExports.add('default');
         break;
       }
@@ -156,7 +164,7 @@ export class BarrelParser {
       return { originFile: contextFilePath, originSymbol: targetSymbolName };
     }
 
-    // Rule B: Evaluate explicit named re-export mappings
+    // Rule B: Evaluate explicit named re-export mappings (export { A as B } from 'module')
     if (spec.forwardedNamedExports.has(targetSymbolName)) {
       const routingRule = spec.forwardedNamedExports.get(targetSymbolName);
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, routingRule.targetModule);
@@ -167,7 +175,10 @@ export class BarrelParser {
 
     // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
     for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
-      // If the targetSymbolName is prefixed with the namespaceAlias, then it's a member of this namespace re-export
+      if (targetSymbolName === namespaceAlias) {
+          const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
+          return { originFile: fullyResolvedPath, originSymbol: '*' };
+      }
       if (targetSymbolName.startsWith(`${namespaceAlias}.`)) {
         const originalSymbol = targetSymbolName.substring(namespaceAlias.length + 1);
         const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
@@ -178,38 +189,36 @@ export class BarrelParser {
     }
 
     // Rule D: Sweep through anonymous star re-exports vectors (export * from 'module')
-    //
-    // Algorithm:
-    // 1. For each `export * from './child'`, recursively resolve the symbol in the child.
-    // 2. A non-barrel child immediately returns `{ originFile: childPath }` regardless of
-    //    whether it actually declares the symbol.  We therefore must verify that the
-    //    returned origin file actually contains the symbol in its declaredLocalExports
-    //    before accepting the result.
-    // 3. If the child is itself a barrel, the recursive call already performs the full
-    //    chain walk, so we only need to verify the final origin.
     for (const relativePath of spec.wildcardExports) {
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
       
       if (fullyResolvedPath) {
+        // Verbinde Graph-Kanten direkt während der Wildcard-Traversierung
+        const contextNode = activeProjectGraph.get(contextFilePath);
+        if (contextNode) {
+          contextNode.outgoingEdges.add(fullyResolvedPath);
+          const targetNode = activeProjectGraph.get(fullyResolvedPath);
+          if (targetNode) {
+            targetNode.incomingEdges.add(contextFilePath);
+          }
+        }
+
         const continuousResolutionTrace = await this.determineSymbolDeclarationOrigin(
           fullyResolvedPath,
           targetSymbolName,
           activeProjectGraph,
-          new Set(protectionStack) // Use a copy so sibling branches don't block each other
+          new Set(protectionStack) // Kopie verhindert geschwisterliche Branch-Blockaden
         );
 
         if (!continuousResolutionTrace) continue;
         if (continuousResolutionTrace.originFile === contextFilePath) continue;
 
-        // Verify that the resolved origin actually declares the symbol.
-        // This prevents a non-barrel sibling (e.g. constants.ts) from being
-        // incorrectly returned for a symbol it does not export (e.g. formatData).
         const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
-        if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol)) {
+        if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol) || 
+            continuousResolutionTrace.originSymbol === '*') {
           return continuousResolutionTrace;
         }
-        // The origin spec is itself a barrel (isBarrelInstance = true) and the
-        // recursive call already resolved through it – accept the result.
+
         if (originSpec.isBarrelInstance) {
           return continuousResolutionTrace;
         }
@@ -218,4 +227,4 @@ export class BarrelParser {
 
     return { originFile: contextFilePath, originSymbol: targetSymbolName };
   }
-}
+}

package/src/ast/DeadCodeDetector.js

@@ -10,26 +10,32 @@ export class DeadCodeDetector {
     // Find all entry points
     const entryPoints = new Set();
     for (const [filePath, node] of graph.entries()) {
-      if (node.isEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
+      // NIGHTMARE FIX: node.isEntry must be respected, and also check for library entries
+      if (node.isEntry || node.isLibraryEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
         entryPoints.add(filePath);
       }
     }
 
-    // Traverse from entry points to find used files
+    // UPGRADE 5: Cycle-tolerant Graph Traversal.
+    // We use a robust recursive traversal with a visited set to handle cycles.
     const usedFiles = new Set();
-    const queue = Array.from(entryPoints);
-    
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (!usedFiles.has(current)) {
-        usedFiles.add(current);
-        const node = graph.get(current);
-        if (node && node.outgoingEdges) {
-          for (const edge of node.outgoingEdges) {
-            queue.push(edge);
-          }
+    const visited = new Set();
+
+    const traverse = (filePath) => {
+      if (visited.has(filePath)) return;
+      visited.add(filePath);
+      usedFiles.add(filePath);
+
+      const node = graph.get(filePath);
+      if (node && node.outgoingEdges) {
+        for (const edge of node.outgoingEdges) {
+          traverse(edge);
         }
       }
+    };
+
+    for (const entry of entryPoints) {
+      traverse(entry);
     }
 
     // Identify dead files
@@ -45,25 +51,31 @@ export class DeadCodeDetector {
       if (!node) continue;
       
       // If it's an entry point, we consider its exports used (unless strictly configured otherwise)
-      if (node.isEntry) continue;
+      // NIGHTMARE FIX: Even in entry points, we might want to find unused exports if they are not re-exported
+      if (node.isEntry && !node.isLibraryEntry) {
+          // If it's a main entry but not a library, its exports are usually unused 
+          // unless it's a barrel file. Let's proceed to check usage.
+      } else if (node.isLibraryEntry) {
+          continue;
+      }
 
       for (const [exportName, exportInfo] of node.internalExports.entries()) {
         if (exportName === '*' || exportName === 'default') continue; // Skip wildcards for now
         
         let isUsed = false;
-        // Check incoming edges if they import this specific symbol
+        // Check ALL nodes in the graph for usage of this symbol, not just those with edges
+        // (Handles cases where edges might be missing or complex)
         for (const [otherPath, otherNode] of graph.entries()) {
-          if (otherNode.outgoingEdges.has(filePath)) {
             if (otherNode.importedSymbols.has(`${filePath}:${exportName}`) || 
                 otherNode.importedSymbols.has(`${filePath}:*`)) {
               isUsed = true;
               break;
             }
-          }
         }
 
         // Additional check for library entries or index files
-        if (!isUsed && (node.isLibraryEntry || filePath.toLowerCase().includes('index'))) {
+        // NIGHTMARE FIX: Don't blindly protect 'index' files if they are not real entries
+        if (!isUsed && (node.isLibraryEntry)) {
           isUsed = true;
         }
 

package/src/ast/MagicDetector.js

@@ -177,7 +177,7 @@ export class MagicDetector {
     if (!await this.isImplicitlyRequiredByEcosystem(filePath, activeFrameworks)) return;
 
     // Retain entry point elements within memory to keep verification safe
-    fileNode.isLibraryEntry = true;
+    fileNode.isEntry = true;
 
     // Apply dynamic exports coverage metrics based on active platform contracts
     const normalizedPath = filePath.replace(/\\/g, '/');