entkapp 5.4.0 → 5.6.0

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.js

@@ -10,36 +10,6 @@ export class GraphAnalyzer {
   constructor(context) {
     this.context = context;
     this.cwd = context.cwd;
-    // UPGRADE 5.4.3: Default Boundary Rules
-    this.boundaryRules = context.config?.boundaries || [
-      { from: 'packages/shared-*', to: 'apps/*', allow: false, message: 'Shared packages must not import from applications.' },
-      { from: '*', to: '**/internal/**', allow: false, message: 'Private internal utilities must not be imported externally.' }
-    ];
-  }
-
-  /**
-   * UPGRADE 5.4.3: Boundary Enforcement
-   * Checks if an import violates defined architectural boundaries.
-   */
-  checkBoundaries(fromPath, toPath) {
-    const relFrom = path.relative(this.cwd, fromPath).replace(/\\/g, '/');
-    const relTo = path.relative(this.cwd, toPath).replace(/\\/g, '/');
-
-    for (const rule of this.boundaryRules) {
-      const fromMatch = this._globMatch(relFrom, rule.from);
-      const toMatch = this._globMatch(relTo, rule.to);
-
-      if (fromMatch && toMatch && !rule.allow) {
-        return { violated: true, message: rule.message };
-      }
-    }
-    return { violated: false };
-  }
-
-  _globMatch(str, pattern) {
-    if (pattern === '*') return true;
-    const regex = new RegExp('^' + pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*') + '$');
-    return regex.test(str);
   }
 
   /**
@@ -93,41 +63,7 @@ export class GraphAnalyzer {
       }
     }
 
-    const unusedImports = [];
-    const boundaryViolations = [];
-
-    for (const [filePath, node] of graph.entries()) {
-      if (!reachable.has(filePath)) continue;
-
-      // UPGRADE 5.4.3: Check boundaries for every import
-      for (const impPath of node.explicitImports) {
-        if (graph.has(impPath)) {
-          const violation = this.checkBoundaries(filePath, impPath);
-          if (violation.violated) {
-            boundaryViolations.push({
-              file: path.relative(this.cwd, filePath).replace(/\\/g, '/'),
-              target: path.relative(this.cwd, impPath).replace(/\\/g, '/'),
-              message: violation.message
-            });
-          }
-        }
-      }
-      
-      if (node.localImportBindings) {
-        for (const [localName, meta] of node.localImportBindings.entries()) {
-          // Check if this local binding is used anywhere in the file
-          if (!node.instantiatedIdentifiers.has(localName)) {
-            unusedImports.push({
-              file: path.relative(this.cwd, filePath).replace(/\\/g, '/'),
-              specifier: meta.specifier,
-              symbol: meta.originalName === '*' ? 'Namespace' : meta.originalName
-            });
-          }
-        }
-      }
-    }
-
-    return { deadFiles, zombieExports, unusedImports, boundaryViolations };
+    return { deadFiles, zombieExports };
   }
 
   _walk(filePath, reachable) {

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

package/src/resolution/PathMapper.js

@@ -6,22 +6,15 @@ export class PathMapper {
   constructor(context) { 
     this.context = context; 
     this.aliasMappers = []; // list of alias mapping functions
-    // UPGRADE: Raw alias patterns for fast "is this an alias?" checks without file-existence tests
-    this._aliasPatterns = []; // Array of { regex }
   }
   
   async loadMappings(tsconfigFilename = 'tsconfig.json') {
-    // UPGRADE: Reset on reload to avoid duplicate entries when called twice (workspace re-load)
-    this.aliasMappers = [];
-    this._aliasPatterns = [];
-
     // Load root tsconfig
     const loader = new TSConfigLoader(this.context.cwd);
     const config = loader.load();
     if (config) {
       const mapper = loader.getAliasMapper(config);
       this.aliasMappers.push(mapper);
-      this._collectAliasPatterns(config, loader);
       if (this.context.verbose) console.log(`[PathMapper] Loaded root tsconfig aliases`);
     }
 
@@ -33,86 +26,12 @@ export class PathMapper {
         if (wsConfig) {
           const wsMapper = wsLoader.getAliasMapper(wsConfig);
           this.aliasMappers.push(wsMapper);
-          this._collectAliasPatterns(wsConfig, wsLoader);
           if (this.context.verbose) console.log(`[PathMapper] Loaded workspace tsconfig aliases from ${root}`);
         }
       }
     }
   }
 
-  /**
-   * UPGRADE: Collect raw alias patterns from a parsed tsconfig so we can answer
-   * "is this specifier a tsconfig alias?" without needing the target file to exist on disk.
-   * Handles patterns like "@shared/*", "@idk/*", "~/*", etc.
-   * @param {Object} parsedConfig - Result of TSConfigLoader.load()
-   * @param {TSConfigLoader} loader
-   */
-  _collectAliasPatterns(parsedConfig, loader) {
-    if (!parsedConfig || !parsedConfig.options) return;
-    const { paths, baseUrl } = parsedConfig.options;
-
-    if (paths) {
-      for (const pattern in paths) {
-        // Convert tsconfig glob pattern to a regex
-        // e.g. "@shared/*" -> /^@shared\//  or  "@shared" -> /^@shared$/
-        const escaped = pattern
-          .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex special chars except *
-          .replace(/\\\*/g, '.*');               // replace escaped \* with .*
-        try {
-          this._aliasPatterns.push({ regex: new RegExp('^' + escaped + '$') });
-          // Also add a prefix variant so "@shared/foo/bar" matches "@shared/*"
-          const prefixEscaped = pattern.replace(/\*.*$/, '').replace(/[.+^${}()|[\]\\]/g, '\\$&');
-          if (prefixEscaped && prefixEscaped !== escaped) {
-            this._aliasPatterns.push({ regex: new RegExp('^' + prefixEscaped) });
-          }
-        } catch (e) { /* ignore invalid regex */ }
-      }
-    }
-  }
-
-  /**
-   * UPGRADE: Returns true if the given specifier matches any tsconfig path alias pattern.
-   * This check does NOT require the target file to exist on disk.
-   * Used by the unlisted-dependency audit to skip tsconfig-aliased imports.
-   * @param {string} specifier
-   * @returns {boolean}
-   */
-  isTsconfigAlias(specifier) {
-    if (!specifier || typeof specifier !== 'string') return false;
-    for (const { regex } of this._aliasPatterns) {
-      if (regex.test(specifier)) return true;
-    }
-    return false;
-  }
-
-  /**
-   * UPGRADE: Manually register a dynamic alias (e.g. from vite.config.js).
-   * @param {string} key - Alias key (e.g. "@shared")
-   * @param {string} target - Absolute path or relative path to resolve
-   */
-  addAlias(key, target) {
-    if (!key || !target) return;
-    
-    // 1. Add to aliasMappers for resolvePath()
-    const mapper = (p) => {
-      if (p === key) return target;
-      if (p.startsWith(key + '/')) {
-        return path.join(target, p.substring(key.length + 1)).replace(/\\/g, '/');
-      }
-      return p;
-    };
-    this.aliasMappers.push(mapper);
-
-    // 2. Add to _aliasPatterns for isTsconfigAlias() checks
-    const escaped = key.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-    try {
-      this._aliasPatterns.push({ regex: new RegExp('^' + escaped + '$') });
-      this._aliasPatterns.push({ regex: new RegExp('^' + escaped + '/') });
-    } catch (e) {}
-    
-    if (this.context.verbose) console.log(`[PathMapper] Added dynamic alias: ${key} -> ${target}`);
-  }
-
   /**
    * Resolves physical module paths on disk, translating modern .js imports 
    * back to their actual TypeScript source files.

package/src/resolution/PathMapper.mjs

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import { TSConfigLoader } from './TSConfigLoader.mjs';
+
+export class PathMapper {
+  constructor(context) { 
+    this.context = context; 
+    this.aliasMappers = []; // list of alias mapping functions
+  }
+  
+  async loadMappings(tsconfigFilename = 'tsconfig.json') {
+    // Load root tsconfig
+    const loader = new TSConfigLoader(this.context.cwd);
+    const config = loader.load();
+    if (config) {
+      const mapper = loader.getAliasMapper(config);
+      this.aliasMappers.push(mapper);
+      if (this.context.verbose) console.log(`[PathMapper] Loaded root tsconfig aliases`);
+    }
+
+    // Load workspace tsconfigs if available
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const root of this.context.monorepoPackageRoots) {
+        const wsLoader = new TSConfigLoader(root);
+        const wsConfig = wsLoader.load();
+        if (wsConfig) {
+          const wsMapper = wsLoader.getAliasMapper(wsConfig);
+          this.aliasMappers.push(wsMapper);
+          if (this.context.verbose) console.log(`[PathMapper] Loaded workspace tsconfig aliases from ${root}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolves physical module paths on disk, translating modern .js imports 
+   * back to their actual TypeScript source files.
+   * @param {string} p - The target module specifier or absolute path
+   */
+  resolvePath(p) {
+    if (!p || typeof p !== 'string') return p;
+
+    let resolvedP = p;
+
+    // Try alias mappers first
+    for (const mapper of this.aliasMappers) {
+      const mapped = mapper(resolvedP);
+      if (mapped !== resolvedP && fs.existsSync(mapped)) {
+        resolvedP = mapped;
+        break;
+      }
+    }
+
+    // FIX 1: If the import ends with .js, translate it to .ts for the search
+    if (resolvedP.endsWith('.mjs')) {
+      const tsPath = resolvedP.slice(0, -3) + '.ts';
+      if (fs.existsSync(tsPath)) return tsPath;
+    }
+
+    // FIX 2: If the import ends with .jsx, translate it to .tsx for the search
+    if (resolvedP.endsWith('.jsx')) {
+      const tsxPath = resolvedP.slice(0, -4) + '.tsx';
+      if (fs.existsSync(tsxPath)) return tsxPath;
+    }
+
+    // FIX 3: Support for directory imports (z.B. ./adapters -> ./adapters/index.ts)
+    try {
+      const stat = fs.statSync(resolvedP);
+      if (stat.isDirectory()) {
+        const extensions = ['.ts', '.tsx', '.mjs', '.jsx'];
+        for (const ext of extensions) {
+          const indexPath = path.join(resolvedP, `index${ext}`);
+          if (fs.existsSync(indexPath)) return indexPath;
+        }
+      }
+    } catch {
+      // File does not exist or is not a directory, continue with default
+    }
+
+    return resolvedP; 
+  }
+}

package/src/resolution/TSConfigLoader.js

@@ -109,9 +109,7 @@ export class TSConfigLoader {
         }
 
         const { paths, baseUrl } = parsedConfig.options;
-        // In ts.parseJsonConfigFileContent, baseUrl is already resolved to an absolute path if it was present
-        // If not, we fall back to targetDir
-        const base = baseUrl ? baseUrl : this.targetDir;
+        const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
 
         return (source) => {
             // If no paths configured, still try baseUrl resolution