entkapp 4.5.0 → 5.0.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

@@ -140,6 +140,10 @@ export class BarrelParser {
    * @param {Map} activeProjectGraph - Global active module maps directory registry
    * @param {Set} [protectionStack] - Avoids cyclic validation traps inside self-referencing links
    */
+  /**
+   * UPGRADE 3: Cross-Barrel Symbol Tracking.
+   * Resolves the original source of a symbol through re-exports and aliases.
+   */
   async determineSymbolDeclarationOrigin(contextFilePath, targetSymbolName, activeProjectGraph, protectionStack = new Set()) {
     if (protectionStack.has(contextFilePath)) {
       return { originFile: contextFilePath, originSymbol: targetSymbolName };
@@ -156,7 +160,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 +171,11 @@ 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) {
+          // The symbol IS the namespace itself
+          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,19 +186,20 @@ 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) {
+        // FIX: Mark the target module as active immediately when export * is found
+        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,
@@ -202,14 +211,12 @@ export class BarrelParser {
         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;
         }

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, '/');