entkapp 4.3.0 → 4.4.1

package/.scaffold-ignore

@@ -1,5 +1,5 @@
 # ============================================================================
-# ⚙️ entkapp Rule Suppression & Intent Profiles
+# ⚙️ loui Rule Suppression & Intent Profiles
 # ============================================================================
 # Define exact symbols, file patterns, or dependency keys that must remain 
 # preserved during dead-code scanning and transactional refactoring pruning.

package/README.md

@@ -28,19 +28,6 @@ It represents the process of stripping away the unnecessary layers of a codebase
 ## 📦 Installation
 
 ```bash
-npm install -g entkapp
+npm install -D entkapp
 # or
-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!
-```
+pnpm add -D entkapp

package/bin/cli.js

@@ -28,15 +28,15 @@ async function bootstrap() {
     program
       .name('entkapp')
       .description(ansis.cyan('Enterprise-Grade AST Syntax Refactoring & Self-Healing Engine'))
-      .version(packageJsonContent.version || '4.3.0');
+      .version(packageJsonContent.version || '4.4.1');
 
     program
       .option('-c, --cwd <path>', 'Specify the execution context root directory', process.cwd())
       .option('-d, --debug', 'Developer`s comprehensive telemetry debug diagnostics', false)
-      .option('--fix', 'Enable atomic code updates, structural file pruning, and active type sanitization', true)
-      .option('--no-fix', 'Disable direct file manipulation modifications (dry-run reporting mode)')
+      .option('--fix', 'Enable atomic code updates, structural file pruning, and active type sanitization', false)
       .option('--tsconfig <filename>', 'Specify path to custom layout configurations', 'tsconfig.json')
       .option('--test-command <command>', 'Integrated continuous safety test validation script execution path', 'npm test')
+      .option('--no-fix', 'Deprecated flag, this is now default')
       .option('--workspace', 'Enable high-density workspace workspace/monorepo cluster mesh evaluation parsing', false)
       .option('--verbose', 'Toggle expanded trace telemetry for debug operational diagnostics', false)
       .option('-r, --run', 'Execute the primary operational pipeline loop', false)
@@ -45,7 +45,10 @@ async function bootstrap() {
 
     program.parse(process.argv);
     const options = program.opts();
-
+    if (args.includes('--no-fix')) {
+      console.warn("\n⚠️  [DEPRECATION] The --no-fix flag is deprecated. No-fix is now the default behavior.");
+      console.warn("👉 To apply structural changes, use the --fix flag instead.\n");
+    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
     // --- Onboarding Check (Skipped in Non-Interactive Mode) ---
@@ -66,7 +69,7 @@ async function bootstrap() {
         const answer = await rl.question(ansis.bold.yellow('❓ No "entkapp:run" script found in package.json. Install it? (y/n): '));
         if (answer.toLowerCase() === 'y') {
           pkgJson.scripts = pkgJson.scripts || {};
-          pkgJson.scripts['entkapp:run'] = 'npx entkapp --fix';
+          pkgJson.scripts['entkapp:run'] = 'npx entkapp';
           await fs.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
           console.log(ansis.green('✅ "entkapp:run" script added to package.json.'));
         }
@@ -90,7 +93,7 @@ async function bootstrap() {
             enabledPlugins: ["nextjs", "nuxt", "remix", "sveltekit", "astro"]
           };
           await fs.writeFile(path.join(configDirPath, 'config.json'), JSON.stringify(defaultConfig, null, 2));
-          console.log(ansis.green('✅ "/entkapp" folder? and default config created.'));
+          console.log(ansis.green('✅ "/entkapp" folder and default config created.'));
           configInstalled = true;
         }
       }
@@ -132,7 +135,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.3.0'} Engine Activation`));
+    console.log(ansis.bold.green(`\n📦 entkapp v${packageJsonContent.version || '4.4.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/index.js

@@ -2,7 +2,7 @@
 
 /**
  * ============================================================================
- * 📦 entkapp v4.2.0: Ultimate Enterprise Codebase Janitor & Self-Healing Engine
+ * 📦 entkapp v4.1.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.2.0' },
+            headers: { 'User-Agent': 'entkapp-dx-client/4.1.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.2.0' },
+            headers: { 'User-Agent': 'entkapp-dx-client/4.1.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.2.0: Advanced Dependency Intelligence Engine\n`);
+        console.log(`\n📦 entkapp v4.1.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.2.0: Enterprise Graph Intelligence Analyzer`);
+    console.log(`🚀 entkapp v4.1.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.3.0",
+  "version": "4.4.1",
   "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,12 +64,7 @@
     "unresolved",
     "unused",
     "unused-packages",
-    "workspace",
-    "entkapp",
-    "cut",
-    "kapp",
-    "dreamlong",
-    "DreamLong"
+    "workspace"
   ],
   "author": "DreamLongYT",
   "license": "Apache-2.0",
@@ -91,6 +86,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
+    "knip": "^6.17.1",
     "vitepress": "^1.6.4",
     "vue": ">=3.5.0"
   },

package/src/EngineContext.js

@@ -31,16 +31,12 @@ export class GraphNode {
     this.localSuppressedRules = new Set();
   }
 
-  isSymbolReferencedExternally(symbolName, projectGraph, context) {
+  isSymbolReferencedExternally(symbolName, projectGraph, visited = new Set()) {
+    const visitKey = `${this.filePath}:${symbolName}`;
+    if (visited.has(visitKey)) return false;
+    visited.add(visitKey);
+
     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.
@@ -80,6 +76,20 @@ export class GraphNode {
         return true;
       }
 
+      // NEW: Check for re-exports that might use this symbol (Recursive Barrel Resolution)
+      for (const [exportedName, exportMeta] of parentNode.internalExports.entries()) {
+        const isMatch = (exportMeta.type === 're-export' || exportMeta.type === 're-export-namespace') && 
+                        (exportMeta.originalName === symbolName || exportMeta.originalName === '*') && 
+                        (exportMeta.source === this.filePath || (exportMeta.source && path.resolve(path.dirname(parentPath), exportMeta.source) === this.filePath));
+        
+        if (isMatch) {
+          // If this parent re-exports our symbol, check if the re-exported symbol is used
+          if (parentNode.isSymbolReferencedExternally(exportedName, projectGraph, visited)) {
+            return true;
+          }
+        }
+      }
+
       if (parentNode.instantiatedIdentifiers.has(symbolName)) return true;
       
       for (const accessChain of parentNode.propertyAccessChains) {
@@ -145,14 +155,12 @@ 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, this)) {
+        if (!node.isSymbolReferencedExternally(symbol, this.projectGraph)) {
           const loc = node.symbolSourceLocations.get(symbol) || { line: 0, column: 0 };
           report.deadExports.push({
             symbol,
@@ -168,9 +176,11 @@ export class EngineContext {
     for (const [manifestPath, deps] of this.manifestDependencies.entries()) {
       const allDeps = [...(deps.dependencies || []), ...(deps.devDependencies || [])];
       
+      const hasTypeScriptFiles = Array.from(this.projectGraph.keys()).some(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+      
       for (const dep of allDeps) {
         // Skip @types packages and known safe packages
-        if (dep.startsWith('@types/') || dep === 'entkapp') {
+        if (dep.startsWith('@types/') || dep === 'entkapp' || (dep === 'typescript' && hasTypeScriptFiles)) {
           continue;
         }
         

package/src/analyzers/OxcAnalyzer.js

@@ -0,0 +1,383 @@
+export class OxcAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.oxc = null;
+    this.isAvailable = false;
+  }
+
+  async init() {
+    if (this.isAvailable) return true;
+    try {
+      const oxc = await import("oxc-parser");
+      this.oxc = oxc;
+      this.isAvailable = true;
+      return true;
+    } catch (e) {
+      try {
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        this.oxc = require("oxc-parser");
+        this.isAvailable = true;
+        return true;
+      } catch (err) {
+        this.isAvailable = false;
+        if (this.context.verbose) {
+          console.warn(`[OxcAnalyzer] oxc-parser failed to load: ${err.message}`);
+        }
+        return false;
+      }
+    }
+  }
+
+  async parseFile(filePath, content, fileNode) {
+    if (!this.isAvailable) {
+      const initialized = await this.init();
+      if (!initialized) return false;
+    }
+
+    try {
+      // Fix: Ensure filePath is correctly handled for OXC (Windows path issue)
+      const normalizedPath = filePath.replace(/\\/g, '/');
+      
+      // Try passing the path directly as the second argument if the object-based options fail
+      // Some versions of oxc-parser expect a string as the second argument for the filename
+      let result;
+      try {
+        result = this.oxc.parseSync(content, {
+          sourceType: "module",
+          sourceFilename: normalizedPath,
+          lang: "typescript"
+        });
+      } catch (e) {
+        // Fallback for versions that expect the path as second argument
+        result = this.oxc.parseSync(content, normalizedPath);
+      }
+
+      // Fix: Handle cases where OXC returns a JSON string instead of an object
+      // Stabilize result through JSON round-trip to fix N-API conversion issues on Windows
+      let parsedResult;
+      try {
+        parsedResult = typeof result === 'string' ? JSON.parse(result) : JSON.parse(JSON.stringify(result));
+      } catch (err) {
+        if (typeof result === 'object') {
+          parsedResult = result; // Last resort
+        } else {
+          throw new Error("OXC returned an invalid format");
+        }
+      }
+
+      let ast;
+      if (parsedResult && typeof parsedResult === 'object') {
+        if (parsedResult.program) {
+          ast = parsedResult;
+        } else if (parsedResult.ast) {
+          ast = { program: parsedResult.ast };
+        } else {
+          ast = { program: parsedResult };
+        }
+      } else {
+        throw new Error("OXC returned an invalid AST format");
+      }
+
+      fileNode.ast = ast.program; // Store the AST for advanced analysis
+      fileNode.jsxComponents = new Set();
+      fileNode.jsxProps = new Set();
+      fileNode.decorators = new Set();
+
+      this.walkOxcAst(ast.program, fileNode, content);
+      
+      const lines = content.split('\n');
+      const getLineCol = (pos) => {
+        let count = 0;
+        for (let i = 0; i < lines.length; i++) {
+          if (count + lines[i].length + 1 > pos) {
+            return { line: i + 1, column: pos - count + 1 };
+          }
+          count += lines[i].length + 1;
+        }
+        return { line: 1, column: 1 };
+      };
+
+      for (const [name, meta] of fileNode.internalExports.entries()) {
+        if (meta.start !== undefined) {
+          fileNode.symbolSourceLocations.set(name, getLineCol(meta.start));
+        }
+      }
+
+      return true;
+    } catch (e) {
+      if (this.context.verbose) {
+        console.warn(`[OXC] Failed to parse ${filePath}. Error: ${e.message}`);
+        if (e.stack) console.debug(e.stack);
+        console.info(`[OXC] Switching back to TypeScript Compiler API for ${filePath}`);
+      }
+      return false;
+    }
+  }
+
+  walkOxcAst(node, fileNode, content) {
+    if (!node) return;
+
+    switch (node.type) {
+      case "ImportDeclaration":
+        this.handleImportDeclaration(node, fileNode);
+        break;
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration":
+      case "ExportAllDeclaration":
+        this.handleExportDeclaration(node, fileNode, content);
+        break;
+      case "CallExpression":
+        this.handleCallExpression(node, fileNode);
+        break;
+      case "JSXElement":
+      case "JSXFragment":
+        this.handleJsxElement(node, fileNode);
+        break;
+      case "Decorator":
+        this.handleDecorator(node, fileNode);
+        break;
+      case "StringLiteral":
+        fileNode.rawStringReferences.add(node.value);
+        break;
+    }
+
+    for (const key in node) {
+      if (node[key] && typeof node[key] === "object") {
+        if (Array.isArray(node[key])) {
+          node[key].forEach((child) => this.walkOxcAst(child, fileNode, content));
+        } else {
+          this.walkOxcAst(node[key], fileNode, content);
+        }
+      }
+    }
+  }
+
+  handleImportDeclaration(node, fileNode) {
+    const specifier = node.source.value;
+    fileNode.explicitImports.add(specifier);
+
+    if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+      fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+    }
+
+    if (node.specifiers) {
+      node.specifiers.forEach((spec) => {
+        if (spec.type === "ImportSpecifier") {
+          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`);
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          fileNode.importedSymbols.add(`${specifier}:*`);
+        }
+      });
+    }
+  }
+
+  handleExportDeclaration(node, fileNode, content) {
+    // 1. Default Exports
+    if (node.type === "ExportDefaultDeclaration") {
+      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.value;
+      fileNode.explicitImports.add(sourceSpecifier);
+      if (!sourceSpecifier.startsWith('.') && !sourceSpecifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(sourceSpecifier));
+      }
+
+      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: export { x } from 'mod'
+      const specifier = node.source.value;
+      fileNode.explicitImports.add(specifier);
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
+
+      if (node.specifiers) {
+        node.specifiers.forEach((spec) => {
+          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: spec.start,
+            end: spec.end,
+          });
+          fileNode.importedSymbols.add(`${specifier}:${localName}`);
+        });
+      }
+    } else if (node.declaration) {
+      // Direct declaration export: export const x = 1, export function f() {}
+      const decl = node.declaration;
+      if (decl.type === "VariableDeclaration") {
+        decl.declarations.forEach((d) => {
+          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";
+        if (decl.type === "FunctionDeclaration") type = "function";
+        else if (decl.type === "ClassDeclaration") type = "class";
+        else if (decl.type === "TSEnumDeclaration") type = "enum";
+        else if (decl.type === "TSInterfaceDeclaration") type = "interface";
+        else if (decl.type === "TSTypeAliasDeclaration") type = "type";
+        else if (decl.type === "TSModuleDeclaration") type = "namespace";
+
+        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 || (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: 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 (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 {
+        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));
+      }
+    }
+  }
+
+  handleJsxElement(node, fileNode) {
+    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";
+    };
+
+    if (node.openingElement) {
+      const tagName = getElementName(node.openingElement.name);
+      fileNode.jsxComponents.add(tagName);
+
+      if (node.openingElement.attributes) {
+        node.openingElement.attributes.forEach(attr => {
+          if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
+            fileNode.jsxProps.add(`${tagName}:${attr.name.name}`);
+          }
+        });
+      }
+    }
+  }
+
+  handleDecorator(node, fileNode) {
+    const getDecoratorName = (expr) => {
+      if (expr.type === "Identifier") return expr.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);
+    if (decoratorName !== "unknown") {
+      fileNode.decorators.add(decoratorName);
+    }
+  }
+
+  _extractPackageName(specifier) {
+    if (specifier.startsWith('@')) {
+      const parts = specifier.split('/');
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+    }
+    return specifier.split('/')[0];
+  }
+}

package/src/api/HeadlessAPI.js

@@ -1,6 +1,6 @@
 /**
  * ============================================================================
- * Headless API for entkapp v4.2.0
+ * Headless API for entkapp v4.1.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.2.0
+ * Plugin SDK for entkapp v4.0.0
  * ============================================================================
  * Provides utilities and helpers for developing custom plugins that extend
  * entkapp's analysis and healing capabilities.

package/src/ast/ASTAnalyzer.js

@@ -1,7 +1,6 @@
 import ts from 'typescript';
 import path from 'path';
 import fs from 'fs';
-import ansis from 'ansis';
 
 export class ASTAnalyzer {
   constructor(context) {
@@ -36,6 +35,7 @@ export class ASTAnalyzer {
     this.scopeStack.push(this.currentScope);
 
     this.extractTopLevelJSDocSuppreessions(sourceFile, fileNode);
+    fileNode.ast = sourceFile; // Store the AST for advanced analysis
     this.walkAST(sourceFile, fileNode, sourceFile);
 
     this.scopeStack.pop(); // Pop the global scope
@@ -399,14 +399,6 @@ 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);
@@ -414,6 +406,11 @@ 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') {