entkapp 5.3.0 → 5.4.0

package/src/resolution/WorkSpaceGraph.js

@@ -1,82 +1,208 @@
 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; 
-    this.packageManifests = new Map(); // dirPath -> manifestData
-    this.workspacePackages = new Map(); // packageName -> dirPath
-    this.tsconfigPaths = new Map(); // packageName -> tsconfigData
+  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();
   }
 
   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) {}
+    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);
       }
+    }
+  }
 
-      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) {}
+  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);
+    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;
+          }
+          if (trimmed.startsWith('-')) {
+            const val = trimmed.substring(1).trim().replace(/^['"]|['"]$/g, '');
+            if (val) patterns.push(val);
           }
         }
       }
+      return patterns;
     } catch (e) {
-      if (this.context.verbose) console.log('[Workspace] No root package.json found or invalid.');
+      return [];
     }
   }
 
-  calculatePackageExportsEntries(pkgData, dirPath) {
+  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) {
     const entries = [];
     const addEntry = (p) => {
       if (typeof p === 'string') entries.push(path.resolve(dirPath, p).replace(/\\/g, '/'));
@@ -87,7 +213,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);
@@ -95,23 +221,33 @@ 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;
     }
@@ -133,51 +269,86 @@ export class WorkspaceGraph {
   }
 
   markWorkspacePackagesAsUsed() {
-    for (const [pkgName, dirPath] of this.workspacePackages.entries()) {
+    for (const [pkgName] 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 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())
+    };
+  }
+
   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) {}
+            results.push(fullPath.replace(/\\/g, '/'));
           }
         }
       } 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;
   }
 }