entkapp 5.2.4 → 5.3.1

package/src/resolution/ConfigLoader.js

@@ -1,4 +1,90 @@
+import fs from 'fs/promises';
+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)
+ */
 export class ConfigLoader {
-  constructor(cwd) { this.cwd = cwd; }
-  async loadConfig() { return {}; }
+  constructor(cwd) { 
+    this.cwd = cwd; 
+  }
+
+  async loadConfig(overrides = {}) {
+    let config = this._defaultConfig();
+
+    // 1. Try 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);
+    } catch (e) {}
+
+    // 2. Try entkapp.config.js / entkapp.config.mjs
+    for (const configFile of ['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') {
+          config = this._merge(config, jsConfig);
+          break;
+        }
+      } catch (e) {}
+    }
+
+    // 3. Try package.json "entkapp" key
+    const pkgPath = path.join(this.cwd, 'package.json');
+    try {
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+      if (pkg.entkapp && typeof pkg.entkapp === 'object') {
+        config = this._merge(config, pkg.entkapp);
+      }
+    } catch (e) {}
+
+    // 4. Apply CLI overrides
+    config = this._merge(config, overrides);
+
+    return config;
+  }
+
+  _defaultConfig() {
+    return {
+      interface: 'CLI',
+      useBuiltinPlugins: true,
+      useCustomPlugins: true,
+      options: {
+        verbose: false,
+        fastMode: true,
+        selfHealing: true
+      },
+      enabledPlugins: [],
+      ignoreDependencies: ['entkapp', '@types/*'],
+      exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
+      entryPoints: [],
+      workspace: false
+    };
+  }
+
+  _merge(base, override) {
+    if (!override || typeof override !== 'object') return base;
+    const result = { ...base };
+    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];
+      }
+    }
+    return result;
+  }
 }

package/src/resolution/DepencyResolver.js

@@ -25,8 +25,23 @@ export class DependencyResolver {
   resolveModulePath(sourceFile, specifier) {
     const cleanSource = this.normalizePath(sourceFile);
     
+    // Check if it's a workspace package reference
+    if (this.context.isWorkspaceEnabled && this.workspaceGraph && this.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+      const match = this.workspaceGraph.getWorkspacePackageMatch(specifier);
+      if (match && match.entryPoints && match.entryPoints.length > 0) {
+        // Return the first entry point for the workspace package
+        return this.normalizePath(match.entryPoints[0]);
+      }
+    }
+
     // UPGRADE: Use PathMapper for sophisticated resolution (TS-to-JS, aliases, etc.)
     if (this.pathMapper) {
+      // Allow pathMapper to resolve aliases directly from specifier
+      const aliasResolved = this.pathMapper.resolvePath(specifier);
+      if (aliasResolved && aliasResolved !== specifier && existsSync(aliasResolved)) {
+         return this.normalizePath(aliasResolved);
+      }
+
       const dir = path.dirname(cleanSource);
       const target = path.resolve(dir, specifier);
       const resolved = this.pathMapper.resolvePath(target);

package/src/resolution/DependencyProfiler.js

@@ -146,9 +146,44 @@ export class DependencyProfiler {
     const usedPackages = new Set();
     const usedBinaries = new Set(); // NEW: Track which binaries are actually used
     
-    // 1. Scan package.json scripts
+    // 1. Scan package.json scripts (Root)
+    await this._scanDirectoryForConfigs(projectRoot, usedPackages, usedBinaries);
+
+    // 1.5 Scan Workspace package.json scripts and configs
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._scanDirectoryForConfigs(workspaceRoot, usedPackages, usedBinaries);
+      }
+    }
+
+    // 2. Scan CI workflows
+    try {
+      const githubWorkflows = path.join(projectRoot, '.github/workflows');
+      const files = await fs.readdir(githubWorkflows).catch(() => []);
+      for (const file of files) {
+        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
+          this.extractPackagesFromScript(content, usedPackages, usedBinaries);
+        }
+      }
+    } catch (e) {}
+
+    // 4. Identify Unused Binaries (Root)
+    await this._identifyUnusedBinaries(projectRoot, usedBinaries);
+    
+    // 4.5 Identify Unused Binaries (Workspaces)
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._identifyUnusedBinaries(workspaceRoot, usedBinaries);
+      }
+    }
+
+    return usedPackages;
+  }
+
+  async _scanDirectoryForConfigs(dir, usedPackages, usedBinaries) {
     try {
-      const pkgJsonPath = path.join(projectRoot, 'package.json');
+      const pkgJsonPath = path.join(dir, 'package.json');
       const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
       
       if (pkg.scripts) {
@@ -157,7 +192,6 @@ export class DependencyProfiler {
         }
       }
 
-      // Detect @types/* usage
       if (pkg.dependencies || pkg.devDependencies) {
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         for (const depName of Object.keys(allDeps)) {
@@ -168,21 +202,8 @@ export class DependencyProfiler {
       }
     } catch (e) {}
 
-    // 2. Scan CI workflows
     try {
-      const githubWorkflows = path.join(projectRoot, '.github/workflows');
-      const files = await fs.readdir(githubWorkflows).catch(() => []);
-      for (const file of files) {
-        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
-          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
-          this.extractPackagesFromScript(content, usedPackages, usedBinaries);
-        }
-      }
-    } catch (e) {}
-
-    // 3. Scan config files
-    try {
-      const dirEntries = await fs.readdir(projectRoot, { withFileTypes: true });
+      const dirEntries = await fs.readdir(dir, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!entry.isFile()) continue;
         const fileName = entry.name;
@@ -194,15 +215,14 @@ export class DependencyProfiler {
         }
       }
     } catch (e) {}
+  }
 
-    // 4. Identify Unused Binaries
-    // Scan node_modules/.bin for all available binaries
+  async _identifyUnusedBinaries(dir, usedBinaries) {
     try {
-      const binDir = path.join(projectRoot, 'node_modules', '.bin');
+      const binDir = path.join(dir, 'node_modules', '.bin');
       const availableBinaries = await fs.readdir(binDir).catch(() => []);
       
       for (const bin of availableBinaries) {
-        // Skip hidden files or package manager internal bins
         if (bin.startsWith('.') || ['npm', 'pnpm', 'yarn', 'bun'].includes(bin)) continue;
         
         if (!usedBinaries.has(bin)) {
@@ -210,8 +230,6 @@ export class DependencyProfiler {
         }
       }
     } catch (e) {}
-
-    return usedPackages;
   }
 
   extractPackagesFromScript(script, packageCollector, binaryCollector) {

package/src/resolution/PathMapper.js

@@ -1,13 +1,35 @@
 import fs from 'fs';
 import path from 'path';
+import { TSConfigLoader } from './TSConfigLoader.js';
 
 export class PathMapper {
   constructor(context) { 
     this.context = context; 
+    this.aliasMappers = []; // list of alias mapping functions
   }
   
-  async loadMappings() {
-    // Tsconfig paths can be loaded here later
+  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}`);
+        }
+      }
+    }
   }
 
   /**
@@ -18,25 +40,36 @@ export class PathMapper {
   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 (p.endsWith('.js')) {
-      const tsPath = p.slice(0, -3) + '.ts';
+    if (resolvedP.endsWith('.js')) {
+      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 (p.endsWith('.jsx')) {
-      const tsxPath = p.slice(0, -4) + '.tsx';
+    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(p);
+      const stat = fs.statSync(resolvedP);
       if (stat.isDirectory()) {
         const extensions = ['.ts', '.tsx', '.js', '.jsx'];
         for (const ext of extensions) {
-          const indexPath = path.join(p, `index${ext}`);
+          const indexPath = path.join(resolvedP, `index${ext}`);
           if (fs.existsSync(indexPath)) return indexPath;
         }
       }
@@ -44,6 +77,6 @@ export class PathMapper {
       // File does not exist or is not a directory, continue with default
     }
 
-    return p; 
+    return resolvedP; 
   }
 }

package/src/resolution/TSConfigLoader.js

@@ -9,39 +9,102 @@ export class TSConfigLoader {
 
     /**
      * 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() {
-        const configPath = path.join(this.targetDir, 'tsconfig.json');
+    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 result = ts.parseConfigFileTextWithComments(configPath, content);
+            const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
             
-            if (result.error) {
+            if (readResult.error) {
                 return null;
             }
 
             const parsed = ts.parseJsonConfigFileContent(
-                result.config,
+                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 || !parsedConfig.options.paths) {
+        if (!parsedConfig || !parsedConfig.options) {
             return (source) => source;
         }
 
@@ -49,19 +112,31 @@ export class TSConfigLoader {
         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', '.js', '.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(/\*/, '(.*)');
+                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(/\*/, match[1]);
+                        const resolvedReplacement = replacement.replace(/\*/g, match[1] || '');
                         const fullPath = path.resolve(base, resolvedReplacement);
                         
-                        // Prüfe ob Datei existiert
-                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+                        // Check with common extensions
+                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
                         for (const ext of extensions) {
                             if (fs.existsSync(fullPath + ext)) {
                                 return fullPath + ext;
@@ -73,4 +148,15 @@ export class TSConfigLoader {
             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,8 +1,183 @@
+import fs from 'fs/promises';
+import path from 'path';
+
 export class WorkspaceGraph {
   constructor(context) { 
     this.context = context; 
-    this.packageManifests = new Map();
+    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;
   }
-  async initializeWorkspaceMesh() {}
-  markWorkspacePackagesAsUsed() {}
 }