entkapp 5.0.0 → 5.1.0

package/bin/cli.js

@@ -28,7 +28,7 @@ async function bootstrap() {
     program
       .name('entkapp')
       .description(ansis.cyan('The Ultimate Enterprise Codebase Janitor with OXC integration, type-aware analysis, and automated structural healing.'))
-      .version(packageJsonContent.version || '5.0.0');
+      .version(packageJsonContent.version || '5.1.0');
 
     program
       .option('-c, --cwd <path>', 'Specify the execution context root directory', process.cwd())
@@ -132,7 +132,7 @@ async function bootstrap() {
     }, timeoutMs);
     timeoutTimer.unref(); // Allow process to exit if work finishes
 
-    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '5.0.0'} Engine Activation`));
+    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '5.1.0'} Engine Activation`));
     console.log(ansis.dim('------------------------------------------------------------'));
     console.log(`${ansis.bold('Target Workspace Root :')} ${ansis.blue(targetCwd)}`);
     console.log(`${ansis.bold('Refactoring Mode     :')} ${options.fix ? ansis.yellow('Active Fixing & Self-Healing Enabled') : ansis.gray('Dry-Run Reporting Only')}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "name": "entkapp",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "The Ultimate Enterprise Codebase Janitor. Faster than Knip with OXC integration, type-aware analysis, and automated structural healing. Fully standalone - solving what Knip cannot.",
   "type": "module",
   "main": "index.js",

package/src/ast/ASTAnalyzer.js

@@ -234,7 +234,11 @@ export class ASTAnalyzer {
               }
             }
             break;
+
           case ts.SyntaxKind.CallExpression:
+            // FIX: Führe zuerst die generische Aufrufanalyse aus, die vorher blockiert war
+            this.handleCallExpression(node, fileNode, sourceFile);
+
             if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
               const arg = node.arguments[0];
               if (arg) {
@@ -244,14 +248,12 @@ export class ASTAnalyzer {
                   fileNode.explicitImports.add(specifier);
                 } else {
                   // UPGRADE: Handle Dynamic Imports with variables/expressions
-                  // We mark the file as having "calculated" dynamic imports to be conservative
                   fileNode.hasCalculatedDynamicImports = true;
                   const exprText = arg.getText(sourceFile);
-                  if (!fileNode.calculatedDynamicImports) fileNode.calculatedDynamicImports = new Set();
+                  if (!fileNode.calculatedDynamicImports || Array.isArray(fileNode.calculatedDynamicImports)) {
+                    fileNode.calculatedDynamicImports = new Set();
+                  }
                   fileNode.calculatedDynamicImports.add(exprText);
-                  
-                  // Conservative approach: If we see `import(path)`, any file in the same or sub directory could be a target.
-                  // This is a simplified version of what knip/entkapp does for plugins.
                   fileNode.dynamicImports.add('__DYNAMIC_PATTERN__');
                 }
               }
@@ -269,12 +271,23 @@ export class ASTAnalyzer {
                 // Dynamic require with template literal
                 fileNode.hasCalculatedDynamicImports = true;
                 const exprText = arg.getText(sourceFile);
-                if (!fileNode.calculatedDynamicImports) fileNode.calculatedDynamicImports = [];
-                fileNode.calculatedDynamicImports.push({ kind: 'DynamicRequire', expression: exprText, start: arg.getStart(sourceFile) });
+                
+                // FIX: Typ-Integrität als Set erzwingen (kein Array [])
+                if (!fileNode.calculatedDynamicImports || Array.isArray(fileNode.calculatedDynamicImports)) {
+                  fileNode.calculatedDynamicImports = new Set();
+                }
+                
+                // FIX: .add() statt .push() verwenden, um Absturz in Pass 2 zu verhindern
+                fileNode.calculatedDynamicImports.add({ 
+                  kind: 'DynamicRequire', 
+                  expression: exprText, 
+                  start: arg.getStart(sourceFile) 
+                });
                 fileNode.dynamicImports.add('__DYNAMIC_PATTERN__');
               }
             }
             break;
+
           case ts.SyntaxKind.PropertyAccessExpression:
             {
               const chain = node.getText(sourceFile);
@@ -284,9 +297,7 @@ export class ASTAnalyzer {
               }
             }
             break;
-          case ts.SyntaxKind.CallExpression:
-            this.handleCallExpression(node, fileNode, sourceFile);
-            break;
+
           case ts.SyntaxKind.JsxElement:
           case ts.SyntaxKind.JsxSelfClosingElement:
             this.handleJsxElement(node, fileNode, sourceFile);
@@ -580,7 +591,9 @@ export class ASTAnalyzer {
           }
         } else {
           // Non-literal dynamic import
-          if (!fileNode.calculatedDynamicImports) fileNode.calculatedDynamicImports = [];
+          if (!Array.isArray(fileNode.calculatedDynamicImports)) {
+            fileNode.calculatedDynamicImports = [];
+          }
           fileNode.calculatedDynamicImports.push({ kind: ts.SyntaxKind[arg.kind], start: arg.getStart(sourceFile) });
           
           // UPGRADE 2: Try to perform Glob-Analysis on Template Strings
@@ -605,11 +618,13 @@ export class ASTAnalyzer {
     if (ts.isTemplateExpression(node)) {
       const head = node.head.text;
       if (head.startsWith('./') || head.startsWith('../')) {
-        // Pattern: `./directory/${variable}`
+        // FIX: Typ-Integrität als Set erzwingen, kein Array!
+        if (!fileNode.globImports || Array.isArray(fileNode.globImports)) {
+          fileNode.globImports = new Set();
+        }
         const dirPath = path.dirname(head);
         if (dirPath && dirPath !== '.') {
-          if (!fileNode.globImports) fileNode.globImports = new Set();
-          fileNode.globImports.add(dirPath);
+          fileNode.globImports.add(dirPath); // Jetzt klappt .add() garantiert!
         }
       }
     }

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;
       }
@@ -140,10 +148,6 @@ 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 };
@@ -172,7 +176,6 @@ export class BarrelParser {
     // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
     for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
       if (targetSymbolName === namespaceAlias) {
-          // The symbol IS the namespace itself
           const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
           return { originFile: fullyResolvedPath, originSymbol: '*' };
       }
@@ -190,7 +193,7 @@ export class BarrelParser {
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
       
       if (fullyResolvedPath) {
-        // FIX: Mark the target module as active immediately when export * is found
+        // Verbinde Graph-Kanten direkt während der Wildcard-Traversierung
         const contextNode = activeProjectGraph.get(contextFilePath);
         if (contextNode) {
           contextNode.outgoingEdges.add(fullyResolvedPath);
@@ -204,13 +207,12 @@ export class BarrelParser {
           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.
         const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
         if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol) || 
             continuousResolutionTrace.originSymbol === '*') {
@@ -225,4 +227,4 @@ export class BarrelParser {
 
     return { originFile: contextFilePath, originSymbol: targetSymbolName };
   }
-}
+}

package/src/ast/OxcAnalyzer.js

@@ -250,6 +250,9 @@ export class OxcAnalyzer {
     } 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,
@@ -437,6 +440,9 @@ export class OxcAnalyzer {
   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,

package/src/index.js

@@ -563,10 +563,13 @@ export class RefactoringEngine {
           if (node && (node.isLibraryEntry || node.isEntry)) return false;
 
           let isPackageEntryPoint = false;
-          for (const [_, metadata] of this.workspaceGraph.packageManifests.entries()) {
-            if (metadata.entryPoints && metadata.entryPoints.map(p => slashifyLocal(p)).includes(cleanAbsPath)) {
-              isPackageEntryPoint = true;
-              break;
+          const manifests = this.workspaceGraph?.packageManifests;
+          if (manifests) {
+            for (const [_, metadata] of manifests.entries()) {
+              if (metadata.entryPoints && metadata.entryPoints.map(p => slashifyLocal(p)).includes(cleanAbsPath)) {
+                isPackageEntryPoint = true;
+                break;
+              }
             }
           }
           return !isPackageEntryPoint;
@@ -574,7 +577,7 @@ export class RefactoringEngine {
       }
       analysisSummary.unlistedDependencies = this.context.unlistedDependencies || [];
       
-      const advancedResults = this.advancedAnalysis.runAll(this.context.projectGraph, this.workspaceGraph.packageManifests);
+      const advancedResults = this.advancedAnalysis.runAll(this.context.projectGraph, this.workspaceGraph?.packageManifests || new Map());
       const cycles = cyclesResult;
       
       const structuralModificationsStaged = 

package/src/resolution/CircularDetector.js

@@ -6,47 +6,86 @@ export class CircularDetector {
     this.cycles = [];
   }
 
-  detectCycles(projectGraph, context) {
-    const visited = new Set();
-    const stack = new Set();
-    const cycles = [];
+  detectCycles(projectGraph) {
+    const stack = [];
+    const onStack = new Set();
+    const indices = new Map();
+    const lowlink = new Map();
+    const sccs = [];
+    let index = 0;
 
-    const traverse = (filePath, currentPath) => {
-      visited.add(filePath);
-      stack.add(filePath);
-      currentPath.push(filePath);
+    const strongConnect = (v) => {
+      indices.set(v, index);
+      lowlink.set(v, index);
+      index++;
+      stack.push(v);
+      onStack.add(v);
 
-      const node = projectGraph.get(filePath);
+      const node = projectGraph.get(v);
       if (node && node.outgoingEdges) {
-        for (const neighbor of node.outgoingEdges) {
-          if (stack.has(neighbor)) {
-            const cycleStartIndex = currentPath.indexOf(neighbor);
-            const cycle = currentPath.slice(cycleStartIndex);
-            cycle.push(neighbor);
-            cycles.push(cycle);
-          } else if (!visited.has(neighbor)) {
-            traverse(neighbor, currentPath);
+        // Ensure outgoingEdges is treated as an array-like structure
+        const edges = Array.isArray(node.outgoingEdges) ? node.outgoingEdges : Array.from(node.outgoingEdges);
+        
+        for (let i = 0; i < edges.length; i++) {
+          const w = edges[i];
+          if (!indices.has(w)) {
+            strongConnect(w);
+            lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+          } else if (onStack.has(w)) {
+            lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
           }
         }
       }
 
-      stack.delete(filePath);
-      currentPath.pop();
+      if (lowlink.get(v) === indices.get(v)) {
+        const scc = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.push(w);
+        } while (w !== v);
+
+        if (scc.length > 1) {
+          const cycle = scc.slice().reverse();
+          cycle.push(cycle[0]);
+          sccs.push(cycle);
+        } else if (scc.length === 1) {
+          const singleNode = projectGraph.get(scc[0]);
+          if (singleNode && singleNode.outgoingEdges) {
+            const edges = Array.isArray(singleNode.outgoingEdges) ? singleNode.outgoingEdges : Array.from(singleNode.outgoingEdges);
+            let hasSelfLoop = false;
+            for (let i = 0; i < edges.length; i++) {
+              if (edges[i] === scc[0]) {
+                hasSelfLoop = true;
+                break;
+              }
+            }
+            if (hasSelfLoop) {
+              sccs.push([scc[0], scc[0]]);
+            }
+          }
+        }
+      }
     };
 
-    for (const filePath of projectGraph.keys()) {
-      if (!visited.has(filePath)) {
-        traverse(filePath, []);
+    const keys = Array.from(projectGraph.keys());
+    for (let i = 0; i < keys.length; i++) {
+      if (!indices.has(keys[i])) {
+        strongConnect(keys[i]);
       }
     }
 
-    this.cycles = cycles;
-    return cycles;
+    this.cycles = sccs;
+    return sccs;
   }
 
   formatCycles() {
     return this.cycles.map(cycle => {
-      return cycle.map(p => path.relative(this.context.cwd, p).replace(/\\/g, '/')).join(' -> ');
+      return cycle.map(p => {
+        const relativePath = path.relative(this.context.cwd, p);
+        return relativePath.replace(/\\/g, '/');
+      }).join(' -> ');
     });
   }
 }

package/src/resolution/DepencyResolver.js

@@ -24,12 +24,23 @@ export class DependencyResolver {
 
   resolveModulePath(sourceFile, specifier) {
     const cleanSource = this.normalizePath(sourceFile);
+    
+    // UPGRADE: Use PathMapper for sophisticated resolution (TS-to-JS, aliases, etc.)
+    if (this.pathMapper) {
+      const dir = path.dirname(cleanSource);
+      const target = path.resolve(dir, specifier);
+      const resolved = this.pathMapper.resolvePath(target);
+      if (resolved && existsSync(resolved)) {
+        return this.normalizePath(resolved);
+      }
+    }
+
     if (specifier.startsWith('.')) {
       const dir = path.dirname(cleanSource);
       const target = path.resolve(dir, specifier);
       const normalizedTarget = this.normalizePath(target);
       
-      const extensions = ['', '.js', '.ts', '.tsx', '.jsx', '/index.js', '/index.ts'];
+      const extensions = ['', '.js', '.ts', '.tsx', '.jsx', '/index.js', '/index.ts', '/index.tsx'];
       for (const ext of extensions) {
         const p = normalizedTarget + ext;
         if (existsSync(p)) return this.normalizePath(p);

package/src/resolution/PathMapper.js

@@ -1,5 +1,49 @@
+import fs from 'fs';
+import path from 'path';
+
 export class PathMapper {
-  constructor(context) { this.context = context; }
-  async loadMappings() {}
-  resolvePath(p) { return p; }
+  constructor(context) { 
+    this.context = context; 
+  }
+  
+  async loadMappings() {
+    // Hier können später tsconfig-Pfade geladen werden
+  }
+
+  /**
+   * Resolves physical module paths on disk, translating modern .js imports 
+   * back to their actual TypeScript source files.
+   * @param {string} p - The target module specifier or absolute path
+   */
+  resolvePath(p) {
+    if (!p || typeof p !== 'string') return p;
+
+    // FIX 1: Wenn der Import auf .js endet, übersetze ihn für die Suche auf .ts
+    if (p.endsWith('.js')) {
+      const tsPath = p.slice(0, -3) + '.ts';
+      if (fs.existsSync(tsPath)) return tsPath;
+    }
+
+    // FIX 2: Wenn der Import auf .jsx endet, übersetze ihn für die Suche auf .tsx
+    if (p.endsWith('.jsx')) {
+      const tsxPath = p.slice(0, -4) + '.tsx';
+      if (fs.existsSync(tsxPath)) return tsxPath;
+    }
+
+    // FIX 3: Unterstützung für Verzeichnis-Imports (z.B. ./adapters -> ./adapters/index.ts)
+    try {
+      const stat = fs.statSync(p);
+      if (stat.isDirectory()) {
+        const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+        for (const ext of extensions) {
+          const indexPath = path.join(p, `index${ext}`);
+          if (fs.existsSync(indexPath)) return indexPath;
+        }
+      }
+    } catch {
+      // Datei existiert nicht oder ist kein Verzeichnis, fahre mit Standard fort
+    }
+
+    return p; 
+  }
 }

package/src/resolution/WorkSpaceGraph.js

@@ -1,5 +1,8 @@
 export class WorkspaceGraph {
-  constructor(context) { this.context = context; }
+  constructor(context) { 
+    this.context = context; 
+    this.packageManifests = new Map();
+  }
   async initializeWorkspaceMesh() {}
   markWorkspacePackagesAsUsed() {}
 }