entkapp 5.3.0 → 5.4.0

package/src/resolution/ConfigLoader.js

@@ -3,73 +3,239 @@ 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)
+ *
+ * Loads and merges entkapp configuration from multiple sources.
+ * Supports Monorepo detection for pnpm, npm/yarn/bun, Lerna, Turbo, and Nx.
  */
 export class ConfigLoader {
-  constructor(cwd) { 
-    this.cwd = cwd; 
+  constructor(cwd) {
+    this.cwd = cwd;
   }
 
   async loadConfig(overrides = {}) {
     let config = this._defaultConfig();
 
-    // 1. Try entkapp/config.json
+    // 1. 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);
+      config = this._merge(config, JSON.parse(stripped));
     } catch (e) {}
 
-    // 2. Try entkapp.config.js / entkapp.config.mjs
-    for (const configFile of ['entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
+    // 2. entkapp.config.ts / .mjs / .js / .cjs
+    for (const configFile of ['entkapp.config.ts', 'entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
       const jsConfigPath = path.join(this.cwd, configFile);
       try {
         const mod = await import(jsConfigPath);
         const jsConfig = mod.default || mod;
-        if (typeof jsConfig === 'object') {
+        if (typeof jsConfig === 'object' && jsConfig !== null) {
           config = this._merge(config, jsConfig);
           break;
         }
       } catch (e) {}
     }
 
-    // 3. Try package.json "entkapp" key
-    const pkgPath = path.join(this.cwd, 'package.json');
+    // 3. package.json "entkapp" key
     try {
-      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
       if (pkg.entkapp && typeof pkg.entkapp === 'object') {
         config = this._merge(config, pkg.entkapp);
       }
     } catch (e) {}
 
-    // 4. Apply CLI overrides
+    // 4. Workspace / monorepo packages
+    const workspaceData = await this.loadWorkspaceConfigs();
+    if (workspaceData.packages.length > 0) {
+      config.workspace = true;
+      config.workspacePackages = workspaceData.packages;
+      config.workspaceTsConfigs = workspaceData.tsConfigs;
+      config.workspaceConfigFiles = workspaceData.configFiles;
+      config.monorepoConfigs = workspaceData.monorepoConfigs;
+    }
+
+    // 5. CLI overrides
     config = this._merge(config, overrides);
 
+    // Final sanity check: ensure arrays exist
+    if (!Array.isArray(config.entryPoints)) config.entryPoints = [];
+    if (!Array.isArray(config.workspacePackages)) config.workspacePackages = [];
+    if (!Array.isArray(config.workspaceTsConfigs)) config.workspaceTsConfigs = [];
+    if (!Array.isArray(config.workspaceConfigFiles)) config.workspaceConfigFiles = [];
+
     return config;
   }
 
+  async loadWorkspaceConfigs() {
+    const result = {
+      packages: [],
+      tsConfigs: [],
+      configFiles: [],
+      monorepoConfigs: {}
+    };
+
+    // Load global configs first
+    const globalConfigs = ['turbo.json', 'nx.json', 'lerna.json'];
+    for (const file of globalConfigs) {
+      try {
+        const content = JSON.parse(await fs.readFile(path.join(this.cwd, file), 'utf8'));
+        result.monorepoConfigs[file] = content;
+      } catch (e) {}
+    }
+
+    const patterns = await this._resolveWorkspacePatterns();
+    if (patterns.length === 0) return result;
+
+    for (const pattern of patterns) {
+      const dirs = await this._expandGlob(pattern);
+      for (const dir of dirs) {
+        await this._readPackageDir(dir, result);
+      }
+    }
+
+    return result;
+  }
+
+  async _resolveWorkspacePatterns() {
+    const pnpmPatterns = await this._parseWorkspaceYaml('pnpm-workspace.yaml');
+    if (pnpmPatterns.length > 0) return pnpmPatterns;
+
+    try {
+      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
+      if (pkg.workspaces) {
+        return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
+      }
+    } catch (e) {}
+
+    try {
+      const lerna = JSON.parse(await fs.readFile(path.join(this.cwd, 'lerna.json'), 'utf8'));
+      if (lerna.packages) return lerna.packages;
+    } catch (e) {}
+
+    return this._parseWorkspaceYaml('workspace.yaml');
+  }
+
+  async _parseWorkspaceYaml(fileName) {
+    const filePath = path.join(this.cwd, fileName);
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      const patterns = [];
+      const lines = raw.split('\n');
+      let inPackages = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        if (/^packages\s*:/.test(trimmed)) {
+          inPackages = true;
+          const inlineMatch = trimmed.match(/^packages\s*:\s*\[([^\]]*)\]/);
+          if (inlineMatch) {
+            inPackages = false;
+            for (const item of inlineMatch[1].split(',')) {
+              const val = item.trim().replace(/^['"]|['"]$/g, '');
+              if (val) patterns.push(val);
+            }
+          }
+          continue;
+        }
+        if (inPackages) {
+          if (line.match(/^[a-zA-Z0-9_-]/) && trimmed.endsWith(':')) {
+            inPackages = false;
+            continue;
+          }
+          if (trimmed.startsWith('-')) {
+            const val = trimmed.substring(1).trim().replace(/^['"]|['"]$/g, '');
+            if (val) patterns.push(val);
+          }
+        }
+      }
+      return patterns;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async _readPackageDir(dir, result) {
+    const normalizedDir = dir.replace(/\\/g, '/');
+    let packageName;
+
+    try {
+      const pkg = JSON.parse(await fs.readFile(path.join(dir, 'package.json'), 'utf8'));
+      packageName = pkg.name;
+      result.packages.push({
+        dir: normalizedDir,
+        name: packageName,
+        entkappConfig: (pkg.entkapp && typeof pkg.entkapp === 'object') ? pkg.entkapp : {}
+      });
+    } catch (e) {
+      // If no package.json, skip as requested in WorkSpaceGraph logic
+      return;
+    }
+
+    // tsconfig.json
+    try {
+      const tsconfigRaw = await fs.readFile(path.join(dir, 'tsconfig.json'), 'utf8');
+      const stripped = tsconfigRaw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+      result.tsConfigs.push({ dir: normalizedDir, name: packageName, tsconfig: JSON.parse(stripped) });
+    } catch (e) {}
+
+    // *.config.ts / .js
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !/\.config\.(ts|js|mjs|cjs)$/.test(entry.name)) continue;
+        const filePath = path.join(dir, entry.name).replace(/\\/g, '/');
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          result.configFiles.push({ dir: normalizedDir, name: packageName, fileName: entry.name, filePath, content });
+        } catch (e) {}
+      }
+    } catch (e) {}
+  }
+
+  async _expandGlob(pattern) {
+    const results = [];
+    const cleanPattern = pattern.replace(/\/$/, '');
+    if (cleanPattern.includes('*')) {
+      const parts = cleanPattern.split('/');
+      const wildcardIndex = parts.findIndex(p => p.includes('*'));
+      const baseDir = path.join(this.cwd, ...parts.slice(0, wildcardIndex));
+      try {
+        const entries = await fs.readdir(baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            const fullPath = path.join(baseDir, entry.name);
+            try {
+              await fs.access(path.join(fullPath, 'package.json'));
+              results.push(fullPath.replace(/\\/g, '/'));
+            } catch (e) {}
+          }
+        }
+      } catch (e) {}
+    } else {
+      const fullPath = path.resolve(this.cwd, cleanPattern);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) results.push(fullPath.replace(/\\/g, '/'));
+      } catch (e) {}
+    }
+    return results;
+  }
+
   _defaultConfig() {
     return {
       interface: 'CLI',
       useBuiltinPlugins: true,
       useCustomPlugins: true,
-      options: {
-        verbose: false,
-        fastMode: true,
-        selfHealing: true
-      },
+      options: { verbose: false, fastMode: true, selfHealing: true },
       enabledPlugins: [],
       ignoreDependencies: ['entkapp', '@types/*'],
       exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
       entryPoints: [],
-      workspace: false
+      workspace: false,
+      workspacePackages: [],
+      workspaceTsConfigs: [],
+      workspaceConfigFiles: [],
+      monorepoConfigs: {}
     };
   }
 
@@ -79,8 +245,6 @@ export class ConfigLoader {
     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];
       }

package/src/resolution/FrameworkConfigParser.js

@@ -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', '.js', '.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,6 +10,36 @@ 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);
   }
 
   /**
@@ -63,7 +93,41 @@ export class GraphAnalyzer {
       }
     }
 
-    return { deadFiles, zombieExports };
+    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 };
   }
 
   _walk(filePath, reachable) {

package/src/resolution/PathMapper.js

@@ -6,15 +6,22 @@ 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`);
     }
 
@@ -26,12 +33,86 @@ 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/TSConfigLoader.js

@@ -109,7 +109,9 @@ export class TSConfigLoader {
         }
 
         const { paths, baseUrl } = parsedConfig.options;
-        const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
+        // 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;
 
         return (source) => {
             // If no paths configured, still try baseUrl resolution