entkapp 5.4.0 → 5.6.0

package/src/ast/BarrelParser.mjs

@@ -0,0 +1,230 @@
+import ts from 'typescript';
+import fs from 'fs/promises';
+
+/**
+ * Enterprise Wildcard Optimization & Flattening Layer for Barrel Operations
+ * Traces unreferenced paths through redistribution entries.
+ */
+export class BarrelParser {
+  constructor(context, resolver) {
+    this.context = context; // Enthält globale Konfigurationen (z.B. context.entrypoints)
+    this.resolver = resolver;
+    this.cachedSpecifications = new Map();
+  }
+
+  /**
+   * Compiles the structural export layout for a specific index or barrel target.
+   * @param {string} filePath - Absolute path to on-disk target element
+   */
+  async parseBarrelSpecification(filePath) {
+    if (this.cachedSpecifications.has(filePath)) {
+      return this.cachedSpecifications.get(filePath);
+    }
+
+    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);
+
+      // 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.isBarrelInstance = true;
+      }
+
+      this.cachedSpecifications.set(filePath, specification);
+      return specification;
+    } catch {
+      return specification; // Error-State fällt auf sicheres Standard-Layout zurück
+    }
+  }
+
+  harvestExportSignatures(node, spec) {
+    if (!node) return;
+
+    switch (node.kind) {
+      case ts.SyntaxKind.ExportDeclaration: {
+        const targetSpecifier = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)
+          ? node.moduleSpecifier.text
+          : null;
+
+        if (targetSpecifier) {
+          if (!node.exportClause) {
+            // Standard Wildcard Transfer: export * from './module';
+            spec.wildcardExports.add(targetSpecifier);
+          } else if (ts.isNamespaceExport(node.exportClause)) {
+            // Namespaced Wildcard Transfer: export * as Core from './module';
+            const namespaceAlias = node.exportClause.name.text;
+            spec.namespacedWildcardExports.set(namespaceAlias, targetSpecifier);
+          } else if (ts.isNamedExports(node.exportClause)) {
+            // Selective Re-export Forwarding: export { x, y as z } from './module';
+            node.exportClause.elements.forEach(element => {
+              const originalSymbol = element.propertyName ? element.propertyName.text : element.name.text;
+              const exposedAlias = element.name.text;
+              spec.forwardedNamedExports.set(exposedAlias, {
+                targetModule: targetSpecifier,
+                sourceSymbol: originalSymbol
+              });
+            });
+          }
+        }
+        break;
+      }
+
+      // Track items declared directly within the file boundary
+      case ts.SyntaxKind.FunctionDeclaration:
+      case ts.SyntaxKind.ClassDeclaration:
+      case ts.SyntaxKind.InterfaceDeclaration:
+      case ts.SyntaxKind.TypeAliasDeclaration:
+      case ts.SyntaxKind.EnumDeclaration: {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          if (node.name && ts.isIdentifier(node.name)) {
+            spec.declaredLocalExports.add(node.name.text);
+          }
+        }
+        break;
+      }
+
+      case ts.SyntaxKind.VariableStatement: {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          node.declarationList.declarations.forEach(decl => {
+            if (ts.isIdentifier(decl.name)) {
+              spec.declaredLocalExports.add(decl.name.text);
+            } else if (ts.isObjectBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
+            } else if (ts.isArrayBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
+            }
+          });
+        }
+        break;
+      }
+
+      case ts.SyntaxKind.ExportAssignment: {
+        spec.declaredLocalExports.add('default');
+        break;
+      }
+    }
+
+    ts.forEachChild(node, child => this.harvestExportSignatures(child, spec));
+  }
+
+  /**
+   * Challenge #3 Resolution Logic. Unwraps nested redistribution links to find origin source nodes.
+   * @param {string} contextFilePath - Current position filename vector pointer
+   * @param {string} targetSymbolName - Targeted semantic variable signature name
+   * @param {Map} activeProjectGraph - Global active module maps directory registry
+   * @param {Set} [protectionStack] - Avoids cyclic validation traps inside self-referencing links
+   */
+  async determineSymbolDeclarationOrigin(contextFilePath, targetSymbolName, activeProjectGraph, protectionStack = new Set()) {
+    if (protectionStack.has(contextFilePath)) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+    protectionStack.add(contextFilePath);
+
+    const spec = await this.parseBarrelSpecification(contextFilePath);
+    if (!spec.isBarrelInstance) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+
+    // Rule A: Settle boundary immediately if local declaration matches token signature name
+    if (spec.declaredLocalExports.has(targetSymbolName)) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+
+    // 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);
+      if (fullyResolvedPath) {
+        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      }
+    }
+
+    // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
+    for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
+      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);
+        if (fullyResolvedPath) {
+          return this.determineSymbolDeclarationOrigin(fullyResolvedPath, originalSymbol, activeProjectGraph, protectionStack);
+        }
+      }
+    }
+
+    // Rule D: Sweep through anonymous star re-exports vectors (export * from 'module')
+    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) // Kopie verhindert geschwisterliche Branch-Blockaden
+        );
+
+        if (!continuousResolutionTrace) continue;
+        if (continuousResolutionTrace.originFile === contextFilePath) continue;
+
+        const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
+        if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol) || 
+            continuousResolutionTrace.originSymbol === '*') {
+          return continuousResolutionTrace;
+        }
+
+        if (originSpec.isBarrelInstance) {
+          return continuousResolutionTrace;
+        }
+      }
+    }
+
+    return { originFile: contextFilePath, originSymbol: targetSymbolName };
+  }
+}

package/src/ast/DeadCodeDetector.js

@@ -10,8 +10,10 @@ export class DeadCodeDetector {
     // Find all entry points
     const entryPoints = new Set();
     for (const [filePath, node] of graph.entries()) {
-      // NIGHTMARE FIX: node.isEntry must be respected, and also check for library entries
-      if (node.isEntry || node.isLibraryEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
+      // ADVANCED: Framework-agnostic entry point detection
+      // Respects explicit entries, side-effect files, and dynamic entry points
+      if (node.isEntry || node.isLibraryEntry || node.isDynamicEntry || node.hasSideEffects || 
+          node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
         entryPoints.add(filePath);
       }
     }
@@ -63,11 +65,11 @@ export class DeadCodeDetector {
         if (exportName === '*' || exportName === 'default') continue; // Skip wildcards for now
         
         let isUsed = false;
-        // 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)
+        // ADVANCED: Global usage tracking including dynamic property access
         for (const [otherPath, otherNode] of graph.entries()) {
             if (otherNode.importedSymbols.has(`${filePath}:${exportName}`) || 
-                otherNode.importedSymbols.has(`${filePath}:*`)) {
+                otherNode.importedSymbols.has(`${filePath}:*`) ||
+                otherNode.instantiatedIdentifiers.has(exportName)) {
               isUsed = true;
               break;
             }

package/src/ast/DeadCodeDetector.mjs

@@ -0,0 +1,92 @@
+export class DeadCodeDetector {
+  constructor(context) {
+    this.context = context;
+  }
+
+  detectDeadCode(graph) {
+    const deadFiles = [];
+    const deadExports = [];
+    
+    // Find all entry points
+    const entryPoints = new Set();
+    for (const [filePath, node] of graph.entries()) {
+      // ADVANCED: Framework-agnostic entry point detection
+      // Respects explicit entries, side-effect files, and dynamic entry points
+      if (node.isEntry || node.isLibraryEntry || node.isDynamicEntry || node.hasSideEffects || 
+          node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
+        entryPoints.add(filePath);
+      }
+    }
+
+    // UPGRADE 5: Cycle-tolerant Graph Traversal.
+    // We use a robust recursive traversal with a visited set to handle cycles.
+    const usedFiles = new Set();
+    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
+    for (const filePath of graph.keys()) {
+      if (!usedFiles.has(filePath)) {
+        deadFiles.push(filePath);
+      }
+    }
+
+    // Identify dead exports in used files
+    for (const filePath of usedFiles) {
+      const node = graph.get(filePath);
+      if (!node) continue;
+      
+      // If it's an entry point, we consider its exports used (unless strictly configured otherwise)
+      // 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;
+        // ADVANCED: Global usage tracking including dynamic property access
+        for (const [otherPath, otherNode] of graph.entries()) {
+            if (otherNode.importedSymbols.has(`${filePath}:${exportName}`) || 
+                otherNode.importedSymbols.has(`${filePath}:*`) ||
+                otherNode.instantiatedIdentifiers.has(exportName)) {
+              isUsed = true;
+              break;
+            }
+        }
+
+        // Additional check for library entries or index files
+        // NIGHTMARE FIX: Don't blindly protect 'index' files if they are not real entries
+        if (!isUsed && (node.isLibraryEntry)) {
+          isUsed = true;
+        }
+
+        if (!isUsed) {
+          deadExports.push({ file: filePath, symbol: exportName, line: exportInfo.start });
+        }
+      }
+    }
+
+    return { deadFiles, deadExports };
+  }
+}

package/src/ast/MagicDetector.js

@@ -6,7 +6,15 @@ import { PluginRegistry } from '../plugins/PluginRegistry.js';
  * Ecosystem Entry Point Manifest & Dynamic Framework Router Heuristic Validator
  * Intercepts implicit conventions to handle cases where direct import statements are absent.
  * Now refactored to use a pluggable architecture.
- * Version 5.4.0: Added detectEntryPointsFromPlugins() for dynamic framework entry detection.
+ *
+ * Improvements over v1:
+ * - Extended config-file detection list (Biome, Oxlint, tsup, unbuild, etc.)
+ * - Next.js App Router conventions (page.tsx, layout.tsx, loading.tsx, error.tsx, etc.)
+ * - Remix conventions (route files under app/routes/)
+ * - SvelteKit conventions (+page.svelte, +layout.svelte, etc.)
+ * - Astro page/layout conventions
+ * - Common entry-point patterns (bin/, cli.ts, server.ts, main.ts, app.ts)
+ * - Test file patterns extended to cover Vitest workspace files
  */
 export class MagicDetector {
   constructor(context) {
@@ -23,26 +31,18 @@ export class MagicDetector {
 
   /**
    * Audits the project context to map active micro-framework ecosystems.
+   * @param {string} baseContextDirectory - Root file workspace context execution vector path
    */
   async identifyActiveProjectEcosystems(baseContextDirectory) {
     await this.ensureInitialized(baseContextDirectory);
     const activePlugins = await this.registry.getActivePlugins(baseContextDirectory);
     const activeFrameworkFlags = activePlugins.map(p => p.name);
+    
+    // Universal infrastructure overrides (testing platforms and common bundlers)
     activeFrameworkFlags.push('universal-tooling-vectors');
     return activeFrameworkFlags;
   }
 
-  /**
-   * Version 5.4.0: Delegates entry point detection to the plugin registry.
-   * @param {string} content - The file content
-   * @param {string} filePath - The absolute path to the file
-   * @returns {Array<string>} List of detected entry points
-   */
-  async detectEntryPointsFromPlugins(content, filePath) {
-    await this.ensureInitialized();
-    return this.registry.detectEntryPointsFromContent(content, filePath);
-  }
-
   /**
    * Assesses if a file path acts as an implicit route entry point.
    */
@@ -60,6 +60,7 @@ export class MagicDetector {
       }
     }
 
+    // Apply baseline platform rules (Test suites, lint parameters, continuous integration files)
     if (this.isCoreToolingSuiteElement(normalizedSystemPath)) {
       return true;
     }
@@ -67,46 +68,49 @@ export class MagicDetector {
     return false;
   }
 
-  /**
-   * Version 5.3.0: Delegates content analysis to the plugin registry.
-   */
-  async runPluginContentAnalysis(node, absolutePath) {
-    await this.ensureInitialized();
-    await this.registry.runPluginAnalysis(node, absolutePath);
-  }
-
   isCoreToolingSuiteElement(normalizedPath) {
+    // ── Test / spec files ──────────────────────────────────────────────────────
     if (/\.(test|spec|e2e|cy)\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
     if (/\.stories\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
 
+    // ── Build / bundler config files ───────────────────────────────────────────
     const configFragments = [
+      // Test runners
       'jest.config.', 'vitest.config.', 'vitest.workspace.',
       'playwright.config.', 'cypress.config.',
+      // Bundlers
       'webpack.config.', 'vite.config.', 'rollup.config.',
       'esbuild.config.', 'parcel.config.',
       'tsup.config.', 'unbuild.config.', 'pkgroll.config.',
+      // CSS / styling
       'tailwind.config.', 'postcss.config.', '.postcssrc.',
+      // Linters / formatters
       '.eslintrc.', 'eslint.config.', 'prettier.config.', '.prettierrc.',
       '.stylelintrc.', 'stylelint.config.',
       'biome.json', '.oxlintrc.',
+      // Babel / transpilation
       '.babelrc.', 'babel.config.',
+      // Commit / git hooks
       '.commitlintrc.', 'commitlint.config.',
       '.lintstagedrc.', 'lint-staged.config.',
+      // Documentation
       'typedoc.config.', 'typedoc.json',
+      // Monorepo tools
       'turbo.json', 'nx.json', 'lerna.json',
+      // Misc tooling
       'knip.config.', 'knip.json',
       'syncpack.config.',
+      // Internal worker
       'WorkerTaskRunner.js'
     ];
     if (configFragments.some(f => normalizedPath.includes(f))) return true;
 
+    // ── Common application entry points ───────────────────────────────────────
     const entryPatterns = [
       // CLI binaries
       '/bin/cli.js', '/bin/cli.ts', '/bin/cli.mjs',
       '/bin/index.js', '/bin/index.ts',
-      // Standard package entry points (poly-extension support)
-      '/index.js', '/index.ts', '/index.jsx', '/index.tsx', '/index.mjs', '/index.cjs',
-      // Server / app entry points
+      // Server / app entry points (Reduced in v3.3.8 to avoid false positives in libraries)
       '/src/main.ts', '/src/main.js',
       '/src/app.ts', '/src/app.js',
       '/src/api/HeadlessAPI.js', '/src/api/PluginSDK.js',
@@ -115,37 +119,50 @@ export class MagicDetector {
     ];
     if (entryPatterns.some(p => normalizedPath.endsWith(p))) return true;
 
+    // ── Next.js App Router conventions ────────────────────────────────────────
+    // Files under app/ directory with Next.js special names
     if (/\/app\/(page|layout|loading|error|not-found|template|default|route|middleware)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js Pages Router
     if (/\/pages\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js API routes
     if (/\/pages\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js middleware
     if (/\/middleware\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js config
     if (/\/next\.config\.(js|ts|mjs|cjs)$/.test(normalizedPath)) return true;
 
+    // ── Remix conventions ─────────────────────────────────────────────────────
     if (/\/app\/routes\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
     if (/\/app\/root\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
     if (/\/app\/entry\.(client|server)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
 
+    // ── SvelteKit conventions ─────────────────────────────────────────────────
     if (/\/\+page(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
     if (/\/\+layout(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
     if (/\/\+error\.(svelte|js|ts)$/.test(normalizedPath)) return true;
     if (/\/\+server\.(js|ts)$/.test(normalizedPath)) return true;
     if (/\/svelte\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
 
+    // ── Astro conventions ─────────────────────────────────────────────────────
     if (/\/src\/pages\/.*\.astro$/.test(normalizedPath)) return true;
     if (/\/src\/layouts\/.*\.astro$/.test(normalizedPath)) return true;
     if (/\/astro\.config\.(mjs|js|ts)$/.test(normalizedPath)) return true;
 
+    // ── Nuxt conventions ──────────────────────────────────────────────────────
     if (/\/pages\/.*\.vue$/.test(normalizedPath)) return true;
     if (/\/layouts\/.*\.vue$/.test(normalizedPath)) return true;
     if (/\/server\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
     if (/\/nuxt\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
 
+    // ── React / Vite entry points ─────────────────────────────────────────────
     if (/\/vite\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
 
+    // ── Angular conventions ───────────────────────────────────────────────────
     if (/\/main\.(ts|js)$/.test(normalizedPath)) return true;
     if (/\/app\.module\.(ts|js)$/.test(normalizedPath)) return true;
     if (/\/angular\.json$/.test(normalizedPath)) return true;
 
+    // ── Expo / React Native ───────────────────────────────────────────────────
     if (/\/app\/_layout\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
     if (/\/app\/index\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
 
@@ -159,8 +176,10 @@ export class MagicDetector {
     await this.ensureInitialized();
     if (!await this.isImplicitlyRequiredByEcosystem(filePath, activeFrameworks)) return;
 
+    // Retain entry point elements within memory to keep verification safe
     fileNode.isEntry = true;
 
+    // Apply dynamic exports coverage metrics based on active platform contracts
     const normalizedPath = filePath.replace(/\\/g, '/');
     const plugins = this.registry.getPlugins();
 
@@ -173,6 +192,7 @@ export class MagicDetector {
           const contracts = plugin.getRequiredSystemContracts();
           contracts.forEach(contractMethodToken => {
             if (fileNode.internalExports.has(contractMethodToken)) {
+              // Emulate active local reference linkages to protect the export
               fileNode.instantiatedIdentifiers.add(contractMethodToken);
             }
           });