entkapp 5.1.0 → 5.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "name": "entkapp",
-  "version": "5.1.0",
+  "version": "5.2.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",

package/src/EngineContext.js

@@ -86,10 +86,16 @@ export class GraphNode {
       }
 
       // Fuzzy / Dynamic usage (Identifiers, Strings, JSX, Decorators)
-      if (parentNode.instantiatedIdentifiers.has(symbolName)) return true;
-      if (parentNode.rawStringReferences.has(symbolName)) return true;
-      if (parentNode.jsxComponents.has(symbolName)) return true;
-      if (parentNode.decorators.has(symbolName)) return true;
+      // UPGRADE: Only check for fuzzy matches if we have a reason to believe it might be used.
+      // We skip global names like 'toLowerCase' unless they are explicitly imported.
+      const isGlobalName = ['toLowerCase', 'toUpperCase', 'toString', 'valueOf', 'hasOwnProperty', 'constructor'].includes(symbolName);
+      
+      if (!isGlobalName) {
+        if (parentNode.instantiatedIdentifiers.has(symbolName)) return true;
+        if (parentNode.rawStringReferences.has(symbolName)) return true;
+        if (parentNode.jsxComponents.has(symbolName)) return true;
+        if (parentNode.decorators.has(symbolName)) return true;
+      }
       
       for (const accessChain of parentNode.propertyAccessChains) {
         if (accessChain.endsWith(`.${symbolName}`) || accessChain.includes(`.${symbolName}.`)) return true;
@@ -189,7 +195,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) {
@@ -390,7 +396,15 @@ export class EngineContext {
           continue;
         }
         
-        if (!usedByReachableFiles.has(dep)) {
+        // UPGRADE: Be more aggressive in detecting unused dependencies.
+        // Check both externalPackageUsage and rawStringReferences.
+        const isUsed = usedByReachableFiles.has(dep) || 
+                       Array.from(reachableFiles).some(f => {
+                         const node = this.projectGraph.get(f);
+                         return node && (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep));
+                       });
+
+        if (!isUsed) {
           report.unusedDependencies.push({
             package: dep,
             type: deps.dependencies.includes(dep) ? 'dependency' : 'devDependency',

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;
+  }
+}