entkapp 5.0.0 → 5.2.0

package/package.json

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

package/src/EngineContext.js

@@ -189,7 +189,7 @@ export class EngineContext {
             });
 
             // --- PLUGIN-BASED ECOSYSTEM DETECTION ---
-            // Plugins will now handle their own erreichbarkeit and dependency validation.
+            // Plugins will now handle their own reachability and dependency validation.
             if (this.pluginRegistry) {
                 const activePlugins = await this.pluginRegistry.getActivePlugins(pkgDir);
                 for (const plugin of activePlugins) {

package/src/Initializer.js

@@ -0,0 +1,82 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+/**
+ * Entkapp Initializer: Analyzes the codebase to generate a package.json
+ * with correctly categorized dependencies and devDependencies.
+ */
+export class Initializer {
+  constructor(context) {
+    this.context = context;
+  }
+
+  async run() {
+    console.log("🚀 Starting entkapp intelligent initialization...");
+    const cwd = this.context.cwd || process.cwd();
+    
+    // 1. Scan for all JS/TS files
+    const files = await glob('**/*.{js,ts,jsx,tsx,vue,svelte,astro}', { 
+      ignore: ['node_modules/**', 'dist/**', '.git/**'],
+      cwd 
+    });
+
+    const dependencies = new Set();
+    const devDependencies = new Set();
+
+    // Common dev tool indicators
+    const devIndicators = ['test', 'spec', 'config', 'stories', 'mock'];
+
+    console.log(`🔍 Analyzing ${files.length} files for imports...`);
+
+    for (const file of files) {
+      const content = await fs.readFile(path.join(cwd, file), 'utf8');
+      const isDevFile = devIndicators.some(ind => file.toLowerCase().includes(ind));
+
+      // Simple but effective regex for imports
+      const importMatches = content.matchAll(/(?:import|from|require)\s*\(?\s*['"]([^' "./][^'"]*)['"]/g);
+      
+      for (const match of importMatches) {
+        const pkg = this.extractPackageName(match[1]);
+        if (pkg && !this.isBuiltIn(pkg)) {
+          if (isDevFile) devDependencies.add(pkg);
+          else dependencies.add(pkg);
+        }
+      }
+    }
+
+    // 2. Generate package.json
+    const pkgJson = {
+      name: path.basename(cwd),
+      version: "1.0.0",
+      description: "Initialized with entkapp",
+      main: "index.js",
+      scripts: {
+        "entkapp:run": "entkapp -r",
+        "entkapp:check": "entkapp --verbose"
+      },
+      dependencies: Object.fromEntries([...dependencies].sort().map(d => [d, "latest"])),
+      devDependencies: Object.fromEntries([...devDependencies].sort().map(d => [d, "latest"]))
+    };
+
+    await fs.writeFile(path.join(cwd, 'package.json'), JSON.stringify(pkgJson, null, 2));
+    console.log("✅ package.json generated with analyzed dependencies.");
+    
+    // 3. Create /entkapp folder
+    await fs.mkdir(path.join(cwd, 'entkapp'), { recursive: true });
+    console.log("✅ /entkapp configuration folder created.");
+  }
+
+  extractPackageName(specifier) {
+    if (specifier.startsWith('@')) {
+      const parts = specifier.split('/');
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return specifier.split('/')[0];
+  }
+
+  isBuiltIn(pkg) {
+    const builtins = ['path', 'fs', 'os', 'crypto', 'http', 'https', 'stream', 'util', 'events', 'module', 'process'];
+    return builtins.includes(pkg) || pkg.startsWith('node:');
+  }
+}

package/src/analyzers/CodeSmellAnalyzer.js

@@ -0,0 +1,106 @@
+/**
+ * CodeSmellAnalyzer: Performs deep static analysis to find runtime risks and logic smells.
+ */
+export class CodeSmellAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.issues = [];
+    this.rules = {
+      'potential-null-pointer': {
+        message: 'Potential Null Pointer Risk: Accessing property on an object that might be undefined.',
+        link: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_access_property'
+      },
+      'infinite-loop-risk': {
+        message: 'Potential Infinite Loop: Loop condition does not seem to change within the body.',
+        link: 'https://en.wikipedia.org/wiki/Infinite_loop'
+      },
+      'implicit-type-coercion': {
+        message: 'Implicit Type Coercion: Using loose equality (==) can lead to unexpected runtime behavior.',
+        link: 'https://dorey.github.io/JavaScript-Equality-Table/'
+      }
+    };
+  }
+
+  analyze(fileNode) {
+    if (!fileNode.ast) return;
+    this.walk(fileNode.ast, fileNode);
+  }
+
+  walk(node, fileNode) {
+    if (!node) return;
+
+    // 1. Check for Loose Equality (==)
+    if (node.type === 'BinaryExpression' && (node.operator === '==' || node.operator === '!=')) {
+      this.addIssue('implicit-type-coercion', node, fileNode);
+    }
+
+    // 2. Check for Potential Infinite Loops (While loops with static conditions)
+    if (node.type === 'WhileStatement' && node.test.type === 'Literal' && node.test.value === true) {
+      // Check if there is a break or return inside
+      if (!this.hasExitStatement(node.body)) {
+        this.addIssue('infinite-loop-risk', node, fileNode);
+      }
+    }
+
+    // 3. Check for Null Pointer Risks (Accessing properties on potentially uninitialized vars)
+    if (node.type === 'MemberExpression' && node.object.type === 'Identifier') {
+      const varName = node.object.name;
+      if (this.isPotentiallyNull(varName, fileNode)) {
+        this.addIssue('potential-null-pointer', node, fileNode);
+      }
+    }
+
+    // Recursively walk the AST
+    for (const key in node) {
+      if (node[key] && typeof node[key] === 'object') {
+        if (Array.isArray(node[key])) {
+          node[key].forEach(child => this.walk(child, fileNode));
+        } else {
+          this.walk(node[key], fileNode);
+        }
+      }
+    }
+  }
+
+  addIssue(ruleId, node, fileNode) {
+    const rule = this.rules[ruleId];
+    fileNode.diagnostics = fileNode.diagnostics || [];
+    fileNode.diagnostics.push({
+      ruleId,
+      message: rule.message,
+      link: rule.link,
+      line: node.start ? this.getLineNumber(node.start, fileNode.content) : 0,
+      severity: 'warning'
+    });
+  }
+
+  hasExitStatement(node) {
+    let found = false;
+    const check = (n) => {
+      if (!n || found) return;
+      if (n.type === 'BreakStatement' || n.type === 'ReturnStatement' || n.type === 'ThrowStatement') {
+        found = true;
+        return;
+      }
+      for (const key in n) {
+        if (n[key] && typeof n[key] === 'object') {
+          if (Array.isArray(n[key])) n[key].forEach(check);
+          else check(n[key]);
+        }
+      }
+    };
+    check(node);
+    return found;
+  }
+
+  isPotentiallyNull(name, fileNode) {
+    // Simple heuristic: if it's a variable declared without init or in a try-catch
+    const symbol = fileNode.symbolTable?.get(name);
+    return symbol && symbol.type === 'variable' && !symbol.initialized;
+  }
+
+  getLineNumber(pos, content) {
+    if (!content) return 0;
+    return content.substring(0, pos).split('\n').length;
+  }
+}

package/src/ast/ASTAnalyzer.js

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

package/src/ast/BarrelParser.js

@@ -7,7 +7,7 @@ import fs from 'fs/promises';
  */
 export class BarrelParser {
   constructor(context, resolver) {
-    this.context = context;
+    this.context = context; // Enthält globale Konfigurationen (z.B. context.entrypoints)
     this.resolver = resolver;
     this.cachedSpecifications = new Map();
   }
@@ -23,28 +23,43 @@ export class BarrelParser {
 
     const specification = {
       isBarrelInstance: false,
+      isApplicationEntrypoint: false,     // FIX: Schutzschicht für Einstiegspunkte gegen Fehldetektion
       wildcardExports: new Set(),         // export * from './module';
       namespacedWildcardExports: new Map(), // export * as Utils from './module';
       forwardedNamedExports: new Map(),   // export { token as alias } from './module';
       declaredLocalExports: new Set()      // export const a = 1;
     };
 
+    // FIX: Überprüfe, ob die aktuelle Datei als App-Einstiegspunkt deklariert ist
+    if (this.context && this.context.entrypoints) {
+      const isEntry = this.context.entrypoints.some(entry => 
+        this.resolver.resolveModulePath(filePath, entry) === filePath || entry === filePath
+      );
+      if (isEntry) {
+        specification.isApplicationEntrypoint = true;
+      }
+    }
+
     try {
       const code = await fs.readFile(filePath, 'utf8');
       const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
 
       this.harvestExportSignatures(sourceFile, specification);
 
-      if (specification.wildcardExports.size > 0 || 
+      // FIX: Eine Datei ist NUR DANN ein rein kosmetisches Barrel, wenn sie Re-Exports besitzt
+      // UND NICHT der geschützte Haupteinstiegspunkt (Entrypoint) der Anwendung ist!
+      if (!specification.isApplicationEntrypoint && (
+          specification.wildcardExports.size > 0 || 
           specification.namespacedWildcardExports.size > 0 || 
-          specification.forwardedNamedExports.size > 0) {
+          specification.forwardedNamedExports.size > 0
+      )) {
         specification.isBarrelInstance = true;
       }
 
       this.cachedSpecifications.set(filePath, specification);
       return specification;
     } catch {
-      return specification; // Error state defaults to safe boundaries layout manifest
+      return specification; // Error-State fällt auf sicheres Standard-Layout zurück
     }
   }
 
@@ -117,14 +132,7 @@ export class BarrelParser {
         break;
       }
 
-      // Track default exports declared directly within the file boundary:
-      // Handles both `export default function foo()` and `export default expression`.
-      // The canonical symbol name stored is 'default' so that forwardedNamedExports
-      // entries whose sourceSymbol is 'default' can resolve correctly via Rule A.
       case ts.SyntaxKind.ExportAssignment: {
-        // ExportAssignment covers `export default <expr>` (isExportEquals === false)
-        // as well as `export = <expr>` (isExportEquals === true, CommonJS style).
-        // We register 'default' for both to ensure the barrel tracer can settle here.
         spec.declaredLocalExports.add('default');
         break;
       }
@@ -140,10 +148,6 @@ export class BarrelParser {
    * @param {Map} activeProjectGraph - Global active module maps directory registry
    * @param {Set} [protectionStack] - Avoids cyclic validation traps inside self-referencing links
    */
-  /**
-   * UPGRADE 3: Cross-Barrel Symbol Tracking.
-   * Resolves the original source of a symbol through re-exports and aliases.
-   */
   async determineSymbolDeclarationOrigin(contextFilePath, targetSymbolName, activeProjectGraph, protectionStack = new Set()) {
     if (protectionStack.has(contextFilePath)) {
       return { originFile: contextFilePath, originSymbol: targetSymbolName };
@@ -172,7 +176,6 @@ export class BarrelParser {
     // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
     for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
       if (targetSymbolName === namespaceAlias) {
-          // The symbol IS the namespace itself
           const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
           return { originFile: fullyResolvedPath, originSymbol: '*' };
       }
@@ -190,7 +193,7 @@ export class BarrelParser {
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
       
       if (fullyResolvedPath) {
-        // FIX: Mark the target module as active immediately when export * is found
+        // Verbinde Graph-Kanten direkt während der Wildcard-Traversierung
         const contextNode = activeProjectGraph.get(contextFilePath);
         if (contextNode) {
           contextNode.outgoingEdges.add(fullyResolvedPath);
@@ -204,13 +207,12 @@ export class BarrelParser {
           fullyResolvedPath,
           targetSymbolName,
           activeProjectGraph,
-          new Set(protectionStack) // Use a copy so sibling branches don't block each other
+          new Set(protectionStack) // Kopie verhindert geschwisterliche Branch-Blockaden
         );
 
         if (!continuousResolutionTrace) continue;
         if (continuousResolutionTrace.originFile === contextFilePath) continue;
 
-        // Verify that the resolved origin actually declares the symbol.
         const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
         if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol) || 
             continuousResolutionTrace.originSymbol === '*') {
@@ -225,4 +227,4 @@ export class BarrelParser {
 
     return { originFile: contextFilePath, originSymbol: targetSymbolName };
   }
-}
+}