entkapp 5.3.0 → 5.4.0

package/src/performance/WorkerPool.js

@@ -47,10 +47,11 @@ export class WorkerPool {
 
     try {
       const analyticalResultsSubsets = await Promise.all(threadTaskExecutionsList);
+      const flatResults = analyticalResultsSubsets.flat();
       
       // Merge thread structural subsets back into the primary context graph nodes
-      analyticalResultsSubsets.flat().forEach(result => {
-        if (!result) return;
+      for (const result of flatResults) {
+        if (!result) continue;
         // UPGRADE: Normalize filePath before merging to prevent duplicate nodes in the graph
         const normalizedPath = path.resolve(this.context.cwd, result.filePath).replace(/\\/g, '/');
         const node = masterEngineInstanceReference.context.getOrCreateNode(normalizedPath);
@@ -95,7 +96,13 @@ export class WorkerPool {
           if (!node.globImports) node.globImports = [];
           result.globImports.forEach(i => node.globImports.push(i));
         }
-      });
+
+        // UPGRADE 5.3.0: Run plugin-specific content analysis for worker-parsed files
+        if (result.rawCode) {
+          node.rawCode = result.rawCode;
+          await masterEngineInstanceReference.magicDetector.runPluginContentAnalysis(node, normalizedPath);
+        }
+      }
 
       return true;
     } catch (poolThreadFault) {
@@ -107,13 +114,24 @@ export class WorkerPool {
   }
 
   executeChunkInsideThread(fileChunkSubset) {
+    // UPGRADE: Serialize alias patterns and workspace package names so workers can filter false positives
+    const serializedAliasPatterns = (this.context.pathMapper && this.context.pathMapper._aliasPatterns)
+      ? this.context.pathMapper._aliasPatterns.map(p => p.regex.source)
+      : [];
+    const workspacePackageNames = (this.context.workspaceGraph && this.context.workspaceGraph.workspacePackages)
+      ? Array.from(this.context.workspaceGraph.workspacePackages.keys())
+      : [];
+
     return new Promise((resolve, reject) => {
       const workerInstance = new Worker(this.workerScriptPath, { type: 'module',
         workerData: { 
           files: fileChunkSubset, 
           contextOptions: { 
             verbose: this.context.verbose,
-            cwd: this.context.cwd
+            cwd: this.context.cwd,
+            // UPGRADE: Pass alias/workspace data so workers can filter false positives
+            aliasPatternSources: serializedAliasPatterns,
+            workspacePackageNames
           } 
         }
       });

package/src/performance/WorkerTaskRunner.js

@@ -12,11 +12,35 @@ async function runTask() {
   const { files, contextOptions } = workerData;
   const results = [];
 
+  // UPGRADE: Reconstruct alias/workspace filter helpers from serialized contextOptions
+  // These are passed from WorkerPool.executeChunkInsideThread so workers can skip false positives
+  const aliasRegexes = (contextOptions.aliasPatternSources || []).map(src => {
+    try { return new RegExp(src); } catch { return null; }
+  }).filter(Boolean);
+  const workspacePackageSet = new Set(contextOptions.workspacePackageNames || []);
+
+  // Lightweight helpers mirroring PathMapper.isTsconfigAlias and WorkspaceGraph.isLocalWorkspaceSpecifier
+  const isTsconfigAlias = (spec) => aliasRegexes.some(r => r.test(spec));
+  const isWorkspacePkg = (spec) => {
+    if (workspacePackageSet.has(spec)) return true;
+    for (const name of workspacePackageSet) { if (spec.startsWith(name + '/')) return true; }
+    return false;
+  };
+
   // Create a minimal context for analyzers
   const mockContext = {
     verbose: contextOptions.verbose,
     cwd: contextOptions.cwd || process.cwd(),
     projectGraph: new Map(),
+    // UPGRADE: Expose lightweight alias/workspace helpers so ASTAnalyzer can filter imports
+    pathMapper: {
+      isTsconfigAlias,
+      _aliasPatterns: aliasRegexes.map(r => ({ regex: r }))
+    },
+    workspaceGraph: {
+      isLocalWorkspaceSpecifier: isWorkspacePkg,
+      workspacePackages: workspacePackageSet
+    },
     getOrCreateNode: (path) => ({
       filePath: path,
       explicitImports: new Set(),
@@ -50,6 +74,7 @@ async function runTask() {
     try {
       const content = await fs.readFile(filePath, 'utf8');
       const node = mockContext.getOrCreateNode(filePath);
+      node.rawCode = content; // UPGRADE: Add raw code to node for plugin analysis in main thread
 
       // Defensiver Check: Sicherstellen, dass die Map/Set-Instanzen sauber existieren
       if (!(node.internalExports instanceof Map)) node.internalExports = new Map();
@@ -106,6 +131,7 @@ async function runTask() {
       // Serialize the node data for transfer back to main thread
       results.push({
         filePath: node.filePath,
+        rawCode: node.rawCode, // UPGRADE: Pass raw code back to main thread for plugin analysis
         explicitImports: Array.from(node.explicitImports || []),
         dynamicImports: Array.from(node.dynamicImports || []),
         importedSymbols: Array.from(node.importedSymbols || []),

package/src/plugins/BasePlugin.js

@@ -5,7 +5,7 @@ import path from 'path';
  * Base class for all entkapp plugins.
  * Defines the contract for ecosystem detection, entry point mapping,
  * and missing dependency / devDependency detection.
- * Version 5.0.0: Added getMissingDependencies(), getOrphanedConfigs(), runDependencyDiagnostics().
+ * Version 5.4.0: Added detectEntryPoints() for dynamic framework entry detection.
  */
 export class BasePlugin {
     constructor(context) {
@@ -34,6 +34,17 @@ export class BasePlugin {
         return [];
     }
 
+    /**
+     * Version 5.4.0: Dynamically detect entry points from a file's content.
+     * Useful for parsing vite.config.ts, webpack.config.js, etc.
+     * @param {string} content - The file content
+     * @param {string} filePath - The absolute path to the file
+     * @returns {Array<string>} List of relative or absolute entry point paths
+     */
+    detectEntryPoints(content, filePath) {
+        return [];
+    }
+
     /**
      * Returns symbols that are implicitly required/exported by the framework.
      */
@@ -43,25 +54,13 @@ export class BasePlugin {
 
     /**
      * Returns the npm package names required for this plugin to work.
-     * Each entry is either a string or an object:
-     *   { name: string, dev?: boolean, optional?: boolean }
-     *   - dev: true  => expected in devDependencies
-     *   - dev: false => expected in dependencies
-     *   - optional   => only warn, not error
-     *
-     * Override in subclasses to enable automatic dependency checking.
-     * @returns {Array<string | {name: string, dev?: boolean, optional?: boolean}>}
      */
     getRequiredPackages() {
         return [];
     }
 
     /**
-     * Version 5.0.0: Checks whether all required packages are present in package.json.
-     * Returns an array of diagnostic objects describing missing or misplaced dependencies.
-     *
-     * @param {string} baseDir - The project root directory
-     * @returns {Promise<Array>}
+     * Checks whether all required packages are present in package.json.
      */
     async getMissingDependencies(baseDir) {
         const diagnostics = [];
@@ -147,11 +146,7 @@ export class BasePlugin {
     }
 
     /**
-     * Version 5.0.0: Checks for config files that exist without the corresponding package.
-     * Detects "orphaned" configs – e.g. .prettierrc exists but prettier is not installed.
-     *
-     * @param {string} baseDir
-     * @returns {Promise<Array>}
+     * Checks for config files that exist without the corresponding package.
      */
     async getOrphanedConfigs(baseDir) {
         const diagnostics = [];
@@ -195,11 +190,7 @@ export class BasePlugin {
     }
 
     /**
-     * Version 5.0.0: Run all dependency diagnostics (missing + orphaned).
-     * Convenience method combining getMissingDependencies and getOrphanedConfigs.
-     *
-     * @param {string} baseDir
-     * @returns {Promise<Array>}
+     * Run all dependency diagnostics (missing + orphaned).
      */
     async runDependencyDiagnostics(baseDir) {
         const [missing, orphaned] = await Promise.all([
@@ -210,9 +201,7 @@ export class BasePlugin {
     }
 
     /**
-     * Version 3.2.0: Dynamic getter for custom plugin properties.
-     * @param {string} key - The property key to retrieve
-     * @returns {any} The value of the custom property
+     * Dynamic getter for custom plugin properties.
      */
     get(key) {
         const methodName = `get${key.charAt(0).toUpperCase() + key.slice(1)}`;

package/src/plugins/PluginRegistry.js

@@ -111,6 +111,31 @@ export class PluginRegistry {
         return this.plugins.get(name);
     }
 
+    /**
+     * Version 5.4.0: Collect entry points from all plugins for a given file.
+     * @param {string} content - The file content
+     * @param {string} filePath - The absolute path to the file
+     * @returns {Array<string>} List of detected entry points
+     */
+    detectEntryPointsFromContent(content, filePath) {
+        const entryPoints = [];
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.detectEntryPoints === 'function') {
+                try {
+                    const detected = plugin.detectEntryPoints(content, filePath);
+                    if (Array.isArray(detected)) {
+                        entryPoints.push(...detected);
+                    }
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Entry detection failed for plugin "${plugin.name}" on ${filePath}:`, e.message);
+                    }
+                }
+            }
+        }
+        return entryPoints;
+    }
+
     async getActivePlugins(baseDir) {
         const active = [];
         for (const plugin of this.plugins.values()) {
@@ -121,6 +146,25 @@ export class PluginRegistry {
         return active;
     }
 
+    /**
+     * Version 5.3.0: Run content analysis on a node using all active plugins.
+     * @param {GraphNode} node - The node to analyze
+     * @param {string} filePath - The absolute path to the file
+     */
+    async runPluginAnalysis(node, filePath) {
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.analyze === 'function') {
+                try {
+                    await plugin.analyze(node, filePath);
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Analysis failed for plugin "${plugin.name}" on ${filePath}:`, e.message);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Version 5.0.0: Run dependency diagnostics across all registered plugins.
      * Returns a consolidated list of missing/misplaced dependencies and orphaned configs.

package/src/plugins/ecosystems/UltimateBundle.js

@@ -8,6 +8,7 @@
 import path from 'path';
 import fs from 'fs/promises';
 import { BasePlugin } from '../BasePlugin.js';
+import { FrameworkConfigParser } from '../../resolution/FrameworkConfigParser.js';
 
 
 export class GraphQLPlugin extends BasePlugin {
@@ -211,6 +212,27 @@ export class NuxtPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) node.frameworkAliases = aliases;
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('modules:')) node.hasNuxtModules = true;
+        if (node.rawCode.includes('components:')) node.hasNuxtComponentsConfig = true;
+      }
+    }
+  }
 }
 
 export class RemixPlugin extends BasePlugin {
@@ -233,6 +255,21 @@ export class RemixPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.endsWith('remix.config.js') || filePath.includes('vite.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.endsWith('remix.config.js')) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('ignoredRouteFiles:')) node.hasRemixIgnoredRoutes = true;
+      if (node.rawCode?.includes('serverBuildPath:')) node.hasRemixServerBuildPath = true;
+    }
+  }
 }
 
 export class SvelteKitPlugin extends BasePlugin {
@@ -251,6 +288,29 @@ export class SvelteKitPlugin extends BasePlugin {
   async isActive(baseDir) {
     try { await fs.access(path.join(baseDir, 'svelte.config.js')); return true; } catch { return false; }
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.includes('svelte.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.includes('svelte.config.')) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.hasSvelteAliases = true;
+        }
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('adapter:')) node.hasSvelteAdapter = true;
+      }
+    }
+  }
 }
 
 export class AstroPlugin extends BasePlugin {
@@ -265,12 +325,39 @@ export class AstroPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) node.frameworkAliases = aliases;
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('integrations:')) node.hasAstroIntegrations = true;
+        if (node.rawCode.includes('output:')) node.hasAstroOutputConfig = true;
+      }
+    }
+  }
 }
 
 export class VitepressPlugin extends BasePlugin {
   get name() { return 'vitepress'; }
   getConfigFiles() { return ['package.json']; }
   getRequiredPackages() { return [{ name: 'vitepress', dev: true }]; }
+  
+  getRoutePatterns() {
+    // Protection: Every file inside a .vitepress folder is treated as an entry point
+    return [/\/\.vitepress\//];
+  }
+
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
@@ -282,6 +369,62 @@ export class VitepressPlugin extends BasePlugin {
       return hasDep;
     } catch { return false; }
   }
+
+  async runDependencyDiagnostics(baseDir) {
+    const diagnostics = await super.runDependencyDiagnostics(baseDir);
+    
+    let pkg = null;
+    try {
+      const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+      pkg = JSON.parse(raw);
+    } catch { return diagnostics; }
+
+    const scripts = pkg.scripts || {};
+    const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    const hasVitepressDep = 'vitepress' in allDeps;
+    
+    // Check if any script uses vitepress
+    const hasVitepressCommand = Object.values(scripts).some(s => s.includes('vitepress'));
+    
+    // Logic for .vitepress folder existence
+    let hasVitepressFolder = false;
+    const possibleDirs = ['.vitepress', 'docs/.vitepress', 'docs/docs/.vitepress'];
+    for (const d of possibleDirs) {
+      try {
+        await fs.access(path.join(baseDir, d));
+        hasVitepressFolder = true;
+        break;
+      } catch {}
+    }
+
+    // Scenario 1: build cmd/dependency exists but no folder -> unused dependency
+    if ((hasVitepressCommand || hasVitepressDep) && !hasVitepressFolder) {
+      diagnostics.push({
+        plugin: this.name,
+        severity: 'warning',
+        message: `Plugin "${this.name}": "vitepress" is defined in package.json or scripts, but no ".vitepress" folder was found. This might be an unused dependency.`
+      });
+    }
+
+    // Scenario 2: folder exists but no dependency -> missing dependency
+    if (hasVitepressFolder && !hasVitepressDep) {
+      diagnostics.push({
+        plugin: this.name,
+        severity: 'error',
+        message: `Plugin "${this.name}": ".vitepress" folder exists, but "vitepress" package is not installed in package.json.`
+      });
+    }
+
+    return diagnostics;
+  }
+
+  async analyze(node, filePath) {
+    // If it's a config file inside .vitepress, mark it
+    if (filePath.includes('/.vitepress/config.') || filePath.includes('/.vitepress/theme/')) {
+      node.isEntry = true;
+      node.isVitepressInternal = true;
+    }
+  }
 }
 
 export class GatsbyPlugin extends BasePlugin {
@@ -321,6 +464,14 @@ export class NextJsPlugin extends BasePlugin {
     }
     return false;
   }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('rewrites')) node.hasNextRewrites = true;
+      if (node.rawCode?.includes('redirects')) node.hasNextRedirects = true;
+      if (node.rawCode?.includes('images:')) node.hasNextImageConfig = true;
+    }
+  }
 }
 
 export class ReactPlugin extends BasePlugin {
@@ -443,6 +594,42 @@ export class VitePlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.includes('vite.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.includes('vite.config.')) {
+      // Mark config as an entry so its own dependencies are tracked
+      node.isEntry = true;
+      
+      // UPGRADE: Use FrameworkConfigParser for deep structural extraction
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.viteAliasesDetected = true;
+        }
+        
+        if (entries.size > 0) {
+          node.frameworkEntries = entries;
+          node.hasCustomViteInputs = true;
+        }
+
+        // Detect Plugins (Keep existing simple check)
+        const pluginsPattern = /plugins\s*:\s*\[([\s\S]*?)\]/g;
+        if (pluginsPattern.test(node.rawCode)) {
+          node.hasVitePlugins = true;
+        }
+      }
+    }
+  }
 }
 
 export class EsbuildPlugin extends BasePlugin {
@@ -479,6 +666,30 @@ export class WebpackPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('entry:')) node.hasWebpackEntries = true;
+      if (node.rawCode?.includes('resolve:')) node.hasWebpackResolve = true;
+      if (node.rawCode?.includes('plugins:')) node.hasWebpackPlugins = true;
+    }
+  }
 }
 
 export class ParcelPlugin extends BasePlugin {
@@ -521,6 +732,14 @@ export class TailwindPlugin extends BasePlugin {
     }
     return false;
   }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('content:')) node.hasTailwindContent = true;
+      if (node.rawCode?.includes('theme:')) node.hasTailwindTheme = true;
+      if (node.rawCode?.includes('plugins:')) node.hasTailwindPlugins = true;
+    }
+  }
 }
 
 export class PostcssPlugin extends BasePlugin {
@@ -665,6 +884,13 @@ export class JestPlugin extends BasePlugin {
   async isActive(baseDir) {
     try { await fs.access(path.join(baseDir, 'jest.config.js')); return true; } catch { return false; }
   }
+  async analyze(node, filePath) {
+    if (filePath.endsWith('jest.config.js')) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('testEnvironment:')) node.hasJestTestEnv = true;
+      if (node.rawCode?.includes('setupFiles:')) node.hasJestSetupFiles = true;
+    }
+  }
 }
 
 export class VitestPlugin extends BasePlugin {
@@ -677,6 +903,39 @@ export class VitestPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.hasWebpackAliases = true;
+        }
+        if (entries.size > 0) {
+          node.frameworkEntries = entries;
+          node.hasWebpackEntries = true;
+        }
+      }
+    }
+  }
 }
 
 export class PlaywrightPlugin extends BasePlugin {