entkapp 4.2.0 → 4.3.0

package/bin/cli.js

@@ -28,7 +28,7 @@ async function bootstrap() {
     program
       .name('entkapp')
       .description(ansis.cyan('Enterprise-Grade AST Syntax Refactoring & Self-Healing Engine'))
-      .version(packageJsonContent.version || '4.2.0');
+      .version(packageJsonContent.version || '4.3.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 || '4.2.0'} Engine Activation`));
+    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '4.3.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": "4.2.0",
+  "version": "4.3.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",
@@ -91,7 +91,6 @@
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
-    "knip": "^6.17.1",
     "vitepress": "^1.6.4",
     "vue": ">=3.5.0"
   },

package/src/EngineContext.js

@@ -31,8 +31,16 @@ export class GraphNode {
     this.localSuppressedRules = new Set();
   }
 
-  isSymbolReferencedExternally(symbolName, projectGraph) {
+  isSymbolReferencedExternally(symbolName, projectGraph, context) {
     if (this.isLibraryEntry) return true;
+    
+    // Check global registry if provided
+    if (context && context.importUsageRegistry) {
+        if (context.importUsageRegistry.has(`${this.filePath}:${symbolName}`) || 
+            context.importUsageRegistry.has(`${this.filePath}:*`)) {
+            return true;
+        }
+    }
 
     // --- NEW: Self-reference check (Fix for SecretSeverity bug) ---
     // If the symbol is used within the same file, it is NOT dead.
@@ -137,12 +145,14 @@ export class EngineContext {
         report.orphanedFiles.push(path.relative(this.cwd, filePath));
       }
 
+      if (node.isEntry || node.isLibraryEntry) continue;
+
       for (const [symbol, meta] of node.internalExports.entries()) {
         if (symbol === '*' || symbol === 'default' || node.localSuppressedRules.has('unused-export') || node.localSuppressedRules.has(`unused-export:${symbol}`)) {
           continue;
         }
 
-        if (!node.isSymbolReferencedExternally(symbol, this.projectGraph)) {
+        if (!node.isSymbolReferencedExternally(symbol, this.projectGraph, this)) {
           const loc = node.symbolSourceLocations.get(symbol) || { line: 0, column: 0 };
           report.deadExports.push({
             symbol,

package/src/ast/ASTAnalyzer.js

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import path from 'path';
 import fs from 'fs';
+import ansis from 'ansis';
 
 export class ASTAnalyzer {
   constructor(context) {
@@ -398,6 +399,14 @@ export class ASTAnalyzer {
     if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
       if (arg) {
+        if (!fileNode.calculatedDynamicImports) fileNode.calculatedDynamicImports = [];
+        fileNode.calculatedDynamicImports.push({ kind: ts.SyntaxKind[arg.kind], start: arg.getStart(sourceFile) });
+        
+        // Ensure the argument text is also in rawStringReferences if it's a literal
+        if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+           fileNode.rawStringReferences.add(arg.text);
+        }
+
         if (ts.isStringLiteral(arg)) {
           fileNode.explicitImports.add(arg.text);
           fileNode.dynamicImports.add(arg.text);
@@ -405,11 +414,6 @@ export class ASTAnalyzer {
           if (!arg.text.startsWith('.') && !arg.text.startsWith('/')) {
             fileNode.externalPackageUsage.add(this._extractPackageName(arg.text));
           }
-        } else {
-          // Dynamic import with a non-literal expression (e.g., variable or template literal).
-          if (fileNode.calculatedDynamicImports) {
-            fileNode.calculatedDynamicImports.push({ kind: ts.SyntaxKind[arg.kind], start: arg.getStart(sourceFile) });
-          }
         }
       }
     } else if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {

package/src/ast/DeadCodeDetector.js

@@ -10,7 +10,7 @@ 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) {
+      if (node.isEntry || node.isLibraryEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
         entryPoints.add(filePath);
       }
     }
@@ -45,7 +45,7 @@ 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;
+      if (node.isEntry || node.isLibraryEntry) continue;
 
       for (const [exportName, exportInfo] of node.internalExports.entries()) {
         if (exportName === '*' || exportName === 'default') continue; // Skip wildcards for now

package/src/ast/OxcAnalyzer.js

@@ -271,6 +271,9 @@ export class OxcAnalyzer {
     // Dynamic import(): import('./module')
     if (node.callee.type === "Import" && node.arguments.length > 0) {
       const arg = node.arguments[0];
+      if (!fileNode.calculatedDynamicImports) fileNode.calculatedDynamicImports = [];
+      fileNode.calculatedDynamicImports.push({ kind: arg.type, start: arg.start });
+
       if (arg.type === "StringLiteral") {
         const specifier = arg.value;
         fileNode.explicitImports.add(specifier);
@@ -279,10 +282,6 @@ export class OxcAnalyzer {
         if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
           fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
         }
-      } else {
-        if (fileNode.calculatedDynamicImports) {
-          fileNode.calculatedDynamicImports.push({ kind: arg.type, start: arg.start });
-        }
       }
     } else if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length > 0 && node.arguments[0].type === "StringLiteral") {
       const specifier = node.arguments[0].value;

package/src/index.js

@@ -87,6 +87,8 @@ export class RefactoringEngine {
     try {
       console.log(ansis.bold.green('🎯 Starting entkapp Operational Optimization Cycle...'));
       
+      if (!this.context.importUsageRegistry) this.context.importUsageRegistry = new Set();
+
       let rl;
       if (!this.context.skipConfirm) {
         rl = readline.createInterface({
@@ -136,6 +138,7 @@ export class RefactoringEngine {
 
       for (const filePath of sourceCodeFilesList) {
         const node = this.context.getOrCreateNode(filePath);
+        if (!this.context.importUsageRegistry) this.context.importUsageRegistry = new Set();
         const currentHash = await this.cacheManager.computeHash(filePath);
         node.contentHash = currentHash;
 
@@ -217,6 +220,21 @@ export class RefactoringEngine {
       // Pass 4: Evaluate graph edges and link connections across the codebase mesh
       console.log(ansis.dim('🔗 Linking graph edges and checking structural usage paths...'));
       await this.linkDependencyGraph();
+      
+      // Update entry points and seeds based on link analysis
+      for (const [filePath, node] of this.context.projectGraph.entries()) {
+          if (node.isEntry || node.isLibraryEntry) {
+              if (!this.context.importUsageRegistry) this.context.importUsageRegistry = new Set();
+              this.context.importUsageRegistry.add(`${filePath}:*`);
+              
+              // Also protect all symbols in library entries
+              if (node.internalExports) {
+                  for (const symbol of node.internalExports.keys()) {
+                      this.context.importUsageRegistry.add(`${filePath}:${symbol}`);
+                  }
+              }
+          }
+      }
 
       // NEW: Circular Dependency Detection
       console.log(ansis.dim('🔄 Detecting circular dependencies...'));
@@ -470,6 +488,8 @@ export class RefactoringEngine {
           if (isPackageEntryPoint) continue;
 
           const originalNode = this.context.projectGraph.get(cleanExportedFile);
+          if (originalNode && originalNode.isLibraryEntry) continue;
+          
           const unusedExportsInThisFile = [];
           
           for (const symbol of exportsSet) {
@@ -600,6 +620,14 @@ export class RefactoringEngine {
         const ext = path.extname(entry.name);
         if (['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte'].includes(ext) || entry.name === 'package.json') {
           fileList.push(res);
+          // Auto-detect entry points: files named index.js/ts/jsx/tsx in the root are entry points
+          if (dir === this.context.cwd && /^index\.(js|ts|jsx|tsx)$/.test(entry.name)) {
+            if (!this.context.entryPoints.includes(res)) {
+              this.context.entryPoints.push(res);
+            }
+            const node = this.context.getOrCreateNode(res);
+            node.isEntry = true;
+          }
         }
       }
     }
@@ -626,7 +654,9 @@ export class RefactoringEngine {
 
     for (const seedPath of seeds) {
       if (this.context.projectGraph.has(seedPath)) {
-        this.context.projectGraph.get(seedPath).isLibraryEntry = true;
+        const node = this.context.projectGraph.get(seedPath);
+        node.isLibraryEntry = true;
+        node.isEntry = true;
       }
     }
 
@@ -677,6 +707,43 @@ export class RefactoringEngine {
           }
         }
       }
+
+      // C. Dynamic Import Heuristics (Fix for non-literal dynamic imports)
+      // If a file has calculated dynamic imports (e.g. import(variable)), 
+      // we check all raw strings in that file as potential targets.
+      if (node.calculatedDynamicImports && node.calculatedDynamicImports.length > 0) {
+        for (const candidate of node.rawStringReferences) {
+          // Rule 1: Try resolving it directly
+          const resolvedPath = this.resolver.resolveModulePath(filePath, candidate);
+          if (resolvedPath && this.context.projectGraph.has(resolvedPath)) {
+            const targetNode = this.context.projectGraph.get(resolvedPath);
+            targetNode.incomingEdges.add(filePath);
+            node.outgoingEdges.add(resolvedPath);
+            targetNode.isLibraryEntry = true;
+            if (this.context.verbose) console.log(ansis.dim(`🔗 Dynamic Heuristic (Resolved): Linked ${candidate} from ${filePath}`));
+            continue;
+          }
+
+          // Rule 2: Check all possible internal files for partial matches
+          if (candidate.length > 3) { // Avoid very short strings
+            for (const [targetPath, targetNode] of this.context.projectGraph.entries()) {
+               const relToCwd = path.relative(this.context.cwd, targetPath).replace(/\\/g, '/');
+               const relNoExt = relToCwd.replace(/\.[^/.]+$/, "");
+               
+               // Check for exact relative path matches or partial matches that look intentional
+               if (candidate === relToCwd || candidate === relNoExt || 
+                   candidate === `./${relToCwd}` || candidate === `./${relNoExt}` ||
+                   (candidate.includes('/') && targetPath.endsWith(candidate.startsWith('/') ? candidate : `/${candidate}`))) {
+                  
+                  targetNode.incomingEdges.add(filePath);
+                  node.outgoingEdges.add(targetPath);
+                  targetNode.isLibraryEntry = true;
+                  if (this.context.verbose) console.log(ansis.dim(`🔗 Dynamic Heuristic (Partial): Linked ${candidate} to ${relToCwd} from ${filePath}`));
+               }
+            }
+          }
+        }
+      }
     }
   }