entkapp 5.7.0 → 5.7.1

package/README.md

@@ -1,4 +1,4 @@
-# 🕸️ entkapp Ultimate v5.6.1
+# 🕸️ entkapp Ultimate v5.7.1
 
 > **The Ultimate Enterprise Codebase Janitor.** High-speed OXC integration, type-aware analysis, and automated structural healing. Fully standalone architectural orchestrator.
 

package/bin/cli.js

@@ -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.6.0'} Engine Activation`));
+    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '5.7.1'} 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/bin/cli.mjs

@@ -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.7.0');
+      .version(packageJsonContent.version || '5.7.1');
 
     program
       .option('-c, --cwd <path>', 'Specify the execution context root directory', process.cwd())
@@ -123,7 +123,7 @@ async function bootstrap() {
     }, timeoutMs);
     timeoutTimer.unref();
 
-    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '5.7.0'} Engine Activation`));
+    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '5.7.1'} 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.7.0",
+  "version": "5.7.1",
   "description": "The Ultimate Enterprise Codebase Janitor. High-speed OXC integration, type-aware analysis, and automated structural healing. Fully standalone architectural orchestrator.",
   "type": "module",
   "main": "index.js",

package/src/EngineContext.js

@@ -214,6 +214,44 @@ export class EngineContext {
         } catch (e) {}
     }
 
+    // FIX (Bug 2): Fallback Entry-Point Seeding for standard TypeScript/JavaScript projects.
+    // If no entry points have been discovered via node.isEntry flags or manifest fields
+    // (e.g. because EntryPointDetector was not wired in the JS build), we fall back to
+    // well-known convention paths so that the BFS traversal is never empty and all
+    // reachable files – and their dependencies – are correctly included in the analysis.
+    if (reachableFiles.size === 0 && this.projectGraph.size > 0) {
+      const conventionEntries = [
+        'src/index.ts', 'src/index.tsx', 'src/index.js', 'src/index.jsx',
+        'src/main.ts', 'src/main.js',
+        'index.ts', 'index.tsx', 'index.js',
+        'src/app.ts', 'src/app.js'
+      ];
+      const normalizeCwd = (p) => {
+        let n = path.resolve(this.cwd, p).replace(/\\/g, '/');
+        if (/^[a-z]:\//.test(n)) n = n.charAt(0).toUpperCase() + n.slice(1);
+        return n;
+      };
+      for (const rel of conventionEntries) {
+        const abs = normalizeCwd(rel);
+        if (this.projectGraph.has(abs) && !reachableFiles.has(abs)) {
+          reachableFiles.add(abs);
+          queue.push(abs);
+          this.projectGraph.get(abs).isEntry = true;
+          if (this.verbose) console.log(`[Reachability] Fallback entry point seeded: ${rel}`);
+        }
+      }
+      // Last resort: if still empty, treat every graph node that has no incoming edges
+      // as a potential root so that the dependency audit is never skipped entirely.
+      if (reachableFiles.size === 0) {
+        for (const [fp, node] of this.projectGraph.entries()) {
+          if (node.incomingEdges.size === 0) {
+            reachableFiles.add(fp);
+            queue.push(fp);
+          }
+        }
+      }
+    }
+
     // 2. BFS Traversal
     while (queue.length > 0) {
       const currentPath = queue.shift();
@@ -362,11 +400,33 @@ export class EngineContext {
 
     // --- DEPENDENCY ANALYSIS ---
     const usedByReachableFiles = new Set();
+
+    // FIX (Bug 3): Helper to extract the base package name from an import specifier.
+    // Handles scoped packages (@org/pkg), sub-path imports (pkg/sub), and node: prefix.
+    const extractBasePkg = (specifier) => {
+      if (!specifier || specifier.startsWith('.') || specifier.startsWith('/')) return null;
+      const s = specifier.startsWith('node:') ? specifier.slice(5) : specifier;
+      return s.startsWith('@') ? s.split('/').slice(0, 2).join('/') : s.split('/')[0];
+    };
+
     reachableFiles.forEach(filePath => {
       const node = this.projectGraph.get(filePath);
       if (node) {
+        // Primary source: externalPackageUsage populated by ASTAnalyzer / OxcAnalyzer
         node.externalPackageUsage.forEach(pkg => usedByReachableFiles.add(pkg));
-        
+
+        // FIX (Bug 3): Also derive package names from explicitImports.
+        // ASTAnalyzer populates node.explicitImports with raw import specifiers
+        // (e.g. "lodash", "axios/lib/core") but these are not always mirrored into
+        // externalPackageUsage when the AST pass runs in worker threads or when the
+        // OXC parser is unavailable. Extracting them here closes the gap.
+        if (node.explicitImports) {
+          node.explicitImports.forEach(specifier => {
+            const pkg = extractBasePkg(specifier);
+            if (pkg) usedByReachableFiles.add(pkg);
+          });
+        }
+
         // Conservative check for dynamic imports in reachable files
         if (node.calculatedDynamicImports) {
           node.calculatedDynamicImports.forEach(entry => {
@@ -397,11 +457,21 @@ export class EngineContext {
         }
         
         // UPGRADE: Be more aggressive in detecting unused dependencies.
-        // Check both externalPackageUsage and rawStringReferences.
+        // FIX (Bug 3): Check externalPackageUsage, rawStringReferences AND explicitImports
+        // to ensure packages imported via static import statements are never false-positives.
         const isUsed = usedByReachableFiles.has(dep) || 
                        Array.from(reachableFiles).some(f => {
                          const node = this.projectGraph.get(f);
-                         return node && (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep));
+                         if (!node) return false;
+                         if (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep)) return true;
+                         // FIX: check explicitImports for base package name match
+                         if (node.explicitImports) {
+                           for (const specifier of node.explicitImports) {
+                             const base = extractBasePkg(specifier);
+                             if (base === dep) return true;
+                           }
+                         }
+                         return false;
                        });
 
         if (!isUsed) {

package/src/EngineContext.mjs

@@ -218,6 +218,38 @@ export class EngineContext {
         } catch (e) {}
     }
 
+    // FIX (Bug 2): Fallback Entry-Point Seeding for standard TypeScript/JavaScript projects.
+    if (reachableFiles.size === 0 && this.projectGraph.size > 0) {
+      const conventionEntries = [
+        'src/index.ts', 'src/index.tsx', 'src/index.js', 'src/index.jsx',
+        'src/main.ts', 'src/main.js',
+        'index.ts', 'index.tsx', 'index.js',
+        'src/app.ts', 'src/app.js'
+      ];
+      const normalizeCwd = (p) => {
+        let n = path.resolve(this.cwd, p).replace(/\\/g, '/');
+        if (/^[a-z]:\//.test(n)) n = n.charAt(0).toUpperCase() + n.slice(1);
+        return n;
+      };
+      for (const rel of conventionEntries) {
+        const abs = normalizeCwd(rel);
+        if (this.projectGraph.has(abs) && !reachableFiles.has(abs)) {
+          reachableFiles.add(abs);
+          queue.push(abs);
+          this.projectGraph.get(abs).isEntry = true;
+          if (this.verbose) console.log(`[Reachability] Fallback entry point seeded: ${rel}`);
+        }
+      }
+      if (reachableFiles.size === 0) {
+        for (const [fp, node] of this.projectGraph.entries()) {
+          if (node.incomingEdges.size === 0) {
+            reachableFiles.add(fp);
+            queue.push(fp);
+          }
+        }
+      }
+    }
+
     // 2. BFS Traversal
     while (queue.length > 0) {
       const currentPath = queue.shift();
@@ -366,10 +398,24 @@ export class EngineContext {
 
     // --- DEPENDENCY ANALYSIS ---
     const usedByReachableFiles = new Set();
+
+    const extractBasePkg = (specifier) => {
+      if (!specifier || specifier.startsWith('.') || specifier.startsWith('/')) return null;
+      const s = specifier.startsWith('node:') ? specifier.slice(5) : specifier;
+      return s.startsWith('@') ? s.split('/').slice(0, 2).join('/') : s.split('/')[0];
+    };
+
     reachableFiles.forEach(filePath => {
       const node = this.projectGraph.get(filePath);
       if (node) {
         node.externalPackageUsage.forEach(pkg => usedByReachableFiles.add(pkg));
+
+        if (node.explicitImports) {
+          node.explicitImports.forEach(specifier => {
+            const pkg = extractBasePkg(specifier);
+            if (pkg) usedByReachableFiles.add(pkg);
+          });
+        }
         
         // Conservative check for dynamic imports in reachable files
         if (node.calculatedDynamicImports) {
@@ -401,11 +447,18 @@ export class EngineContext {
         }
         
         // UPGRADE: Be more aggressive in detecting unused dependencies.
-        // Check both externalPackageUsage and rawStringReferences.
         const isUsed = usedByReachableFiles.has(dep) || 
                        Array.from(reachableFiles).some(f => {
                          const node = this.projectGraph.get(f);
-                         return node && (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep));
+                         if (!node) return false;
+                         if (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep)) return true;
+                         if (node.explicitImports) {
+                           for (const specifier of node.explicitImports) {
+                             const base = extractBasePkg(specifier);
+                             if (base === dep) return true;
+                           }
+                         }
+                         return false;
                        });
 
         if (!isUsed) {

package/src/index.js

@@ -64,6 +64,24 @@ export class RefactoringEngine {
     this.resolver = new DependencyResolver(this.context, this.pathMapper, this.workspaceGraph);
     this.circularDetector = new CircularDetector(this.context);
     
+    // FIX (Bug 2): Initialize packageJson and EntryPointDetector, mirroring the .mjs twin.
+    // Without this, src/index.ts is never registered as an entry point in the JS build,
+    // causing all files to be treated as unreachable and suppressing the dependency audit.
+    try {
+      const pkgPath = path.join(this.context.cwd, 'package.json');
+      if (existsSync(pkgPath)) {
+        this.context.packageJson = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      }
+    } catch (e) {}
+
+    import('./resolution/EntryPointDetector.js').then(({ EntryPointDetector }) => {
+      this.entryPointDetector = new EntryPointDetector(
+        this.context.cwd,
+        this.context.packageJson,
+        this.context.metrics
+      );
+    }).catch(() => {});
+
     // Lazy import DependencyProfiler
     import('./resolution/DependencyProfiler.js').then(({ DependencyProfiler }) => {
       this.dependencyProfiler = new DependencyProfiler(this.context);
@@ -347,16 +365,33 @@ export class RefactoringEngine {
         }
       }
       if (entryCount === 0) {
-        console.log(ansis.bold.yellow('  🚨 ALARM: Keine einzige Datei wurde als Entry Point markiert! Greife auf Fallbacks zurück...'));
-        const fallbackFiles = ['index.js', 'index.mjs', 'src/index.js', 'src/index.mjs', 'main.js', 'src/main.js'];
-        for (const fallback of fallbackFiles) {
-          const absFallback = path.resolve(this.context.cwd, fallback).replace(/\\/g, '/');
-          if (this.context.projectGraph.has(absFallback)) {
-            const node = this.context.projectGraph.get(absFallback);
-            node.isEntry = true;
-            console.log(ansis.green(`  • 💎 FALLBACK ENTRY: ${fallback}`));
-            entryCount++;
-            break;
+        console.log(ansis.bold.yellow('  🚨 ALARM: Keine einzige Datei wurde als Entry Point markiert! Starte Deep Detection...'));
+
+        // FIX (Bug 2): Use EntryPointDetector first (mirrors .mjs twin behavior).
+        // This ensures src/index.ts and other convention-based roots are found reliably.
+        if (this.entryPointDetector) {
+          const detected = this.entryPointDetector.detect();
+          detected.forEach(absPath => {
+            const cleanPath = absPath.replace(/\\/g, '/');
+            if (this.context.projectGraph.has(cleanPath)) {
+              this.context.projectGraph.get(cleanPath).isEntry = true;
+              console.log(ansis.green(`  • 💎 DETECTED ENTRY: ${path.relative(this.context.cwd, cleanPath)}`));
+              entryCount++;
+            }
+          });
+        }
+
+        if (entryCount === 0) {
+          const fallbackFiles = ['index.js', 'index.mjs', 'src/index.js', 'src/index.mjs', 'src/index.ts', 'src/index.tsx', 'main.js', 'src/main.js', 'src/main.ts'];
+          for (const fallback of fallbackFiles) {
+            const absFallback = path.resolve(this.context.cwd, fallback).replace(/\\/g, '/');
+            if (this.context.projectGraph.has(absFallback)) {
+              const node = this.context.projectGraph.get(absFallback);
+              node.isEntry = true;
+              console.log(ansis.green(`  • 💎 FALLBACK ENTRY: ${fallback}`));
+              entryCount++;
+              break;
+            }
           }
         }
       }
@@ -547,10 +582,22 @@ export class RefactoringEngine {
         }
       }
 
+      // FIX: Robust path normalization helper for cross-platform path comparison.
+      // Mirrors the normalizePath() logic in OxcAnalyzer.js to handle Windows
+      // drive-letter case differences and mixed slash types before path.relative().
+      const normalizeForAudit = (p) => {
+        if (!p) return '';
+        let n = path.resolve(p).replace(/\\/g, '/');
+        if (/^[a-z]:\//.test(n)) n = n.charAt(0).toUpperCase() + n.slice(1);
+        return n.replace(/\/+/g, '/').replace(/\/$/, '');
+      };
+
       for (const metadata of auditManifests) {
         if (this.context.projectGraph) {
+          const normRoot = normalizeForAudit(metadata.rootDirectory);
           for (const [filePath, fileNode] of this.context.projectGraph.entries()) {
-            const cleanRelative = path.relative(metadata.rootDirectory, filePath).replace(/\\/g, '/');
+            const normFilePath = normalizeForAudit(filePath);
+            const cleanRelative = path.relative(normRoot, normFilePath).replace(/\\/g, '/');
             
             // Check if file belongs to this manifest's directory scope
             if (!cleanRelative.startsWith('..') && !cleanRelative.startsWith('/') && fileNode.explicitImports) {