entkapp 5.5.0 → 5.6.1

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

@@ -0,0 +1,162 @@
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+
+export class TSConfigLoader {
+    constructor(targetDir) {
+        this.targetDir = targetDir;
+    }
+
+    /**
+     * Lädt und parst die tsconfig.json.
+     * Unterstützt JSONC (Kommentare), extends, und project references.
+     * @param {string} [filename='tsconfig.json'] - Name der tsconfig-Datei
+     * @returns {Object|null} Parsed config oder null.
+     */
+    load(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
+        if (!fs.existsSync(configPath)) return null;
+
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+            
+            if (readResult.error) {
+                return null;
+            }
+
+            const parsed = ts.parseJsonConfigFileContent(
+                readResult.config,
+                ts.sys,
+                this.targetDir
+            );
+
+            // Attach raw config for reference inspection
+            parsed._rawConfig = readResult.config;
+
+            return parsed;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    /**
+     * Extracts project references from tsconfig (composite monorepo support).
+     * @returns {string[]} Array of referenced tsconfig paths
+     */
+    getProjectReferences(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
+        if (!fs.existsSync(configPath)) return [];
+
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            // Strip comments
+            const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const raw = JSON.parse(stripped);
+            const refs = raw.references || [];
+            return refs.map(ref => {
+                const refPath = path.resolve(this.targetDir, ref.path);
+                // If it's a directory, look for tsconfig.json inside
+                if (fs.existsSync(refPath) && fs.statSync(refPath).isDirectory()) {
+                    return path.join(refPath, 'tsconfig.json');
+                }
+                return refPath;
+            });
+        } catch (e) {
+            return [];
+        }
+    }
+
+    /**
+     * Extracts the "extends" chain from tsconfig.
+     * @returns {string[]} Array of extended tsconfig paths
+     */
+    getExtendsChain(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
+        if (!fs.existsSync(configPath)) return [];
+
+        const chain = [];
+        let currentPath = configPath;
+
+        for (let i = 0; i < 10; i++) { // limit depth to avoid infinite loops
+            try {
+                const content = fs.readFileSync(currentPath, 'utf8');
+                const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                const raw = JSON.parse(stripped);
+                if (!raw.extends) break;
+                const extendedPath = path.resolve(path.dirname(currentPath), raw.extends);
+                const resolvedPath = extendedPath.endsWith('.json') ? extendedPath : extendedPath + '.json';
+                if (!fs.existsSync(resolvedPath)) break;
+                chain.push(resolvedPath);
+                currentPath = resolvedPath;
+            } catch (e) {
+                break;
+            }
+        }
+
+        return chain;
+    }
+
+    /**
+     * Erstellt eine Mapping-Funktion für Aliases aus der tsconfig.
+     * Berücksichtigt baseUrl, paths und project references.
+     * @param {Object} parsedConfig 
+     * @returns {Function} Mapper function.
+     */
+    getAliasMapper(parsedConfig) {
+        if (!parsedConfig || !parsedConfig.options) {
+            return (source) => source;
+        }
+
+        const { paths, baseUrl } = parsedConfig.options;
+        const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
+
+        return (source) => {
+            // If no paths configured, still try baseUrl resolution
+            if (!paths) {
+                if (baseUrl && !source.startsWith('.') && !source.startsWith('/') && !source.startsWith('@')) {
+                    const candidate = path.resolve(base, source);
+                    const extensions = ['', '.ts', '.tsx', '.mjs', '.jsx'];
+                    for (const ext of extensions) {
+                        if (fs.existsSync(candidate + ext)) return candidate + ext;
+                    }
+                }
+                return source;
+            }
+
+            for (const pattern in paths) {
+                const regexPattern = pattern.replace(/\*/g, '(.*)');
+                const regex = new RegExp(`^${regexPattern}$`);
+                const match = source.match(regex);
+
+                if (match) {
+                    const replacements = paths[pattern];
+                    for (const replacement of replacements) {
+                        const resolvedReplacement = replacement.replace(/\*/g, match[1] || '');
+                        const fullPath = path.resolve(base, resolvedReplacement);
+                        
+                        // Check with common extensions
+                        const extensions = ['', '.ts', '.tsx', '.mjs', '.jsx', '/index.ts', '/index.tsx', '/index.mjs'];
+                        for (const ext of extensions) {
+                            if (fs.existsSync(fullPath + ext)) {
+                                return fullPath + ext;
+                            }
+                        }
+                    }
+                }
+            }
+            return source;
+        };
+    }
+
+    /**
+     * Returns all include/exclude glob patterns from tsconfig.
+     */
+    getIncludeExcludePatterns(parsedConfig) {
+        if (!parsedConfig || !parsedConfig._rawConfig) return { include: [], exclude: [] };
+        return {
+            include: parsedConfig._rawConfig.include || [],
+            exclude: parsedConfig._rawConfig.exclude || []
+        };
+    }
+}

package/src/resolution/WorkSpaceGraph.mjs

@@ -0,0 +1,183 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export class WorkspaceGraph {
+  constructor(context) { 
+    this.context = context; 
+    this.packageManifests = new Map(); // dirPath -> manifestData
+    this.workspacePackages = new Map(); // packageName -> dirPath
+    this.tsconfigPaths = new Map(); // packageName -> tsconfigData
+  }
+
+  async initializeWorkspaceMesh() {
+    const rootPkgPath = path.join(this.context.cwd, 'package.json');
+    try {
+      const rootPkg = JSON.parse(await fs.readFile(rootPkgPath, 'utf8'));
+      let workspaces = [];
+
+      // 1. Detect Workspaces (npm/yarn/pnpm/lerna)
+      if (rootPkg.workspaces) {
+        workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces.packages || [];
+      } else {
+        // Fallback for pnpm-workspace.yaml
+        const pnpmWorkspacePath = path.join(this.context.cwd, 'pnpm-workspace.yaml');
+        try {
+          const yaml = await fs.readFile(pnpmWorkspacePath, 'utf8');
+          const match = yaml.match(/packages:\n((?:\s+- .+\n?)+)/);
+          if (match) {
+            workspaces = match[1].split('\n')
+              .filter(line => line.trim().startsWith('-'))
+              .map(line => line.replace('-', '').trim().replace(/['"]/g, ''));
+          }
+        } catch (e) {}
+      }
+
+      if (workspaces.length > 0) {
+        this.context.isWorkspaceEnabled = true;
+        if (this.context.verbose) console.log(`[Workspace] Detected workspaces:`, workspaces);
+
+        for (const pattern of workspaces) {
+          const matches = await this._expandGlob(pattern, this.context.cwd);
+          for (const matchDir of matches) {
+            const pkgPath = path.join(matchDir, 'package.json');
+            try {
+              const pkgData = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+              const normalizedDir = matchDir.replace(/\\/g, '/');
+              
+              this.packageManifests.set(normalizedDir, {
+                rootDirectory: normalizedDir,
+                manifestPath: pkgPath.replace(/\\/g, '/'),
+                name: pkgData.name,
+                dependencies: pkgData.dependencies || {},
+                devDependencies: pkgData.devDependencies || {},
+                peerDependencies: pkgData.peerDependencies || {},
+                scripts: pkgData.scripts || {},
+                entryPoints: this.calculatePackageExportsEntries(pkgData, normalizedDir)
+              });
+
+              if (pkgData.name) {
+                this.workspacePackages.set(pkgData.name, normalizedDir);
+                this.context.monorepoPackageRoots.add(normalizedDir);
+              }
+
+              // Also try to load tsconfig.json for this workspace
+              const tsconfigPath = path.join(matchDir, 'tsconfig.json');
+              try {
+                const tsconfigData = JSON.parse(await fs.readFile(tsconfigPath, 'utf8'));
+                if (pkgData.name) this.tsconfigPaths.set(pkgData.name, tsconfigData);
+              } catch(e) {}
+
+            } catch (e) {}
+          }
+        }
+      }
+    } catch (e) {
+      if (this.context.verbose) console.log('[Workspace] No root package.json found or invalid.');
+    }
+  }
+
+  calculatePackageExportsEntries(pkgData, dirPath) {
+    const entries = [];
+    const addEntry = (p) => {
+      if (typeof p === 'string') entries.push(path.resolve(dirPath, p).replace(/\\/g, '/'));
+    };
+
+    if (pkgData.main) addEntry(pkgData.main);
+    if (pkgData.module) addEntry(pkgData.module);
+    if (pkgData.source) addEntry(pkgData.source);
+    if (pkgData.types) addEntry(pkgData.types);
+    if (pkgData.typings) addEntry(pkgData.typings);
+
+    if (pkgData.bin) {
+      if (typeof pkgData.bin === 'string') addEntry(pkgData.bin);
+      else Object.values(pkgData.bin).forEach(addEntry);
+    }
+
+    if (pkgData.exports) {
+      const traverseExports = (obj) => {
+        if (typeof obj === 'string') {
+          addEntry(obj);
+        } else if (typeof obj === 'object' && obj !== null) {
+          for (const key in obj) traverseExports(obj[key]);
+        }
+      };
+      traverseExports(pkgData.exports);
+    }
+
+    return entries;
+  }
+
+  isLocalWorkspaceSpecifier(specifier) {
+    if (!specifier) return false;
+    // Direct match
+    if (this.workspacePackages.has(specifier)) return true;
+    // Sub-path match (e.g. @my-org/ui/components)
+    for (const pkgName of this.workspacePackages.keys()) {
+      if (specifier.startsWith(pkgName + '/')) return true;
+    }
+    return false;
+  }
+
+  getWorkspacePackageMatch(specifier) {
+    if (this.workspacePackages.has(specifier)) {
+      const dir = this.workspacePackages.get(specifier);
+      return this.packageManifests.get(dir);
+    }
+    for (const pkgName of this.workspacePackages.keys()) {
+      if (specifier.startsWith(pkgName + '/')) {
+        const dir = this.workspacePackages.get(pkgName);
+        return this.packageManifests.get(dir);
+      }
+    }
+    return null;
+  }
+
+  markWorkspacePackagesAsUsed() {
+    for (const [pkgName, dirPath] of this.workspacePackages.entries()) {
+      this.context.usedExternalPackages.add(pkgName);
+    }
+  }
+
+  /**
+   * Expands a workspace glob pattern (e.g. 'packages/*') to absolute directory paths.
+   * Supports single-level wildcards and direct paths.
+   */
+  async _expandGlob(pattern, cwd) {
+    const results = [];
+    
+    // Remove trailing slash
+    const cleanPattern = pattern.replace(/\/$/, '');
+    
+    // Handle simple wildcard patterns like 'packages/*' or 'apps/*'
+    if (cleanPattern.includes('*')) {
+      const parts = cleanPattern.split('/');
+      const wildcardIndex = parts.findIndex(p => p.includes('*'));
+      const baseDir = path.join(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);
+            // Check if it has a package.json
+            try {
+              await fs.access(path.join(fullPath, 'package.json'));
+              results.push(fullPath.replace(/\\/g, '/'));
+            } catch (e) {}
+          }
+        }
+      } catch (e) {}
+    } else {
+      // Direct path
+      const fullPath = path.resolve(cwd, cleanPattern);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) {
+          results.push(fullPath.replace(/\\/g, '/'));
+        }
+      } catch (e) {}
+    }
+    
+    return results;
+  }
+}

package/src/resolution/WorkspaceDiagnostic.mjs

@@ -0,0 +1,139 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * WorkspaceDiagnostic
+ * Performs health checks and architectural boundary enforcement for Monorepo workspaces.
+ * Detects cross-package import violations, version mismatches, and missing workspace declarations.
+ */
+export class WorkspaceDiagnostic {
+  constructor(context) { 
+    this.context = context; 
+    this.findings = [];
+  }
+
+  async checkWorkspaceHealth() {
+    this.findings = [];
+
+    if (!this.context.isWorkspaceEnabled) return this.findings;
+
+    const rootPkgPath = this.context.cwd ? path.join(this.context.cwd, 'package.json') : null;
+    let rootPkg = {};
+    try {
+      if (rootPkgPath) rootPkg = JSON.parse(await fs.readFile(rootPkgPath, 'utf8'));
+    } catch (e) {}
+
+    // 1. Check for version mismatches across workspace packages
+    const versionMap = new Map(); // dep name -> { version, source }
+    for (const [dir, manifest] of (this.context.monorepoPackageRoots || new Set()).entries ? [] : (this.context.monorepoPackageRoots || [])) {
+      // iterate over monorepoPackageRoots as a Set
+    }
+
+    // Use workspaceGraph if available
+    if (this.context.workspaceGraph && this.context.workspaceGraph.packageManifests) {
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        const allDeps = {
+          ...manifest.dependencies,
+          ...manifest.devDependencies
+        };
+        for (const [dep, version] of Object.entries(allDeps)) {
+          if (!versionMap.has(dep)) {
+            versionMap.set(dep, []);
+          }
+          versionMap.get(dep).push({ version, source: manifest.name || dir });
+        }
+      }
+
+      // Report version mismatches
+      for (const [dep, usages] of versionMap.entries()) {
+        const uniqueVersions = new Set(usages.map(u => u.version));
+        if (uniqueVersions.size > 1) {
+          this.findings.push({
+            type: 'version-mismatch',
+            severity: 'warning',
+            message: `Dependency "${dep}" has conflicting versions across workspace packages: ${[...uniqueVersions].join(', ')}`,
+            packages: usages.map(u => u.source)
+          });
+        }
+      }
+
+      // 2. Check for missing workspace package declarations in root
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        if (!manifest.name) continue;
+        const rootDeps = {
+          ...rootPkg.dependencies,
+          ...rootPkg.devDependencies,
+          ...rootPkg.peerDependencies
+        };
+        // If the workspace package is referenced in root deps but not as "workspace:*"
+        if (rootDeps[manifest.name] && !rootDeps[manifest.name].startsWith('workspace:')) {
+          this.findings.push({
+            type: 'workspace-declaration-missing',
+            severity: 'info',
+            message: `Workspace package "${manifest.name}" is referenced in root package.json without "workspace:" protocol`,
+            packages: ['root', manifest.name]
+          });
+        }
+      }
+
+      // 3. Check for packages that have no entry points defined
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        if (!manifest.entryPoints || manifest.entryPoints.length === 0) {
+          this.findings.push({
+            type: 'missing-entry-point',
+            severity: 'warning',
+            message: `Workspace package "${manifest.name || dir}" has no entry points (main/module/exports) defined in package.json`,
+            packages: [manifest.name || dir]
+          });
+        }
+      }
+    }
+
+    return this.findings;
+  }
+
+  enforceBoundaries(filePath, imports) {
+    const violations = [];
+    if (!this.context.isWorkspaceEnabled) return violations;
+    if (!this.context.workspaceGraph || !this.context.workspaceGraph.packageManifests) return violations;
+
+    // Determine which workspace package this file belongs to
+    let sourcePackage = null;
+    for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+      if (filePath.startsWith(dir + '/') || filePath.startsWith(dir + '\\')) {
+        sourcePackage = manifest;
+        break;
+      }
+    }
+
+    if (!sourcePackage) return violations;
+
+    // Check each import
+    for (const specifier of imports) {
+      if (!specifier || specifier.startsWith('.') || specifier.startsWith('/')) continue;
+
+      // Check if the import is a workspace package
+      if (this.context.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+        const targetManifest = this.context.workspaceGraph.getWorkspacePackageMatch(specifier);
+        if (targetManifest && targetManifest.name) {
+          // Check if the target package is declared as a dependency of the source package
+          const sourceDeps = {
+            ...sourcePackage.dependencies,
+            ...sourcePackage.devDependencies,
+            ...sourcePackage.peerDependencies
+          };
+          if (!sourceDeps[targetManifest.name]) {
+            violations.push({
+              type: 'undeclared-workspace-dependency',
+              severity: 'error',
+              message: `Package "${sourcePackage.name}" imports "${specifier}" but "${targetManifest.name}" is not declared as a dependency`,
+              file: filePath
+            });
+          }
+        }
+      }
+    }
+
+    return violations;
+  }
+}

package/test.js

@@ -0,0 +1,76 @@
+import { execa } from 'execa';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const projectRoot = path.resolve(__dirname);
+const entkappCli = path.join(projectRoot, 'bin', 'cli.mjs');
+
+const playgrounds = [
+  'playgrounds/basic',
+  'playgrounds/hard',
+  'playgrounds/intermediate',
+  'playgrounds/monorepo-basic/packages/app',
+  'playgrounds/monorepo-basic/packages/ui',
+  'playgrounds/monorepo-basic/packages/utils',
+  'playgrounds/monorepo-hard/packages/api',
+  'playgrounds/monorepo-hard/packages/app',
+  'playgrounds/monorepo-hard/packages/domain',
+  'playgrounds/monorepo-hard/packages/services',
+  'playgrounds/monorepo-intermediate/packages/app',
+  'playgrounds/monorepo-intermediate/packages/ui',
+  'playgrounds/monorepo-intermediate/packages/utils',
+  'playgrounds/monorepo-nightmare/packages/app',
+  'playgrounds/monorepo-nightmare/packages/bridge',
+  'playgrounds/monorepo-nightmare/packages/core',
+  'playgrounds/monorepo-normal/packages/app',
+  'playgrounds/monorepo-normal/packages/lib-a',
+  'playgrounds/monorepo-normal/packages/lib-b',
+  'playgrounds/nightmare',
+  'playgrounds/normal',
+];
+
+async function runTest() {
+  let allTestsPassed = true;
+
+  for (const playground of playgrounds) {
+    const cwd = path.join(projectRoot, playground);
+    console.log(`\nRunning entkapp in: ${playground}`);
+    try {
+      const { stdout } = await execa('node', [entkappCli, '-r', '--cwd', cwd, '--yes'], { cwd: projectRoot });
+      console.log(stdout);
+
+      if (stdout.includes('Core optimization cycle completed smoothly')) {
+        console.log(`✅ Test passed for ${playground}`);
+      } else {
+        console.error(`❌ Test failed for ${playground}: Expected success message not found.`);
+        allTestsPassed = false;
+      }
+
+      // Add specific assertions for each playground if needed
+      if (playground === 'playgrounds/basic') {
+        if (!stdout.includes('Remove 1 unused dependencies:')) {
+          console.error(`❌ Basic playground test failed: Expected unused dependency detection.`);
+          allTestsPassed = false;
+        }
+      }
+
+    } catch (error) {
+      console.error(`❌ Test failed for ${playground}:`, error.message);
+      console.error(error.stdout);
+      allTestsPassed = false;
+    }
+  }
+
+  if (allTestsPassed) {
+    console.log('\n🎉 All playground tests completed successfully!');
+    process.exit(0);
+  } else {
+    console.error('\n🔥 Some playground tests failed.');
+    process.exit(1);
+  }
+}
+
+runTest();

package/wrangler.toml

@@ -0,0 +1,6 @@
+name = "entkapp"
+pages_build_output_dir = "docs/.vitepress/dist"
+
+[vars]
+NODE_VERSION = "22.16.0"
+PNPM_VERSION = "10.11.1"