entkapp 5.5.0 → 5.6.1

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

package/src/resolution/FrameworkConfigParser.mjs

@@ -0,0 +1,119 @@
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Lightweight Static Analysis Parser for Vite / Vitest / Framework Configurations.
+ * Extracts 'resolve.alias' and 'build.lib.entry' without executing the file.
+ * Version 5.4.0: Added poly-extension path resolution.
+ */
+export class FrameworkConfigParser {
+  constructor(context) {
+    this.context = context;
+  }
+
+  /**
+   * Parses a Framework configuration file and extracts structural metadata.
+   * @param {string} content - Raw source code of the config file
+   * @param {string} filePath - Absolute path to the config file
+   * @returns {Object} { aliases: Map<string, string>, entries: Set<string> }
+   */
+  parse(content, filePath) {
+    const results = {
+      aliases: new Map(),
+      entries: new Set()
+    };
+
+    if (!content) return results;
+
+    const configDir = path.dirname(filePath);
+
+    // 1. Extract Aliases from resolve: { alias: { ... } } or alias: [ ... ]
+    this._extractAliases(content, configDir, results.aliases);
+
+    // 2. Extract Entry Points from build: { lib: { entry: '...' } } or rollupOptions: { input: '...' }
+    this._extractEntries(content, configDir, results.entries);
+
+    return results;
+  }
+
+  _extractAliases(content, configDir, aliasMap) {
+    const objAliasPatterns = [
+      /alias\s*:\s*\{([\s\S]*?)\}/g,
+      /resolve\s*:\s*\{[\s\S]*?alias\s*:\s*\{([\s\S]*?)\}/g
+    ];
+
+    for (const pattern of objAliasPatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const inner = match[1];
+        const pairPattern = /(?:['"]?)(@?[a-zA-Z0-9_\-\/*]+)(?:['"]?)\s*:\s*(?:['"]([^'"]+)['"]|(path\.(?:resolve|join)\([\s\S]*?\)))/g;
+        let pair;
+        while ((pair = pairPattern.exec(inner)) !== null) {
+          const [_, key, stringVal, callVal] = pair;
+          aliasMap.set(key, this._resolveValue(stringVal || callVal, configDir));
+        }
+      }
+    }
+
+    const arrAliasPattern = /alias\s*:\s*\[([\s\S]*?)\]/;
+    const arrMatch = arrAliasPattern.exec(content);
+    if (arrMatch) {
+      const inner = arrMatch[1];
+      const findPattern = /\{\s*find\s*:\s*['"]([^'"]+)['"]\s*,\s*replacement\s*:\s*['"]([^'"]+)['"]\s*\}/g;
+      let findMatch;
+      while ((findMatch = findPattern.exec(inner)) !== null) {
+        const [_, key, value] = findMatch;
+        aliasMap.set(key, this._resolveValue(value, configDir));
+      }
+    }
+  }
+
+  _extractEntries(content, configDir, entrySet) {
+    const libEntryPattern = /entry\s*:\s*['"]([^'"]+)['"]/;
+    const libMatch = libEntryPattern.exec(content);
+    if (libMatch) {
+      entrySet.add(this._resolveValue(libMatch[1], configDir));
+    }
+
+    const inputPattern = /input\s*:\s*(?:['"]([^'"]+)['"]|\[([\s\S]*?)\])/;
+    const inputMatch = inputPattern.exec(content);
+    if (inputMatch) {
+      if (inputMatch[1]) {
+        entrySet.add(this._resolveValue(inputMatch[1], configDir));
+      } else if (inputMatch[2]) {
+        const paths = inputMatch[2].match(/['"]([^'"]+)['"]/g);
+        if (paths) {
+          paths.forEach(p => entrySet.add(this._resolveValue(p.replace(/['"]/g, ''), configDir)));
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolves a path value and applies poly-extension fallback if the file doesn't exist.
+   */
+  _resolveValue(val, configDir) {
+    const pathCallPattern = /path\.(?:resolve|join)\s*\(\s*(?:__dirname\s*,\s*)?['"]([^'"]+)['"]\s*\)/;
+    const pathMatch = pathCallPattern.exec(val);
+    if (pathMatch) {
+      val = pathMatch[1];
+    }
+
+    if (val.startsWith('.') || val.startsWith('/') || /^[a-zA-Z]:/.test(val)) {
+      let resolved = path.resolve(configDir, val).replace(/\\/g, '/');
+      
+      // UPGRADE: Poly-extension fallback
+      if (!fs.existsSync(resolved)) {
+        const base = resolved.replace(/\.[a-zA-Z0-9]+$/, '');
+        const extensions = ['.ts', '.mjs', '.tsx', '.jsx', '.mjs', '.cjs'];
+        for (const ext of extensions) {
+          if (fs.existsSync(base + ext)) {
+            return (base + ext).replace(/\\/g, '/');
+          }
+        }
+      }
+      return resolved;
+    }
+    return val;
+  }
+}

package/src/resolution/GraphAnalyzer.mjs

@@ -0,0 +1,80 @@
+import path from 'path';
+
+/**
+ * ============================================================================
+ * Dead Code & Zombie Export Hunter v5.1.0
+ * ============================================================================
+ * Identifies unused files and exported symbols that are never imported.
+ */
+export class GraphAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.cwd = context.cwd;
+  }
+
+  /**
+   * Performs a full reachability analysis from entry points.
+   */
+  async findDeadCode() {
+    const graph = this.context.projectGraph;
+    const reachable = new Set();
+    const entries = [];
+
+    // 1. Identify all confirmed entry points
+    for (const [filePath, node] of graph.entries()) {
+      if (node.isEntry) {
+        entries.push(filePath);
+        this._walk(filePath, reachable);
+      }
+    }
+
+    const deadFiles = [];
+    const zombieExports = [];
+
+    // 2. Find unreachable files
+    for (const filePath of graph.keys()) {
+      if (!reachable.has(filePath)) {
+        deadFiles.push(path.relative(this.cwd, filePath).replace(/\\/g, '/'));
+      } else {
+        // 3. Find Zombie Exports in reachable files
+        const node = graph.get(filePath);
+        if (node.isEntry) continue; // Skip entries as their exports are intended for external use
+
+        for (const [symbol, meta] of node.internalExports.entries()) {
+          if (symbol === 'default' || symbol === '*') continue;
+          
+          let isUsed = false;
+          // Check if any other node imports this symbol
+          for (const [otherPath, otherNode] of graph.entries()) {
+            if (otherNode.importedSymbols && otherNode.importedSymbols.has(symbol)) {
+              // This is a simplified check; in reality, we'd check if it's imported FROM this file
+              isUsed = true;
+              break;
+            }
+          }
+
+          if (!isUsed) {
+            zombieExports.push({
+              file: path.relative(this.cwd, filePath).replace(/\\/g, '/'),
+              symbol: symbol
+            });
+          }
+        }
+      }
+    }
+
+    return { deadFiles, zombieExports };
+  }
+
+  _walk(filePath, reachable) {
+    if (reachable.has(filePath)) return;
+    reachable.add(filePath);
+
+    const node = this.context.projectGraph.get(filePath);
+    if (!node) return;
+
+    for (const impPath of node.explicitImports) {
+      this._walk(impPath, reachable);
+    }
+  }
+}

package/src/resolution/MigrationAnalyzer.mjs

@@ -0,0 +1,60 @@
+/**
+ * ============================================================================
+ * Migration Path Analyzer v5.1.0
+ * ============================================================================
+ * Suggests modern alternatives for legacy tools and frameworks.
+ */
+export class MigrationAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.migrations = [
+      { 
+        legacy: 'webpack', 
+        modern: 'vite', 
+        reason: 'Vite offers significantly faster HMR and build times using ES modules during development.' 
+      },
+      { 
+        legacy: 'jest', 
+        modern: 'vitest', 
+        reason: 'Vitest is faster, has native ESM support, and shares configuration with Vite.' 
+      },
+      { 
+        legacy: 'moment', 
+        modern: 'dayjs', 
+        reason: 'Day.js is a 2KB alternative to Moment.js with the same modern API.' 
+      },
+      { 
+        legacy: 'axios', 
+        modern: 'fetch', 
+        reason: 'Native fetch is now widely supported and requires no external dependency for simple use cases.' 
+      },
+      { 
+        legacy: 'ts-node', 
+        modern: 'tsx', 
+        reason: 'tsx is faster and has better ESM support for running TypeScript files.' 
+      },
+      {
+        legacy: 'eslint-plugin-prettier',
+        modern: 'eslint-config-prettier',
+        reason: 'Running Prettier as an ESLint rule is slow. It is recommended to run them separately or use a config that turns off conflicting rules.'
+      }
+    ];
+  }
+
+  async analyze(activePlugins) {
+    const suggestions = [];
+    const activeNames = activePlugins.map(p => p.name);
+
+    for (const m of this.migrations) {
+      if (activeNames.includes(m.legacy)) {
+        suggestions.push({
+          from: m.legacy,
+          to: m.modern,
+          message: `Migration Suggestion: Consider moving from "${m.legacy}" to "${m.modern}". ${m.reason}`
+        });
+      }
+    }
+    
+    return suggestions;
+  }
+}