entkapp 4.1.0 → 4.3.0

package/README.md

@@ -28,6 +28,19 @@ It represents the process of stripping away the unnecessary layers of a codebase
 ## 📦 Installation
 
 ```bash
-npm install -D entkapp
+npm install -g entkapp
 # or
-pnpm add -D entkapp
+pnpm add -g entkapp
+```
+
+## Usage
+```bash
+npx entkapp
+# or
+entkapp
+# and then
+npx entkapp -r
+# or
+entkapp -r
+# It is recommended to run with --no-fix tag on your first run!
+```

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.0.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.0.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/index.js

@@ -2,7 +2,7 @@
 
 /**
  * ============================================================================
- * 📦 entkapp v4.1.0: Ultimate Enterprise Codebase Janitor & Self-Healing Engine
+ * 📦 entkapp v4.2.0: Ultimate Enterprise Codebase Janitor & Self-Healing Engine
  * ============================================================================
  * * Eine hochgradig integrierte Code-Analyse- und Projektbootstrapping-Engine.
  * Kombiniert rekursive Erreichbarkeitsanalysen (Reachability Graphs) auf 
@@ -648,7 +648,7 @@ function smartPrepend(originalCode, declarationBlock) {
 async function inspectNpmPackage(pkgName) {
     try {
         const response = await fetch(`https://registry.npmjs.org/${pkgName}/latest`, {
-            headers: { 'User-Agent': 'entkapp-dx-client/4.1.0' },
+            headers: { 'User-Agent': 'entkapp-dx-client/4.2.0' },
             signal: AbortSignal.timeout(4000)
         });
         if (response.status === 200) {
@@ -682,7 +682,7 @@ async function inspectNpmPackage(pkgName) {
 async function fetchRemoteLicense(licenseKey) {
     try {
         const response = await fetch(`https://api.github.com/licenses/${licenseKey.toLowerCase()}`, {
-            headers: { 'User-Agent': 'entkapp-dx-client/4.1.0' },
+            headers: { 'User-Agent': 'entkapp-dx-client/4.2.0' },
             signal: AbortSignal.timeout(5000)
         });
         if (response.status === 200) {
@@ -1681,7 +1681,7 @@ function postProcessAnalysis(stats, graphEngine) {
 // ============================================================
 async function main() {
     if (process.argv.includes('--help') || process.argv.includes('-h')) {
-        console.log(`\n📦 entkapp v4.1.0: Advanced Dependency Intelligence Engine\n`);
+        console.log(`\n📦 entkapp v4.2.0: Advanced Dependency Intelligence Engine\n`);
         console.log(`Usage: npx entkapp [options]\n`);
         console.log(`Options:`);
         console.log(`  -h, --help      Show this comprehensive workspace helper panel`);
@@ -1766,7 +1766,7 @@ async function main() {
     let detectedFrameworks = []; 
 
     console.log(`\n${'═'.repeat(67)}`);
-    console.log(`🚀 entkapp v4.1.0: Enterprise Graph Intelligence Analyzer`);
+    console.log(`🚀 entkapp v4.2.0: Enterprise Graph Intelligence Analyzer`);
     console.log(`${'═'.repeat(67)}\n`);
 
     const topLevelItems = fs.readdirSync(targetDir);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "name": "entkapp",
-  "version": "4.1.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",
@@ -64,7 +64,12 @@
     "unresolved",
     "unused",
     "unused-packages",
-    "workspace"
+    "workspace",
+    "entkapp",
+    "cut",
+    "kapp",
+    "dreamlong",
+    "DreamLong"
   ],
   "author": "DreamLongYT",
   "license": "Apache-2.0",
@@ -86,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/api/HeadlessAPI.js

@@ -1,6 +1,6 @@
 /**
  * ============================================================================
- * Headless API for entkapp v4.1.0
+ * Headless API for entkapp v4.2.0
  * ============================================================================
  * Provides a programmatic interface for integrating entkapp into
  * custom workflows, CI/CD pipelines, and third-party tools.

package/src/api/PluginSDK.js

@@ -1,6 +1,6 @@
 /**
  * ============================================================================
- * Plugin SDK for entkapp v4.0.0
+ * Plugin SDK for entkapp v4.2.0
  * ============================================================================
  * Provides utilities and helpers for developing custom plugins that extend
  * entkapp's analysis and healing capabilities.

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/BarrelParser.js

@@ -178,15 +178,6 @@ 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);
       
@@ -195,24 +186,15 @@ export class BarrelParser {
           fullyResolvedPath,
           targetSymbolName,
           activeProjectGraph,
-          new Set(protectionStack) // Use a copy so sibling branches don't block each other
+          new Set(protectionStack)
         );
 
         if (!continuousResolutionTrace) continue;
-        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)) {
           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,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

@@ -3,20 +3,17 @@ export class OxcAnalyzer {
     this.context = context;
     this.oxc = null;
     this.isAvailable = false;
-    // Initialization is handled via init() or lazily during parseFile
   }
 
   async init() {
     if (this.isAvailable) return true;
     try {
-      // In ESM, we use dynamic import()
       const oxc = await import("oxc-parser");
       this.oxc = oxc;
       this.isAvailable = true;
       return true;
     } catch (e) {
       try {
-        // Fallback for older node versions or specific bundling setups
         const { createRequire } = await import('module');
         const require = createRequire(import.meta.url);
         this.oxc = require("oxc-parser");
@@ -25,7 +22,7 @@ export class OxcAnalyzer {
       } catch (err) {
         this.isAvailable = false;
         if (this.context.verbose) {
-          console.warn("[OxcAnalyzer] oxc-parser not found or failed to load, falling back to TypeScript compiler API.");
+          console.warn("[OxcAnalyzer] oxc-parser not found or failed to load.");
         }
         return false;
       }
@@ -39,24 +36,18 @@ export class OxcAnalyzer {
     }
 
     try {
-      if (this.context.verbose) {
-        console.log(`[OXC] Fast-parsing: ${filePath}`);
-      }
-
       const ast = this.oxc.parseSync(content, {
         sourceType: "module",
         sourceFilename: filePath,
         ecmaVersion: "latest",
       });
 
-      // Initialize new properties for JSX and Decorator analysis
       fileNode.jsxComponents = new Set();
       fileNode.jsxProps = new Set();
       fileNode.decorators = new Set();
 
       this.walkOxcAst(ast.program, fileNode, content);
       
-      // Compute line/column for each export start position
       const lines = content.split('\n');
       const getLineCol = (pos) => {
         let count = 0;
@@ -100,19 +91,17 @@ export class OxcAnalyzer {
         this.handleCallExpression(node, fileNode);
         break;
       case "JSXElement":
-      case "JSXFragment": // Consider fragments as well
+      case "JSXFragment":
         this.handleJsxElement(node, fileNode);
         break;
       case "Decorator":
         this.handleDecorator(node, fileNode);
         break;
       case "StringLiteral":
-        // Track for secret scanning if it looks like a secret
         fileNode.rawStringReferences.add(node.value);
         break;
     }
 
-    // Traverse children
     for (const key in node) {
       if (node[key] && typeof node[key] === "object") {
         if (Array.isArray(node[key])) {
@@ -128,7 +117,6 @@ export class OxcAnalyzer {
     const specifier = node.source.value;
     fileNode.explicitImports.add(specifier);
 
-    // Track external package usage for dependency analysis
     if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
       fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
     }
@@ -136,7 +124,7 @@ export class OxcAnalyzer {
     if (node.specifiers) {
       node.specifiers.forEach((spec) => {
         if (spec.type === "ImportSpecifier") {
-          const importedName = spec.imported.name;
+          const importedName = spec.imported.name || (spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value);
           fileNode.importedSymbols.add(`${specifier}:${importedName}`);
         } else if (spec.type === "ImportDefaultSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:default`);
@@ -148,86 +136,83 @@ export class OxcAnalyzer {
   }
 
   handleExportDeclaration(node, fileNode, content) {
+    // 1. Default Exports
     if (node.type === "ExportDefaultDeclaration") {
-      fileNode.internalExports.set("default", { type: "default", start: node.start, end: node.end });
+      fileNode.internalExports.set("default", { 
+        type: "default", 
+        start: node.start, 
+        end: node.end 
+      });
       return;
     }
 
+    // 2. Re-export All: export * from 'mod' or export * as ns from 'mod'
     if (node.type === "ExportAllDeclaration") {
-      const sourceSpecifier = node.source ? node.source.value : null;
-      if (sourceSpecifier) {
-        // Register re-export source as an explicit import so the graph linker
-        // creates an incomingEdge on the re-exported file.
-        fileNode.explicitImports.add(sourceSpecifier);
-
-        // Track external package usage from re-exports
-        if (!sourceSpecifier.startsWith('.') && !sourceSpecifier.startsWith('/')) {
-          fileNode.externalPackageUsage.add(this._extractPackageName(sourceSpecifier));
-        }
+      const sourceSpecifier = node.source.value;
+      fileNode.explicitImports.add(sourceSpecifier);
+      if (!sourceSpecifier.startsWith('.') && !sourceSpecifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(sourceSpecifier));
+      }
 
-        if (node.exported) {
-          // export * as name from 'module'
-          const name = node.exported.name || (node.exported.type === "Identifier" ? node.exported.name : null);
-          if (name) {
-            fileNode.internalExports.set(name, { type: "re-export-namespace", source: sourceSpecifier, originalName: "*", start: node.start, end: node.end });
-            fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
-          }
-        } else {
-          // export * from 'module'
-          fileNode.internalExports.set("*", { type: "re-export-all", source: sourceSpecifier });
-          // Register as wildcard importedSymbol so graph linker creates incomingEdge
+      if (node.exported) {
+        // export * as ns from 'mod'
+        const name = node.exported.name || (node.exported.type === "Identifier" ? node.exported.name : null);
+        if (name) {
+          fileNode.internalExports.set(name, { 
+            type: "re-export-namespace", 
+            source: sourceSpecifier, 
+            originalName: "*", 
+            start: node.start, 
+            end: node.end 
+          });
           fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
         }
+      } else {
+        // export * from 'mod'
+        fileNode.internalExports.set("*", { 
+          type: "re-export-all", 
+          source: sourceSpecifier 
+        });
+        fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
       }
       return;
     }
 
+    // 3. Named Exports & Re-exports with specifiers
     if (node.source) {
-      // Re-export with source: export { x } from 'module'
+      // Re-export: export { x } from 'mod'
       const specifier = node.source.value;
-      // Register re-export source as an explicit import
       fileNode.explicitImports.add(specifier);
-
-      // Track external package usage from re-exports
       if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
         fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
       }
 
       if (node.specifiers) {
         node.specifiers.forEach((spec) => {
-          const exportedName = spec.exported.name;
-          const localName = spec.local.name;
+          const exportedName = spec.exported.name || (spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value);
+          const localName = spec.local.name || (spec.local.type === "Identifier" ? spec.local.name : spec.local.value);
           fileNode.internalExports.set(exportedName, {
             type: "re-export",
             source: specifier,
             originalName: localName,
-            start: node.start,
-            end: node.end,
+            start: spec.start,
+            end: spec.end,
           });
-          // Register as importedSymbol so barrel-tracer can resolve origin file
           fileNode.importedSymbols.add(`${specifier}:${localName}`);
         });
       }
     } else if (node.declaration) {
-      // Direct export
+      // Direct declaration export: export const x = 1, export function f() {}
       const decl = node.declaration;
       if (decl.type === "VariableDeclaration") {
         decl.declarations.forEach((d) => {
-          if (d.id.type === "Identifier") {
-            fileNode.internalExports.set(d.id.name, { type: "variable", start: d.start, end: d.end });
-          } else if (d.id.type === "ObjectPattern") {
-            d.id.properties.forEach((p) => {
-              if (p.type === "Property" && p.value.type === "Identifier") {
-                fileNode.internalExports.set(p.value.name, { type: "variable", start: p.start, end: p.end });
-              }
-            });
-          } else if (d.id.type === "ArrayPattern") {
-            d.id.elements.forEach((e) => {
-              if (e && e.type === "Identifier") {
-                fileNode.internalExports.set(e.name, { type: "variable", start: e.start, end: e.end });
-              }
+          this._extractNamesFromPattern(d.id, (name) => {
+            fileNode.internalExports.set(name, { 
+              type: "variable", 
+              start: d.start, 
+              end: d.end 
             });
-          }
+          });
         });
       } else if (decl.id && decl.id.name) {
         let type = "unknown";
@@ -238,49 +223,70 @@ export class OxcAnalyzer {
         else if (decl.type === "TSTypeAliasDeclaration") type = "type";
         else if (decl.type === "TSModuleDeclaration") type = "namespace";
 
-        const exportInfo = { type, start: decl.start, end: decl.end };
-        fileNode.internalExports.set(decl.id.name, exportInfo);
-
-        if (decl.type === "TSEnumDeclaration") {
-          exportInfo.members = decl.members.map((m) => m.id.name || (m.id.type === "Identifier" ? m.id.name : ""));
-        } else if (decl.type === "TSInterfaceDeclaration" || decl.type === "ClassDeclaration") {
-          exportInfo.members = decl.body.body.filter((m) => m.key && m.key.name).map((m) => m.key.name);
-        }
+        fileNode.internalExports.set(decl.id.name, { 
+          type, 
+          start: decl.start, 
+          end: decl.end 
+        });
       }
     } else if (node.specifiers) {
+      // Export existing locals: export { x, y as z }
       node.specifiers.forEach((spec) => {
-        const exportedName = spec.exported.name;
-        const localName = spec.local.name;
+        const exportedName = spec.exported.name || (spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value);
+        const localName = spec.local.name || (spec.local.type === "Identifier" ? spec.local.name : spec.local.value);
         fileNode.internalExports.set(exportedName, {
           type: "export",
           originalName: localName,
-          start: node.start,
-          end: node.end,
+          start: spec.start,
+          end: spec.end,
         });
       });
     }
   }
 
+  _extractNamesFromPattern(node, callback) {
+    if (!node) return;
+    if (node.type === "Identifier") {
+      callback(node.name);
+    } else if (node.type === "ObjectPattern") {
+      node.properties.forEach(p => {
+        if (p.type === "Property") {
+          this._extractNamesFromPattern(p.value, callback);
+        } else if (p.type === "RestElement") {
+          this._extractNamesFromPattern(p.argument, callback);
+        }
+      });
+    } else if (node.type === "ArrayPattern") {
+      node.elements.forEach(e => {
+        if (e) this._extractNamesFromPattern(e, callback);
+      });
+    } else if (node.type === "AssignmentPattern") {
+      this._extractNamesFromPattern(node.left, callback);
+    } else if (node.type === "RestElement") {
+      this._extractNamesFromPattern(node.argument, callback);
+    }
+  }
+
   handleCallExpression(node, fileNode) {
     // 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);
         fileNode.dynamicImports.add(specifier);
+        fileNode.importedSymbols.add(`${specifier}:*`); // Dynamic import usually consumes the whole namespace
         if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
           fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
         }
-      } else {
-        // Non-literal dynamic import: record as calculated
-        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;
       fileNode.explicitImports.add(specifier);
+      fileNode.importedSymbols.add(`${specifier}:*`);
       if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
         fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
       }
@@ -291,6 +297,7 @@ export class OxcAnalyzer {
     const getElementName = (nameNode) => {
       if (nameNode.type === "JSXIdentifier") return nameNode.name;
       if (nameNode.type === "JSXMemberExpression") return `${getElementName(nameNode.object)}.${nameNode.property.name}`;
+      if (nameNode.type === "JSXNamespacedName") return `${nameNode.namespace.name}:${nameNode.name.name}`;
       return "unknown";
     };
 
@@ -311,19 +318,17 @@ export class OxcAnalyzer {
   handleDecorator(node, fileNode) {
     const getDecoratorName = (expr) => {
       if (expr.type === "Identifier") return expr.name;
-      if (expr.type === "CallExpression" && expr.callee.type === "Identifier") return expr.callee.name;
-      if (expr.type === "CallExpression" && expr.callee.type === "MemberExpression" && expr.callee.property.type === "Identifier") return expr.callee.property.name;
+      if (expr.type === "CallExpression") return getDecoratorName(expr.callee);
+      if (expr.type === "MemberExpression") {
+        const prop = expr.property.name || expr.property.value;
+        return prop || "unknown";
+      }
       return "unknown";
     };
 
     const decoratorName = getDecoratorName(node.expression);
-    fileNode.decorators.add(decoratorName);
-
-    // Optionally, extract decorator arguments
-    if (node.expression.type === "CallExpression") {
-      node.expression.arguments.forEach(arg => {
-        // Further analysis of arguments can be done here if needed
-      });
+    if (decoratorName !== "unknown") {
+      fileNode.decorators.add(decoratorName);
     }
   }
 

package/src/index.js

@@ -3,7 +3,7 @@ import { OxcAnalyzer } from "./ast/OxcAnalyzer.js";
 import { SecretScanner } from './ast/SecretScanner.js';
 /**
  * ============================================================================
- * 📦 entkapp v4.1.0: Unified Architectural Refactoring Orchestrator
+ * 📦 entkapp v4.2.0: Unified Architectural Refactoring Orchestrator
  * ============================================================================
  * Main execution bridge managing multi-pass compilation cycles, semantic cross-linking,
  * supply-chain validation audits, and automated structural healing rollbacks.
@@ -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...'));
@@ -262,7 +280,11 @@ export class RefactoringEngine {
       if (!this.context.unlistedDependencies) this.context.unlistedDependencies = [];
 
       // Simple internal helper to guarantee matching forward slash strings across all platforms
-      const slashify = (p) => path.resolve(this.context.cwd, p).replace(/\\/g, '/');
+      const slashify = (p) => {
+        if (!p) return p;
+        if (Array.isArray(p)) p = p[0];
+        return path.resolve(this.context.cwd, p).replace(/\\/g, '/');
+      };
 
       if (this.context.projectGraph && typeof this.context.projectGraph.entries === 'function') {
         for (const [filePath, fileNode] of this.context.projectGraph.entries()) {
@@ -271,12 +293,10 @@ export class RefactoringEngine {
           const cleanFilePath = slashify(filePath);
 
           // 🚀 ROOT DEPS HARVESTER SHADOW TRACKING:
-          // If external packages are parsed from ANY file node in the monorepo, 
-          // ensure the auditor registries register their footprint so root checking works!
           if (fileNode.externalPackageUsage) {
             fileNode.externalPackageUsage.forEach(pkg => {
-              const relativeToRoot = path.relative(this.context.cwd, filePath);
-              if (relativeToRoot.startsWith('packages' + path.sep) || relativeToRoot.startsWith('packages/')) {
+              const relativeToRoot = path.relative(this.context.cwd, filePath).replace(/\\/g, '/');
+              if (relativeToRoot.startsWith('packages/')) {
                 this.context.consumedWorkspacePackages.add(pkg);
               } else {
                 this.context.consumedRootPackages.add(pkg);
@@ -294,17 +314,17 @@ export class RefactoringEngine {
               if (!this.context.exportRegistry.has(cleanFilePath)) {
                 this.context.exportRegistry.set(cleanFilePath, new Set());
               }
-              exportKeys.forEach(key => this.context.exportRegistry.get(cleanFilePath).add(key));
+              exportKeys.forEach(key => {
+                if (key !== '*') { // Don't track wildcard as a dead export symbol
+                  this.context.exportRegistry.get(cleanFilePath).add(key);
+                }
+              });
             }
           }
 
           // 2. Gather cross-file usage tokens using unified slashes
-          if (fileNode.explicitImports && fileNode.importedSymbols) {
-            const symbolsArray = typeof fileNode.importedSymbols.forEach === 'function'
-              ? Array.from(fileNode.importedSymbols)
-              : (Array.isArray(fileNode.importedSymbols) ? fileNode.importedSymbols : []);
-
-            for (const symbolToken of symbolsArray) {
+          if (fileNode.importedSymbols) {
+            for (const symbolToken of fileNode.importedSymbols) {
               if (typeof symbolToken !== 'string') continue;
 
               const splitIndex = symbolToken.indexOf(':');
@@ -314,31 +334,20 @@ export class RefactoringEngine {
               const symbolName = symbolToken.slice(splitIndex + 1);
 
               let targetFile = null;
-              if (this.workspaceGraph && typeof this.workspaceGraph.isLocalWorkspaceSpecifier === 'function' && this.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+              // If specifier is already an absolute path (resolved during linkDependencyGraph)
+              if (path.isAbsolute(specifier)) {
+                targetFile = specifier;
+              } else if (this.workspaceGraph && this.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
                 const match = this.workspaceGraph.getWorkspacePackageMatch(specifier);
                 if (match && match.entryPoints && match.entryPoints.length > 0) {
-                  targetFile = Array.isArray(match.entryPoints) ? match.entryPoints : match.entryPoints;
+                  targetFile = match.entryPoints[0];
                 }
               } else if (specifier.startsWith('.')) {
-                targetFile = path.resolve(path.dirname(filePath), specifier);
-                
-                // 🚀 COMPILE-TO-SOURCE EXTENSION SWAP:
-                // If a barrel file imports relative paths using compiled targets (like './used-fn.js'),
-                // replace the extension to check for active source components directly ('.ts' / '.tsx')
-                if (targetFile.endsWith('.js')) {
-                  targetFile = targetFile.slice(0, -3);
-                }
-
-                if (!path.extname(targetFile)) {
-                  if (existsSync(targetFile + '.ts')) targetFile += '.ts';
-                  else if (existsSync(targetFile + '.tsx')) targetFile += '.tsx';
-                  else if (existsSync(targetFile + '.js')) targetFile += '.js';
-                }
+                targetFile = this.resolver.resolveModulePath(filePath, specifier);
               }
 
               if (targetFile) {
-                // Enforce uniform forward slash formats on targets
-                const cleanTargetFile = Array.isArray(targetFile) ? slashify(targetFile[0]) : slashify(targetFile);
+                const cleanTargetFile = slashify(targetFile);
                 this.context.importUsageRegistry.add(`${cleanTargetFile}:${symbolName}`);
               }
             }
@@ -478,16 +487,35 @@ 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) {
             const consumptionToken = `${cleanExportedFile}:${symbol}`;
             if (!this.context.importUsageRegistry?.has(consumptionToken)) {
-              analysisSummary.deadExports.push({
+              // Retrieve the real source location if available
+              const loc = (originalNode && originalNode.symbolSourceLocations) ? originalNode.symbolSourceLocations.get(symbol) || { line: 0 } : { line: 0 };
+              unusedExportsInThisFile.push({
                 symbol: symbol,
                 file: relativeExportedFile,
-                line: 7
+                line: loc.line
               });
             }
           }
+
+          // --- NEW: Orphaned File Detection based on Export Coverage ---
+          // If every single export in this file is unused, and it's not an entry point,
+          // we suggest deleting the entire file instead of pruning individual exports.
+          if (unusedExportsInThisFile.length > 0 && unusedExportsInThisFile.length === exportsSet.size) {
+            if (!analysisSummary.orphanedFiles.includes(relativeExportedFile)) {
+              analysisSummary.orphanedFiles.push(relativeExportedFile);
+            }
+          } else {
+            // Otherwise, just append the individual dead exports as usual
+            analysisSummary.deadExports.push(...unusedExportsInThisFile);
+          }
         }
       }
       analysisSummary.unlistedDependencies = this.context.unlistedDependencies || [];
@@ -592,40 +620,68 @@ 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;
+          }
         }
       }
     }
   }
 
   async linkDependencyGraph() {
+    // Pass 1: Global Entry-Point Protection (Seeds)
+    // Mark all package entry points and explicit config entry points as library entries first.
+    const seeds = new Set();
+    
+    // Add workspace entry points
+    if (this.workspaceGraph && this.workspaceGraph.packageManifests) {
+      for (const pkg of this.workspaceGraph.packageManifests.values()) {
+        if (pkg.entryPoints) {
+          pkg.entryPoints.forEach(ep => seeds.add(path.resolve(ep)));
+        }
+      }
+    }
+
+    // Add explicit config entry points
+    if (this.context.entryPoints) {
+      this.context.entryPoints.forEach(ep => seeds.add(path.resolve(this.context.cwd, ep)));
+    }
+
+    for (const seedPath of seeds) {
+      if (this.context.projectGraph.has(seedPath)) {
+        const node = this.context.projectGraph.get(seedPath);
+        node.isLibraryEntry = true;
+        node.isEntry = true;
+      }
+    }
+
+    // Pass 2: Edge Linking
     for (const [filePath, node] of this.context.projectGraph.entries()) {
-      // Pass A: Link all explicit imports (static + dynamic + re-export sources)
+      // A. Explicit Imports (Files)
       for (const specifier of node.explicitImports) {
         const resolvedPath = this.resolver.resolveModulePath(filePath, specifier);
         if (resolvedPath && this.context.projectGraph.has(resolvedPath)) {
-          this.context.projectGraph.get(resolvedPath).incomingEdges.add(filePath);
+          const targetNode = this.context.projectGraph.get(resolvedPath);
+          targetNode.incomingEdges.add(filePath);
           node.outgoingEdges.add(resolvedPath);
           
-          // Fix: Ensure all internal exports from a re-exported source are marked as used
-          // so the source file itself is never considered orphaned.
-          const targetNode = this.context.projectGraph.get(resolvedPath);
-          const isReExport = Array.from(node.internalExports.values()).some(exp => exp.source === specifier);
-          if (isReExport) {
-            targetNode.isLibraryEntry = true; // Protect re-exported internal files
+          // Re-export protection: If this file re-exports everything from another file, 
+          // the target file should be treated as an entry point for its own exports.
+          const isReExportAll = Array.from(node.internalExports.values()).some(exp => 
+            (exp.type === "re-export-all" || exp.type === "re-export-namespace") && exp.source === specifier
+          );
+          if (isReExportAll) {
+            targetNode.isLibraryEntry = true; 
           }
         }
       }
 
-      // Pass A.2: Mark package entry points as library entries
-      for (const pkg of this.workspaceGraph.packageManifests.values()) {
-        for (const entryPath of pkg.entryPoints) {
-          if (this.context.projectGraph.has(entryPath)) {
-            this.context.projectGraph.get(entryPath).isLibraryEntry = true;
-          }
-        }
-      }
-
-      // Pass B: Link named-symbol imports through barrel/re-export chains
+      // B. Symbol-level Linking (Tracing through barrels)
       for (const specToken of node.importedSymbols) {
         const delimiterIndex = specToken.indexOf(':');
         if (delimiterIndex === -1) continue;
@@ -636,18 +692,55 @@ export class RefactoringEngine {
         if (!resolvedPath) continue;
 
         if (symbol === '*') {
-          // Wildcard import / re-export-all: add a direct edge to the resolved file.
           if (this.context.projectGraph.has(resolvedPath)) {
             this.context.projectGraph.get(resolvedPath).incomingEdges.add(filePath);
             node.outgoingEdges.add(resolvedPath);
           }
         } else {
-          // Named import: trace through barrel files to the actual declaration origin.
           const traceResolution = await this.barrelParser.determineSymbolDeclarationOrigin(resolvedPath, symbol, this.context.projectGraph);
           if (traceResolution && this.context.projectGraph.has(traceResolution.originFile)) {
-            this.context.projectGraph.get(traceResolution.originFile).incomingEdges.add(filePath);
+            const originNode = this.context.projectGraph.get(traceResolution.originFile);
+            originNode.incomingEdges.add(filePath);
             node.outgoingEdges.add(traceResolution.originFile);
-            node.importedSymbols.add(`${traceResolution.originFile}:${traceResolution.symbolName}`);
+            // Register the actual resolved symbol for dead export detection
+            node.importedSymbols.add(`${traceResolution.originFile}:${traceResolution.originSymbol}`);
+          }
+        }
+      }
+
+      // 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}`));
+               }
+            }
           }
         }
       }

package/src/performance/WorkerTaskRunner.js

@@ -0,0 +1,87 @@
+import { parentPort, workerData } from 'worker_threads';
+import fs from 'fs/promises';
+import { ASTAnalyzer } from '../ast/ASTAnalyzer.js';
+import { OxcAnalyzer } from '../ast/OxcAnalyzer.js';
+
+/**
+ * Worker Thread Execution Script
+ * Handles parallel AST parsing for a chunk of files and returns serialized results.
+ */
+async function runTask() {
+  const { files, contextOptions } = workerData;
+  const results = [];
+
+  // Create a minimal context for analyzers
+  const mockContext = {
+    verbose: contextOptions.verbose,
+    projectGraph: new Map(),
+    getOrCreateNode: (path) => ({
+      filePath: path,
+      explicitImports: new Set(),
+      dynamicImports: new Set(),
+      importedSymbols: new Set(),
+      rawStringReferences: new Set(),
+      instantiatedIdentifiers: new Set(),
+      propertyAccessChains: new Set(),
+      internalExports: new Map(),
+      securityThreats: [],
+      localSuppressedRules: new Set(),
+      externalPackageUsage: new Set(),
+      symbolSourceLocations: new Map(),
+      jsxComponents: new Set(),
+      jsxProps: new Set(),
+      decorators: new Set(),
+      isFrameworkContract: false
+    })
+  };
+
+  const astAnalyzer = new ASTAnalyzer(mockContext);
+  const oxcAnalyzer = new OxcAnalyzer(mockContext);
+
+  for (const filePath of files) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const node = mockContext.getOrCreateNode(filePath);
+
+      // Use OXC if available, fallback to TS AST
+      if (oxcAnalyzer.isAvailable) {
+        await oxcAnalyzer.parseFile(filePath, content, node);
+      } else {
+        await astAnalyzer.parseFile(filePath, content, node);
+      }
+
+      // Serialize the node data for transfer back to main thread
+      results.push({
+        filePath: node.filePath,
+        explicitImports: Array.from(node.explicitImports),
+        dynamicImports: Array.from(node.dynamicImports),
+        importedSymbols: Array.from(node.importedSymbols),
+        rawStringReferences: Array.from(node.rawStringReferences),
+        instantiatedIdentifiers: Array.from(node.instantiatedIdentifiers),
+        propertyAccessChains: Array.from(node.propertyAccessChains),
+        internalExports: Object.fromEntries(node.internalExports),
+        securityThreats: node.securityThreats,
+        localSuppressedRules: Array.from(node.localSuppressedRules),
+        externalPackageUsage: Array.from(node.externalPackageUsage),
+        symbolSourceLocations: Object.fromEntries(node.symbolSourceLocations),
+        jsxComponents: Array.from(node.jsxComponents),
+        jsxProps: Array.from(node.jsxProps),
+        decorators: Array.from(node.decorators),
+        isFrameworkContract: node.isFrameworkContract
+      });
+    } catch (err) {
+      if (contextOptions.verbose) {
+        console.error(`[Worker] Failed to parse ${filePath}: ${err.message}`);
+      }
+      // Push null to keep array indices if needed, or just skip
+      results.push(null);
+    }
+  }
+
+  parentPort.postMessage(results);
+}
+
+runTask().catch(err => {
+  console.error(`[Worker Critical Fault] ${err.stack}`);
+  process.exit(1);
+});

package/src/plugins/ecosystems/BackendServices.js

@@ -1,6 +1,6 @@
 /**
  * ============================================================================
- * Backend Services Plugins for entkapp v4.1.0
+ * Backend Services Plugins for entkapp v4.2.0
  * ============================================================================
  * Built-in support for GraphQL, REST APIs, and Databases.
  */

package/src/plugins/ecosystems/ModernFrameworks.js

@@ -1,6 +1,6 @@
 /**
  * ============================================================================
- * Modern Frameworks Plugins for entkapp v4.0.0
+ * Modern Frameworks Plugins for entkapp v4.2.0
  * ============================================================================
  * Built-in support for React, Vue, Svelte, and Angular.
  */