entkapp 5.4.0 → 5.6.0

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

@@ -1,208 +1,82 @@
 import fs from 'fs/promises';
 import path from 'path';
 
-/**
- * WorkspaceGraph
- *
- * Discovers and maps all packages in a monorepo/workspace setup.
- * Supported workspace manifests (in priority order):
- *   1. pnpm-workspace.yaml              (pnpm)
- *   2. package.json "workspaces" field  (npm / yarn / bun)
- *   3. lerna.json                       (Lerna)
- *   4. workspace.yaml                   (generic / custom toolchains)
- */
 export class WorkspaceGraph {
-  constructor(context) {
-    this.context = context;
-
-    /** @type {Map<string, Object>} dirPath -> manifest data */
-    this.packageManifests = new Map();
-
-    /** @type {Map<string, string>} packageName -> dirPath */
-    this.workspacePackages = new Map();
-
-    /** @type {Map<string, Object>} packageName -> parsed tsconfig data */
-    this.tsconfigPaths = new Map();
-
-    /**
-     * Per-package framework / tool config files.
-     * @type {Map<string, Array<{fileName: string, filePath: string, content: string}>>}
-     */
-    this.packageConfigFiles = new Map();
-
-    /**
-     * Global pipeline / monorepo configs (turbo.json, nx.json, etc.)
-     * @type {Map<string, Object>} fileName -> parsed content
-     */
-    this.monorepoConfigs = new Map();
+  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() {
-    let workspaces = [];
-
-    // 1. pnpm-workspace.yaml
-    workspaces = await this._parseWorkspaceYaml('pnpm-workspace.yaml');
-
-    // 2. package.json "workspaces"
-    if (workspaces.length === 0) {
-      try {
-        const rootPkgPath = path.join(this.context.cwd, 'package.json');
-        const rootPkg = JSON.parse(await fs.readFile(rootPkgPath, 'utf8'));
-        if (rootPkg.workspaces) {
-          workspaces = Array.isArray(rootPkg.workspaces)
-            ? rootPkg.workspaces
-            : rootPkg.workspaces.packages || [];
-        }
-      } catch (e) {}
-    }
-
-    // 3. lerna.json
-    if (workspaces.length === 0) {
-      try {
-        const lernaPath = path.join(this.context.cwd, 'lerna.json');
-        const lerna = JSON.parse(await fs.readFile(lernaPath, 'utf8'));
-        workspaces = lerna.packages || [];
-      } catch (e) {}
-    }
-
-    // 4. workspace.yaml
-    if (workspaces.length === 0) {
-      workspaces = await this._parseWorkspaceYaml('workspace.yaml');
-    }
-
-    await this._loadGlobalMonorepoConfigs();
-
-    if (workspaces.length === 0) return;
-
-    this.context.isWorkspaceEnabled = true;
-    if (this.context.verbose) {
-      console.log('[Workspace] Detected workspace patterns:', workspaces);
-    }
-
-    for (const pattern of workspaces) {
-      const matches = await this._expandGlob(pattern, this.context.cwd);
-      for (const matchDir of matches) {
-        await this._loadPackageDir(matchDir);
-      }
-    }
-  }
-
-  async _loadGlobalMonorepoConfigs() {
-    const configFiles = ['turbo.json', 'nx.json'];
-    for (const file of configFiles) {
-      try {
-        const filePath = path.join(this.context.cwd, file);
-        const content = JSON.parse(await fs.readFile(filePath, 'utf8'));
-        this.monorepoConfigs.set(file, content);
-      } catch (e) {}
-    }
-  }
-
-  async _parseWorkspaceYaml(fileName) {
-    const yamlPath = path.join(this.context.cwd, fileName);
+    const rootPkgPath = path.join(this.context.cwd, 'package.json');
     try {
-      const raw = await fs.readFile(yamlPath, '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;
+      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, ''));
           }
-          if (trimmed.startsWith('-')) {
-            const val = trimmed.substring(1).trim().replace(/^['"]|['"]$/g, '');
-            if (val) patterns.push(val);
+        } 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) {}
           }
         }
       }
-      return patterns;
     } catch (e) {
-      return [];
+      if (this.context.verbose) console.log('[Workspace] No root package.json found or invalid.');
     }
   }
 
-  async _loadPackageDir(matchDir) {
-    const normalizedDir = matchDir.replace(/\\/g, '/');
-    const pkgPath = path.join(matchDir, 'package.json');
-    let pkgData = null;
-
-    try {
-      pkgData = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
-    } catch (e) {
-      // UPGRADE: If no package.json, it's not a package – skip silently
-      return;
-    }
-
-    const packageName = pkgData.name || path.basename(matchDir);
-
-    this.packageManifests.set(normalizedDir, {
-      rootDirectory: normalizedDir,
-      manifestPath: pkgPath.replace(/\\/g, '/'),
-      name: packageName,
-      version: pkgData.version,
-      dependencies: pkgData.dependencies || {},
-      devDependencies: pkgData.devDependencies || {},
-      peerDependencies: pkgData.peerDependencies || {},
-      scripts: pkgData.scripts || {},
-      entryPoints: await this.calculatePackageExportsEntries(pkgData, normalizedDir)
-    });
-
-    this.workspacePackages.set(packageName, normalizedDir);
-    this.context.monorepoPackageRoots.add(normalizedDir);
-
-    // tsconfig.json
-    const tsconfigPath = path.join(matchDir, 'tsconfig.json');
-    try {
-      const tsconfigRaw = await fs.readFile(tsconfigPath, 'utf8');
-      const stripped = tsconfigRaw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      const tsconfigData = JSON.parse(stripped);
-      this.tsconfigPaths.set(packageName, tsconfigData);
-      this.tsconfigPaths.set(normalizedDir, tsconfigData);
-    } catch (e) {}
-
-    await this._loadPackageConfigFiles(matchDir, normalizedDir, packageName);
-  }
-
-  async _loadPackageConfigFiles(packageDir, normalizedDir, packageName) {
-    const configEntries = [];
-    let dirEntries;
-    try {
-      dirEntries = await fs.readdir(packageDir, { withFileTypes: true });
-    } catch (e) { return; }
-
-    for (const entry of dirEntries) {
-      if (!entry.isFile()) continue;
-      const isConfig = /\.config\.(ts|js|mjs|cjs)$/.test(entry.name);
-      const isJson = entry.name === 'package.json' || entry.name === 'tsconfig.json';
-      
-      if (!isConfig && !isJson) continue;
-
-      const filePath = path.join(packageDir, entry.name).replace(/\\/g, '/');
-      try {
-        const content = await fs.readFile(filePath, 'utf8');
-        configEntries.push({ fileName: entry.name, filePath, content });
-      } catch (e) {}
-    }
-    if (configEntries.length > 0) this.packageConfigFiles.set(normalizedDir, configEntries);
-  }
-
-  async calculatePackageExportsEntries(pkgData, dirPath) {
+  calculatePackageExportsEntries(pkgData, dirPath) {
     const entries = [];
     const addEntry = (p) => {
       if (typeof p === 'string') entries.push(path.resolve(dirPath, p).replace(/\\/g, '/'));
@@ -213,7 +87,7 @@ export class WorkspaceGraph {
     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);
@@ -221,33 +95,23 @@ export class WorkspaceGraph {
 
     if (pkgData.exports) {
       const traverseExports = (obj) => {
-        if (typeof obj === 'string') addEntry(obj);
-        else if (typeof obj === 'object' && obj !== null) {
+        if (typeof obj === 'string') {
+          addEntry(obj);
+        } else if (typeof obj === 'object' && obj !== null) {
           for (const key in obj) traverseExports(obj[key]);
         }
       };
       traverseExports(pkgData.exports);
     }
 
-    // UPGRADE: If no explicit entry points found, look for standard index files (poly-extension)
-    if (entries.length === 0) {
-      const standardIndexFiles = ['index.js', 'index.ts', 'index.jsx', 'index.tsx', 'index.mjs', 'index.cjs'];
-      for (const fileName of standardIndexFiles) {
-        const fullPath = path.join(dirPath, fileName);
-        try {
-          await fs.access(fullPath);
-          addEntry(fileName);
-          break; // Take the first one found
-        } catch {}
-      }
-    }
-
     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;
     }
@@ -269,86 +133,51 @@ export class WorkspaceGraph {
   }
 
   markWorkspacePackagesAsUsed() {
-    for (const [pkgName] of this.workspacePackages.entries()) {
+    for (const [pkgName, dirPath] of this.workspacePackages.entries()) {
       this.context.usedExternalPackages.add(pkgName);
     }
   }
 
-  async findFrameworkConfigs() {
-    const configFiles = new Set();
-    await this._scanDirForConfigs(this.context.cwd, configFiles);
-    for (const [dir, entries] of this.packageConfigFiles.entries()) {
-      for (const { fileName, filePath } of entries) {
-        if (/\.config\.(ts|js|mjs|cjs)$/.test(fileName)) configFiles.add(filePath);
-      }
-    }
-    for (const root of this.context.monorepoPackageRoots) {
-      const normalizedRoot = root.replace(/\\/g, '/');
-      if (!this.packageConfigFiles.has(normalizedRoot)) await this._scanDirForConfigs(root, configFiles);
-    }
-    return Array.from(configFiles);
-  }
-
-  async _scanDirForConfigs(dir, configFiles) {
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.includes('.config.') && /\.(ts|js|mjs|cjs)$/.test(entry.name)) {
-          configFiles.add(path.join(dir, entry.name).replace(/\\/g, '/'));
-        }
-      }
-    } catch (e) {}
-  }
-
-  getPackageConfigFiles(dirOrName) {
-    const normalized = dirOrName.replace(/\\/g, '/');
-    if (this.packageConfigFiles.has(normalized)) return this.packageConfigFiles.get(normalized);
-    const dir = this.workspacePackages.get(dirOrName);
-    if (dir) return this.packageConfigFiles.get(dir) || [];
-    return [];
-  }
-
-  getPackageTsConfig(dirOrName) {
-    const normalized = dirOrName.replace(/\\/g, '/');
-    if (this.tsconfigPaths.has(normalized)) return this.tsconfigPaths.get(normalized);
-    const dir = this.workspacePackages.get(dirOrName);
-    if (dir) return this.tsconfigPaths.get(dir);
-    return undefined;
-  }
-
-  getSummary() {
-    return {
-      packages: this.packageManifests.size,
-      tsconfigsLoaded: this.tsconfigPaths.size,
-      configFilesLoaded: Array.from(this.packageConfigFiles.values()).reduce((sum, arr) => sum + arr.length, 0),
-      monorepoConfigs: Array.from(this.monorepoConfigs.keys()),
-      packageNames: Array.from(this.workspacePackages.keys())
-    };
-  }
-
+  /**
+   * 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);
-            results.push(fullPath.replace(/\\/g, '/'));
+            // 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, '/'));
+        if (stat.isDirectory()) {
+          results.push(fullPath.replace(/\\/g, '/'));
+        }
       } catch (e) {}
     }
+    
     return results;
   }
 }