entkapp 5.4.0 → 5.6.0

package/src/resolution/ConfigLoader.mjs

@@ -0,0 +1,94 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * ConfigLoader
+ * Loads and merges entkapp configuration from multiple sources:
+ * - entkapp/config.json (project config)
+ * - entkapp.config.js / entkapp.config.mjs (JS config)
+ * - package.json "entkapp" key
+ * - CLI flags (passed as overrides)
+ */
+export class ConfigLoader {
+  constructor(cwd) { 
+    this.cwd = cwd; 
+  }
+
+  async loadConfig(overrides = {}) {
+    let config = this._defaultConfig();
+
+    // 1. Try entkapp/config.json
+    const jsonConfigPath = path.join(this.cwd, 'entkapp', 'config.json');
+    try {
+      const raw = await fs.readFile(jsonConfigPath, 'utf8');
+      // Strip comments from JSON (JSONC support)
+      const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+      const parsed = JSON.parse(stripped);
+      config = this._merge(config, parsed);
+    } catch (e) {}
+
+    // 2. Try entkapp.config.js / entkapp.config.mjs
+    for (const configFile of ['entkapp.config.mjs', 'entkapp.config.mjs', 'entkapp.config.cjs']) {
+      let jsConfigPath = path.join(this.cwd, configFile);
+      try {
+        // FIX: Windows compatibility for dynamic imports
+        if (process.platform === 'win32') {
+          jsConfigPath = 'file://' + jsConfigPath.replace(/\\/g, '/');
+        }
+        const mod = await import(jsConfigPath);
+        const jsConfig = mod.default || mod;
+        if (typeof jsConfig === 'object') {
+          config = this._merge(config, jsConfig);
+          break;
+        }
+      } catch (e) {}
+    }
+
+    // 3. Try package.json "entkapp" key
+    const pkgPath = path.join(this.cwd, 'package.json');
+    try {
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+      if (pkg.entkapp && typeof pkg.entkapp === 'object') {
+        config = this._merge(config, pkg.entkapp);
+      }
+    } catch (e) {}
+
+    // 4. Apply CLI overrides
+    config = this._merge(config, overrides);
+
+    return config;
+  }
+
+  _defaultConfig() {
+    return {
+      interface: 'CLI',
+      useBuiltinPlugins: true,
+      useCustomPlugins: true,
+      options: {
+        verbose: false,
+        fastMode: true,
+        selfHealing: true
+      },
+      enabledPlugins: [],
+      ignoreDependencies: ['entkapp', '@types/*'],
+      exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
+      entryPoints: [],
+      workspace: false
+    };
+  }
+
+  _merge(base, override) {
+    if (!override || typeof override !== 'object') return base;
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+      if (key === 'options' && typeof override[key] === 'object') {
+        result.options = { ...(base.options || {}), ...override[key] };
+      } else if (Array.isArray(override[key])) {
+        result[key] = override[key];
+      } else {
+        result[key] = override[key];
+      }
+    }
+    return result;
+  }
+}

package/src/resolution/DepencyResolver.mjs

@@ -0,0 +1,66 @@
+import path from 'path';
+import { existsSync } from 'fs';
+
+export class DependencyResolver {
+  constructor(context, pathMapper, workspaceGraph) {
+    this.context = context;
+    this.pathMapper = pathMapper;
+    this.workspaceGraph = workspaceGraph;
+  }
+
+  normalizePath(p) {
+    if (!p) return p;
+    const original = p;
+    // Handle Windows drive letters and backslashes
+    let normalized = p.replace(/\\/g, '/');
+    if (/^[a-z]:\//i.test(normalized)) {
+      normalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    }
+    if (this.context.verbose && original !== normalized) {
+       // console.log(`[Path-DEBUG] Normalized: ${original} -> ${normalized}`);
+    }
+    return normalized;
+  }
+
+  resolveModulePath(sourceFile, specifier) {
+    const cleanSource = this.normalizePath(sourceFile);
+    
+    // Check if it's a workspace package reference
+    if (this.context.isWorkspaceEnabled && this.workspaceGraph && this.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+      const match = this.workspaceGraph.getWorkspacePackageMatch(specifier);
+      if (match && match.entryPoints && match.entryPoints.length > 0) {
+        // Return the first entry point for the workspace package
+        return this.normalizePath(match.entryPoints[0]);
+      }
+    }
+
+    // UPGRADE: Use PathMapper for sophisticated resolution (TS-to-JS, aliases, etc.)
+    if (this.pathMapper) {
+      // Allow pathMapper to resolve aliases directly from specifier
+      const aliasResolved = this.pathMapper.resolvePath(specifier);
+      if (aliasResolved && aliasResolved !== specifier && existsSync(aliasResolved)) {
+         return this.normalizePath(aliasResolved);
+      }
+
+      const dir = path.dirname(cleanSource);
+      const target = path.resolve(dir, specifier);
+      const resolved = this.pathMapper.resolvePath(target);
+      if (resolved && existsSync(resolved)) {
+        return this.normalizePath(resolved);
+      }
+    }
+
+    if (specifier.startsWith('.')) {
+      const dir = path.dirname(cleanSource);
+      const target = path.resolve(dir, specifier);
+      const normalizedTarget = this.normalizePath(target);
+      
+      const extensions = ['', '.mjs', '.ts', '.tsx', '.jsx', '/index.mjs', '/index.ts', '/index.tsx'];
+      for (const ext of extensions) {
+        const p = normalizedTarget + ext;
+        if (existsSync(p)) return this.normalizePath(p);
+      }
+    }
+    return null;
+  }
+}

package/src/resolution/DependencyFixer.mjs

@@ -0,0 +1,88 @@
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * ============================================================================
+ * Dependency Auto-Fixer v5.1.0
+ * ============================================================================
+ * Automatically installs missing dependencies using the detected package manager.
+ */
+export class DependencyFixer {
+  constructor(context) {
+    this.context = context;
+    this.cwd = context.cwd;
+  }
+
+  async detectPackageManager() {
+    const files = await fs.readdir(this.cwd);
+    if (files.includes('pnpm-lock.yaml')) return 'pnpm';
+    if (files.includes('yarn.lock')) return 'yarn';
+    if (files.includes('bun.lockb')) return 'bun';
+    return 'npm';
+  }
+
+  async fix(diagnostics) {
+    const pkgManager = await this.detectPackageManager();
+    const toInstall = {
+      dependencies: new Set(),
+      devDependencies: new Set()
+    };
+
+    for (const d of diagnostics) {
+      if (d.package && d.severity === 'error') {
+        if (d.expectedIn === 'devDependencies') {
+          toInstall.devDependencies.add(d.package);
+        } else {
+          toInstall.dependencies.add(d.package);
+        }
+      }
+    }
+
+    const results = [];
+
+    if (toInstall.dependencies.size > 0) {
+      const deps = Array.from(toInstall.dependencies);
+      results.push(await this._runInstall(pkgManager, deps, false));
+    }
+
+    if (toInstall.devDependencies.size > 0) {
+      const devDeps = Array.from(toInstall.devDependencies);
+      results.push(await this._runInstall(pkgManager, devDeps, true));
+    }
+
+    return results;
+  }
+
+  async _runInstall(pm, packages, isDev) {
+    const args = [];
+    if (pm === 'npm') {
+      args.push('install', isDev ? '--save-dev' : '--save');
+    } else if (pm === 'yarn') {
+      args.push('add', isDev ? '--dev' : '');
+    } else if (pm === 'pnpm') {
+      args.push('add', isDev ? '--save-dev' : '');
+    } else if (pm === 'bun') {
+      args.push('add', isDev ? '--dev' : '');
+    }
+
+    const finalArgs = [...args.filter(Boolean), ...packages];
+    console.log(`[DependencyFixer] Running: ${pm} ${finalArgs.join(' ')}`);
+    
+    try {
+      // In a real scenario, we would use execa here. 
+      // For the SDK, we return the command that should be run.
+      return {
+        success: true,
+        command: `${pm} ${finalArgs.join(' ')}`,
+        packages
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        packages
+      };
+    }
+  }
+}

package/src/resolution/DependencyProfiler.mjs

@@ -0,0 +1,286 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Advanced Dependency Profiling Engine.
+ * Traces Peer Dependencies and Implicit Tooling Invocations.
+ * Now supports "Unused Binaries" detection.
+ */
+export class DependencyProfiler {
+  constructor(context) {
+    this.context = context;
+
+    this.binaryToPackageMap = {
+      'tsc': 'typescript',
+      'ts-node': 'ts-node',
+      'tsx': 'tsx',
+      'node': 'node',
+      'bun': 'bun',
+      'deno': 'deno',
+      'jest': 'jest',
+      'vitest': 'vitest',
+      'mocha': 'mocha',
+      'jasmine': 'jasmine',
+      'ava': 'ava',
+      'tap': 'tap',
+      'uvu': 'uvu',
+      'c8': 'c8',
+      'nyc': 'nyc',
+      'playwright': '@playwright/test',
+      'cypress': 'cypress',
+      'puppeteer': 'puppeteer',
+      'webdriverio': 'webdriverio',
+      'wdio': '@wdio/cli',
+      'eslint': 'eslint',
+      'prettier': 'prettier',
+      'tslint': 'tslint',
+      'biome': '@biomejs/biome',
+      'oxlint': 'oxlint',
+      'stylelint': 'stylelint',
+      'markdownlint': 'markdownlint-cli',
+      'commitlint': '@commitlint/cli',
+      'lint-staged': 'lint-staged',
+      'vite': 'vite',
+      'webpack': 'webpack',
+      'rollup': 'rollup',
+      'esbuild': 'esbuild',
+      'parcel': 'parcel',
+      'turbo': 'turbo',
+      'nx': 'nx',
+      'lerna': 'lerna',
+      'changesets': '@changesets/cli',
+      'changeset': '@changesets/cli',
+      'tsup': 'tsup',
+      'unbuild': 'unbuild',
+      'pkgroll': 'pkgroll',
+      'microbundle': 'microbundle',
+      'ncc': '@vercel/ncc',
+      'swc': '@swc/cli',
+      'tailwind': 'tailwindcss',
+      'tailwindcss': 'tailwindcss',
+      'postcss': 'postcss',
+      'sass': 'sass',
+      'less': 'less',
+      'next': 'next',
+      'nuxt': 'nuxt',
+      'astro': 'astro',
+      'remix': '@remix-run/dev',
+      'svelte-kit': '@sveltejs/kit',
+      'expo': 'expo',
+      'react-scripts': 'react-scripts',
+      'ng': '@angular/cli',
+      'vue': '@vue/cli-service',
+      'gatsby': 'gatsby',
+      'nodemon': 'nodemon',
+      'ts-node-dev': 'ts-node-dev',
+      'concurrently': 'concurrently',
+      'cross-env': 'cross-env',
+      'dotenv': 'dotenv-cli',
+      'dotenv-cli': 'dotenv-cli',
+      'rimraf': 'rimraf',
+      'del-cli': 'del-cli',
+      'copyfiles': 'copyfiles',
+      'cpy-cli': 'cpy-cli',
+      'mkdirp': 'mkdirp',
+      'shx': 'shx',
+      'npm-run-all': 'npm-run-all',
+      'run-p': 'npm-run-all',
+      'run-s': 'npm-run-all',
+      'typedoc': 'typedoc',
+      'jsdoc': 'jsdoc',
+      'storybook': 'storybook',
+      'sb': 'storybook',
+      'husky': 'husky',
+      'simple-git-hooks': 'simple-git-hooks',
+      'lefthook': 'lefthook',
+      'pnpm': 'pnpm',
+      'yarn': 'yarn',
+      'npm': 'npm',
+      'patch-package': 'patch-package',
+      'syncpack': 'syncpack',
+      'publint': 'publint',
+      'attw': '@arethetypeswrong/cli',
+      'size-limit': 'size-limit',
+      'bundlesize': 'bundlesize',
+      'depcheck': 'depcheck',
+      'knip': 'knip',
+      'entkapp': 'entkapp'
+    };
+
+    this.configFileToPackageMap = {
+      'jest.config': 'jest',
+      'vitest.config': 'vitest',
+      'playwright.config': '@playwright/test',
+      'cypress.config': 'cypress',
+      'webpack.config': 'webpack',
+      'vite.config': 'vite',
+      'rollup.config': 'rollup',
+      'tailwind.config': 'tailwindcss',
+      'postcss.config': 'postcss',
+      '.eslintrc': 'eslint',
+      'eslint.config': 'eslint',
+      '.prettierrc': 'prettier',
+      'prettier.config': 'prettier',
+      '.babelrc': '@babel/core',
+      'babel.config': '@babel/core',
+      '.stylelintrc': 'stylelint',
+      'stylelint.config': 'stylelint',
+      'svelte.config': '@sveltejs/kit',
+      'astro.config': 'astro',
+      'nuxt.config': 'nuxt',
+      'next.config': 'next',
+      'remix.config': '@remix-run/dev',
+      '.commitlintrc': '@commitlint/cli',
+      'commitlint.config': '@commitlint/cli',
+      'tsup.config': 'tsup',
+      'typedoc': 'typedoc',
+      '.lintstagedrc': 'lint-staged',
+      'lint-staged.config': 'lint-staged',
+      'lefthook': 'lefthook',
+      'knip.config': 'knip',
+      'knip.json': 'knip'
+    };
+  }
+
+  async traceImplicitInvocations(projectRoot) {
+    const usedPackages = new Set();
+    const usedBinaries = new Set(); // NEW: Track which binaries are actually used
+    
+    // 1. Scan package.json scripts (Root)
+    await this._scanDirectoryForConfigs(projectRoot, usedPackages, usedBinaries);
+
+    // 1.5 Scan Workspace package.json scripts and configs
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._scanDirectoryForConfigs(workspaceRoot, usedPackages, usedBinaries);
+      }
+    }
+
+    // 2. Scan CI workflows
+    try {
+      const githubWorkflows = path.join(projectRoot, '.github/workflows');
+      const files = await fs.readdir(githubWorkflows).catch(() => []);
+      for (const file of files) {
+        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
+          this.extractPackagesFromScript(content, usedPackages, usedBinaries);
+        }
+      }
+    } catch (e) {}
+
+    // 4. Identify Unused Binaries (Root)
+    await this._identifyUnusedBinaries(projectRoot, usedBinaries);
+    
+    // 4.5 Identify Unused Binaries (Workspaces)
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._identifyUnusedBinaries(workspaceRoot, usedBinaries);
+      }
+    }
+
+    return usedPackages;
+  }
+
+  async _scanDirectoryForConfigs(dir, usedPackages, usedBinaries) {
+    try {
+      const pkgJsonPath = path.join(dir, 'package.json');
+      const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
+      
+      if (pkg.scripts) {
+        for (const script of Object.values(pkg.scripts)) {
+          this.extractPackagesFromScript(script, usedPackages, usedBinaries);
+        }
+      }
+
+      if (pkg.dependencies || pkg.devDependencies) {
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        for (const depName of Object.keys(allDeps)) {
+          if (depName.startsWith('@types/')) {
+            usedPackages.add(depName);
+          }
+        }
+      }
+    } catch (e) {}
+
+    try {
+      const dirEntries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (!entry.isFile()) continue;
+        const fileName = entry.name;
+        for (const [fragment, pkgName] of Object.entries(this.configFileToPackageMap)) {
+          if (fileName.startsWith(fragment) || fileName === fragment) {
+            usedPackages.add(pkgName);
+            break;
+          }
+        }
+      }
+    } catch (e) {}
+  }
+
+  async _identifyUnusedBinaries(dir, usedBinaries) {
+    try {
+      const binDir = path.join(dir, 'node_modules', '.bin');
+      const availableBinaries = await fs.readdir(binDir).catch(() => []);
+      
+      for (const bin of availableBinaries) {
+        if (bin.startsWith('.') || ['npm', 'pnpm', 'yarn', 'bun'].includes(bin)) continue;
+        
+        if (!usedBinaries.has(bin)) {
+          this.context.unusedBinaries.add(bin);
+        }
+      }
+    } catch (e) {}
+  }
+
+  extractPackagesFromScript(script, packageCollector, binaryCollector) {
+    const words = script.split(/[\s&|;()\n\r\t]+/);
+    for (let i = 0; i < words.length; i++) {
+      const rawWord = words[i];
+      const cleanWord = rawWord.replace(/['"]/g, '').replace(/^(npx|pnpx|bunx|yarn|pnpm)\s+/, '');
+
+      if (this.binaryToPackageMap[cleanWord]) {
+        packageCollector.add(this.binaryToPackageMap[cleanWord]);
+        if (binaryCollector) binaryCollector.add(cleanWord);
+        continue;
+      }
+
+      if ((rawWord === 'npx' || rawWord === 'pnpx' || rawWord === 'bunx') && i + 1 < words.length) {
+        const nextWord = words[i + 1].replace(/['"]/g, '');
+        if (this.binaryToPackageMap[nextWord]) {
+          packageCollector.add(this.binaryToPackageMap[nextWord]);
+          if (binaryCollector) binaryCollector.add(nextWord);
+        }
+        if (nextWord.startsWith('@') || nextWord.includes('/')) {
+          const pkgName = nextWord.split('/').slice(0, nextWord.startsWith('@') ? 2 : 1).join('/');
+          if (pkgName) packageCollector.add(pkgName);
+        }
+      }
+    }
+  }
+
+  async resolvePeerDependencies(usedPackages, projectRoot) {
+    const peerDeps = new Set();
+    const nodeModules = path.join(projectRoot, 'node_modules');
+
+    for (const pkgName of usedPackages) {
+      try {
+        const pkgJsonPath = path.join(nodeModules, pkgName, 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
+        if (pkg.peerDependencies) {
+          Object.keys(pkg.peerDependencies).forEach(dep => peerDeps.add(dep));
+        }
+      } catch (e) {}
+    }
+    return peerDeps;
+  }
+
+  shouldExcludeFromUnusedCheck(packageName, depType) {
+    if (depType === 'peerDependency' || depType === 'optionalDependency') {
+      return true;
+    }
+    if (packageName.startsWith('@types/')) {
+      return true;
+    }
+    return false;
+  }
+}

package/src/resolution/EntryPointDetector.mjs

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+
+export class EntryPointDetector {
+    constructor(targetDir, packageJson, stats) {
+        this.targetDir = targetDir;
+        this.packageJson = packageJson || {};
+        this.stats = stats;
+    }
+
+    /**
+     * Detects all potential entry points of a project.
+     * @returns {Set<string>} Set of absolute paths.
+     */
+    detect() {
+        const entries = new Set();
+
+        // 1. package.json Standards
+        this._addFromPackageJson(entries);
+
+        // 2. Framework-specific paths
+        this._addFromFrameworks(entries);
+
+        // 3. Fallbacks / Konventionen
+        this._addFromConventions(entries);
+
+        return entries;
+    }
+
+    _addFromPackageJson(entries) {
+        const fields = ['main', 'module', 'browser', 'bin'];
+        fields.forEach(field => {
+            const val = this.packageJson[field];
+            if (typeof val === 'string') {
+                this._addIfExist(entries, val);
+            } else if (typeof val === 'object' && val !== null) {
+                Object.values(val).forEach(v => {
+                    if (typeof v === 'string') this._addIfExist(entries, v);
+                });
+            }
+        });
+
+        // Exports field (modern Node.js)
+        if (this.packageJson.exports) {
+            this._parseExports(this.packageJson.exports, entries);
+        }
+    }
+
+    _parseExports(exports, entries) {
+        if (typeof exports === 'string') {
+            this._addIfExist(entries, exports);
+        } else if (typeof exports === 'object' && exports !== null) {
+            for (const key in exports) {
+                const val = exports[key];
+                if (typeof val === 'string') {
+                    this._addIfExist(entries, val);
+                } else if (typeof val === 'object') {
+                    this._parseExports(val, entries);
+                }
+            }
+        }
+    }
+
+    _addFromFrameworks(entries) {
+        if (!this.stats || !this.stats.detectedFrameworks) return;
+
+        const frameworks = this.stats.detectedFrameworks;
+
+        if (frameworks.includes('next')) {
+            this._scanDir(path.join(this.targetDir, 'pages'), entries);
+            this._scanDir(path.join(this.targetDir, 'app'), entries, ['page.tsx', 'page.mjs', 'route.ts', 'route.mjs']);
+        }
+
+        if (frameworks.includes('nuxt')) {
+            this._scanDir(path.join(this.targetDir, 'pages'), entries);
+        }
+
+        if (frameworks.includes('svelte')) {
+            this._scanDir(path.join(this.targetDir, 'src/routes'), entries);
+        }
+    }
+
+    _addFromConventions(entries) {
+        const fallbacks = [
+            'index.mjs', 'index.ts', 'index.jsx', 'index.tsx',
+            'src/index.mjs', 'src/index.ts', 'src/index.jsx', 'src/index.tsx',
+            'main.mjs', 'main.ts', 'src/main.mjs', 'src/main.ts',
+            'app.mjs', 'app.ts', 'src/app.mjs', 'src/app.ts',
+            'server.mjs', 'server.ts', 'src/server.mjs', 'src/server.ts'
+        ];
+        fallbacks.forEach(f => this._addIfExist(entries, f));
+
+        // If no entries found yet, and we are in a simple src structure, 
+        // protect common top-level files in src/
+        if (entries.size === 0) {
+            const commonSrcFiles = ['src/app.ts', 'src/main.ts', 'src/index.ts', 'src/app.mjs', 'src/main.mjs', 'src/index.mjs'];
+            commonSrcFiles.forEach(f => this._addIfExist(entries, f));
+        }
+    }
+
+    _addIfExist(entries, relativePath) {
+        // Clean path (remove ./ etc)
+        const cleanPath = relativePath.replace(/^(\.\/|\/)/, '');
+        const absolutePath = path.resolve(this.targetDir, cleanPath);
+        
+        // Prüfe verschiedene Erweiterungen falls keine angegeben
+        const extensions = ['', '.mjs', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+        for (const ext of extensions) {
+            const p = absolutePath + ext;
+            if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+                entries.add(p);
+                return;
+            }
+        }
+    }
+
+    _scanDir(dir, entries, specificFiles = null) {
+        if (!fs.existsSync(dir)) return;
+        
+        const files = fs.readdirSync(dir, { recursive: true });
+        files.forEach(file => {
+            const fullPath = path.join(dir, file);
+            if (fs.statSync(fullPath).isFile()) {
+                if (specificFiles) {
+                    if (specificFiles.includes(path.basename(file))) {
+                        entries.add(fullPath);
+                    }
+                } else if (/\.(js|ts|jsx|tsx|vue|svelte)$/.test(file)) {
+                    entries.add(fullPath);
+                }
+            }
+        });
+    }
+}