entkapp 5.4.0 → 5.6.0

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"