@morojs/moro 1.5.14 → 1.5.16

package/src/core/modules/auto-discovery.ts

@@ -1,14 +1,16 @@
 // Auto-discovery system for Moro modules
 import { readdirSync, statSync } from 'fs';
-import { join, extname } from 'path';
+import { join, extname, relative, isAbsolute } from 'path';
 import { ModuleConfig } from '../../types/module';
 import { DiscoveryOptions } from '../../types/discovery';
+import { ModuleDefaultsConfig } from '../../types/config';
 import { createFrameworkLogger } from '../logger';
 
 export class ModuleDiscovery {
   private baseDir: string;
   private options: DiscoveryOptions;
   private discoveryLogger = createFrameworkLogger('MODULE_DISCOVERY');
+  private watchers: any[] = []; // Store file watchers for cleanup
 
   constructor(baseDir: string = process.cwd(), options: DiscoveryOptions = {}) {
     this.baseDir = baseDir;
@@ -177,22 +179,483 @@ export class ModuleDiscovery {
     );
   }
 
+  // Enhanced auto-discovery with advanced configuration
+  async discoverModulesAdvanced(
+    config: ModuleDefaultsConfig['autoDiscovery']
+  ): Promise<ModuleConfig[]> {
+    if (!config.enabled) {
+      return [];
+    }
+
+    const allModules: ModuleConfig[] = [];
+
+    // Discover from all configured paths
+    for (const searchPath of config.paths) {
+      const modules = await this.discoverFromPath(searchPath, config);
+      allModules.push(...modules);
+    }
+
+    // Remove duplicates based on name@version
+    const uniqueModules = this.deduplicateModules(allModules);
+
+    // Sort modules based on load order strategy
+    const sortedModules = this.sortModules(uniqueModules, config.loadOrder);
+
+    // Validate dependencies if using dependency order
+    if (config.loadOrder === 'dependency') {
+      return this.resolveDependencyOrder(sortedModules);
+    }
+
+    return sortedModules;
+  }
+
+  // Discover modules from a specific path with advanced filtering
+  private async discoverFromPath(
+    searchPath: string,
+    config: ModuleDefaultsConfig['autoDiscovery']
+  ): Promise<ModuleConfig[]> {
+    const modules: ModuleConfig[] = [];
+    const fullPath = join(this.baseDir, searchPath);
+
+    try {
+      const stat = statSync(fullPath);
+
+      if (!stat.isDirectory()) {
+        return modules;
+      }
+    } catch (error) {
+      return modules;
+    }
+
+    try {
+      const files = await this.findMatchingFilesWithGlob(
+        fullPath,
+        config.patterns,
+        config.ignorePatterns,
+        config.maxDepth
+      );
+
+      for (const filePath of files) {
+        try {
+          // Convert relative path to absolute path for import
+          const absolutePath = join(this.baseDir, filePath);
+          const module = await this.loadModule(absolutePath);
+          if (module && this.validateAdvancedModule(module, config)) {
+            modules.push(module);
+            this.discoveryLogger.info(
+              `Auto-discovered module: ${module.name}@${module.version} from ${filePath}`
+            );
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+
+          if (config.failOnError) {
+            throw new Error(`Failed to load module from ${filePath}: ${errorMsg}`);
+          } else {
+            this.discoveryLogger.warn(
+              `Failed to load module from ${filePath}`,
+              'MODULE_DISCOVERY',
+              {
+                error: errorMsg,
+              }
+            );
+          }
+        }
+      }
+    } catch (error) {
+      if (config.failOnError) {
+        throw error;
+      }
+      // Directory doesn't exist or other error, continue silently
+    }
+
+    return modules;
+  }
+
+  // Find files matching patterns with ignore support
+  private findMatchingFiles(
+    basePath: string,
+    config: ModuleDefaultsConfig['autoDiscovery'],
+    currentDepth: number = 0
+  ): string[] {
+    const files: string[] = [];
+
+    if (currentDepth >= config.maxDepth) {
+      return files;
+    }
+
+    try {
+      const items = readdirSync(basePath);
+
+      for (const item of items) {
+        const fullPath = join(basePath, item);
+        const relativePath = relative(this.baseDir, fullPath);
+
+        // Check ignore patterns
+        if (this.shouldIgnore(relativePath, config.ignorePatterns)) {
+          continue;
+        }
+
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory() && config.recursive) {
+          files.push(...this.findMatchingFiles(fullPath, config, currentDepth + 1));
+        } else if (stat.isFile()) {
+          // Check if file matches any pattern
+          if (this.matchesPatterns(relativePath, config.patterns)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+      // Directory not accessible, skip
+    }
+
+    return files;
+  }
+
+  // Use native Node.js glob to find matching files
+  private async findMatchingFilesWithGlob(
+    searchPath: string,
+    patterns: string[],
+    ignorePatterns: string[],
+    maxDepth: number = 5
+  ): Promise<string[]> {
+    // Force fallback in CI environments or if Node.js version is uncertain
+    const isCI = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+
+    if (isCI) {
+      return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+    }
+
+    const allFiles: string[] = [];
+
+    try {
+      // Try to use native fs.glob if available (Node.js 20+)
+      const { glob } = await import('fs/promises');
+
+      // Check if glob is actually a function and test it
+      if (typeof glob !== 'function') {
+        return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+      }
+
+      // Test glob with a simple pattern first
+      try {
+        const testIterator = glob(join(searchPath, '*'));
+        let testCount = 0;
+        for await (const _ of testIterator) {
+          testCount++;
+          if (testCount > 0) break; // Just test that it works
+        }
+      } catch (testError) {
+        return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+      }
+
+      for (const pattern of patterns) {
+        const fullPattern = join(searchPath, pattern);
+        try {
+          // fs.glob returns an AsyncIterator, need to collect results
+          const globIterator = glob(fullPattern);
+          const files: string[] = [];
+
+          for await (const file of globIterator) {
+            const filePath = typeof file === 'string' ? file : (file as any).name || String(file);
+            const relativePath = relative(this.baseDir, filePath);
+
+            // Check if file should be ignored and within max depth
+            if (
+              !this.shouldIgnore(relativePath, ignorePatterns) &&
+              this.isWithinMaxDepth(relativePath, searchPath, maxDepth)
+            ) {
+              files.push(relativePath);
+            }
+          }
+
+          allFiles.push(...files);
+        } catch (error) {
+          // If any glob call fails, fall back to manual discovery
+          this.discoveryLogger.warn(`Glob pattern failed: ${pattern}`, String(error));
+          return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+        }
+      }
+    } catch (error) {
+      // fs.glob not available, fall back to manual file discovery
+      this.discoveryLogger.debug('Native fs.glob not available, using fallback');
+      return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+    }
+
+    return [...new Set(allFiles)]; // Remove duplicates
+  }
+
+  // Fallback for Node.js versions without fs.glob
+  private async findMatchingFilesFallback(
+    searchPath: string,
+    patterns: string[],
+    ignorePatterns: string[],
+    maxDepth: number = 5
+  ): Promise<string[]> {
+    const config = {
+      patterns,
+      ignorePatterns,
+      maxDepth,
+      recursive: true,
+    } as ModuleDefaultsConfig['autoDiscovery'];
+
+    // Handle both absolute and relative paths
+    const fullSearchPath = isAbsolute(searchPath) ? searchPath : join(this.baseDir, searchPath);
+
+    // Check if search path exists
+    try {
+      const { access } = await import('fs/promises');
+      await access(fullSearchPath);
+    } catch (e) {
+      return [];
+    }
+
+    // Get files and convert to relative paths
+    const files = this.findMatchingFiles(fullSearchPath, config);
+    const relativeFiles = files.map(file => relative(this.baseDir, file));
+
+    return relativeFiles;
+  }
+
+  // Simple pattern matching for fallback (basic glob support)
+  private matchesSimplePattern(path: string, pattern: string): boolean {
+    try {
+      // Normalize path separators
+      const normalizedPath = path.replace(/\\/g, '/');
+      const normalizedPattern = pattern.replace(/\\/g, '/');
+
+      // Convert simple glob patterns to regex
+      const regexPattern = normalizedPattern
+        .replace(/\*\*/g, '___DOUBLESTAR___') // Temporarily replace ** BEFORE escaping
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex chars
+        .replace(/\\\*/g, '[^/]*') // * matches anything except /
+        .replace(/___DOUBLESTAR___/g, '.*') // ** matches anything including /
+        .replace(/\\\?/g, '[^/]') // ? matches single character except /
+        .replace(/\\\{([^}]+)\\\}/g, '($1)') // {ts,js} -> (ts|js)
+        .replace(/,/g, '|'); // Convert comma to OR
+
+      const regex = new RegExp(`^${regexPattern}$`, 'i');
+      const result = regex.test(normalizedPath);
+
+      return result;
+    } catch (error) {
+      this.discoveryLogger.warn(`Pattern matching error for "${pattern}": ${String(error)}`);
+      return false;
+    }
+  }
+
+  // Check if path should be ignored
+  private shouldIgnore(path: string, ignorePatterns: string[]): boolean {
+    return ignorePatterns.some(pattern => this.matchesSimplePattern(path, pattern));
+  }
+
+  // Check if path matches any of the patterns
+  private matchesPatterns(path: string, patterns: string[]): boolean {
+    return patterns.some(pattern => this.matchesSimplePattern(path, pattern));
+  }
+
+  // Check if file is within max depth (for glob results)
+  private isWithinMaxDepth(relativePath: string, searchPath: string, maxDepth: number): boolean {
+    // Count directory separators to determine depth
+    const pathFromSearch = relative(searchPath, join(this.baseDir, relativePath));
+    const depth = pathFromSearch.split('/').length - 1; // -1 because file itself doesn't count as depth
+    return depth <= maxDepth;
+  }
+
+  // Remove duplicate modules
+  private deduplicateModules(modules: ModuleConfig[]): ModuleConfig[] {
+    const seen = new Set<string>();
+    return modules.filter(module => {
+      const key = `${module.name}@${module.version}`;
+      if (seen.has(key)) {
+        this.discoveryLogger.warn(`Duplicate module found: ${key}`, 'MODULE_DISCOVERY');
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  }
+
+  // Sort modules based on strategy
+  private sortModules(
+    modules: ModuleConfig[],
+    strategy: ModuleDefaultsConfig['autoDiscovery']['loadOrder']
+  ): ModuleConfig[] {
+    switch (strategy) {
+      case 'alphabetical':
+        return modules.sort((a, b) => a.name.localeCompare(b.name));
+
+      case 'dependency':
+        // Will be handled by resolveDependencyOrder
+        return modules;
+
+      case 'custom':
+        // Allow custom sorting via module priority (if defined)
+        return modules.sort((a, b) => {
+          const aPriority = (a.config as any)?.priority || 0;
+          const bPriority = (b.config as any)?.priority || 0;
+          return bPriority - aPriority; // Higher priority first
+        });
+
+      default:
+        return modules;
+    }
+  }
+
+  // Resolve dependency order using topological sort
+  private resolveDependencyOrder(modules: ModuleConfig[]): ModuleConfig[] {
+    const moduleMap = new Map<string, ModuleConfig>();
+    const dependencyGraph = new Map<string, string[]>();
+
+    // Build module map and dependency graph
+    modules.forEach(module => {
+      const key = `${module.name}@${module.version}`;
+      moduleMap.set(key, module);
+      dependencyGraph.set(key, module.dependencies || []);
+    });
+
+    // Topological sort
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const sorted: ModuleConfig[] = [];
+
+    const visit = (moduleKey: string): void => {
+      if (visiting.has(moduleKey)) {
+        throw new Error(`Circular dependency detected involving ${moduleKey}`);
+      }
+
+      if (visited.has(moduleKey)) {
+        return;
+      }
+
+      visiting.add(moduleKey);
+
+      const dependencies = dependencyGraph.get(moduleKey) || [];
+      dependencies.forEach(dep => {
+        // Find the dependency in our modules
+        const depModule = Array.from(moduleMap.keys()).find(key =>
+          key.startsWith(`${dep.split('@')[0]}@`)
+        );
+        if (depModule) {
+          visit(depModule);
+        }
+      });
+
+      visiting.delete(moduleKey);
+      visited.add(moduleKey);
+
+      const module = moduleMap.get(moduleKey);
+      if (module) {
+        sorted.push(module);
+      }
+    };
+
+    // Visit all modules
+    Array.from(moduleMap.keys()).forEach(key => {
+      if (!visited.has(key)) {
+        visit(key);
+      }
+    });
+
+    return sorted;
+  }
+
+  // Enhanced module validation
+  private validateAdvancedModule(
+    module: ModuleConfig,
+    _config: ModuleDefaultsConfig['autoDiscovery']
+  ): boolean {
+    // Basic validation
+    if (!this.isValidModule(module)) {
+      return false;
+    }
+
+    // Additional validation can be added here
+    // For example, checking module compatibility, version constraints, etc.
+
+    return true;
+  }
+
   // Watch for module changes (for development)
   watchModules(callback: (modules: ModuleConfig[]) => void): void {
-    const fs = require('fs');
-    const modulePaths = this.findModuleFiles();
+    // Use dynamic import for fs to avoid require()
+    import('fs')
+      .then(fs => {
+        const modulePaths = this.findModuleFiles();
 
-    modulePaths.forEach(path => {
-      try {
-        fs.watchFile(path, async () => {
-          this.discoveryLogger.info(`Module file changed: ${path}`);
-          const modules = await this.discoverModules();
-          callback(modules);
+        modulePaths.forEach(path => {
+          try {
+            fs.watchFile(path, async () => {
+              this.discoveryLogger.info(`Module file changed: ${path}`);
+              const modules = await this.discoverModules();
+              callback(modules);
+            });
+          } catch {
+            // File watching not supported or failed
+          }
         });
-      } catch {
-        // File watching not supported or failed
+      })
+      .catch(() => {
+        // fs module not available
+      });
+  }
+
+  // Watch modules with advanced configuration
+  watchModulesAdvanced(
+    config: ModuleDefaultsConfig['autoDiscovery'],
+    callback: (modules: ModuleConfig[]) => void
+  ): void {
+    if (!config.watchForChanges) {
+      return;
+    }
+
+    import('fs')
+      .then(fs => {
+        const watchedPaths = new Set<string>();
+
+        // Watch all configured paths
+        config.paths.forEach(searchPath => {
+          const fullPath = join(this.baseDir, searchPath);
+
+          try {
+            if (statSync(fullPath).isDirectory() && !watchedPaths.has(fullPath)) {
+              watchedPaths.add(fullPath);
+
+              const watcher = fs.watch(
+                fullPath,
+                { recursive: config.recursive },
+                async (eventType: string, filename: string | null) => {
+                  if (filename && this.matchesPatterns(filename, config.patterns)) {
+                    this.discoveryLogger.info(`Module file changed: ${filename}`);
+                    const modules = await this.discoverModulesAdvanced(config);
+                    callback(modules);
+                  }
+                }
+              );
+
+              // Store watcher for cleanup
+              this.watchers.push(watcher);
+            }
+          } catch {
+            // Path doesn't exist or not accessible
+          }
+        });
+      })
+      .catch(() => {
+        // fs module not available
+      });
+  }
+
+  // Clean up file watchers
+  cleanup(): void {
+    this.watchers.forEach(watcher => {
+      if (watcher && typeof watcher.close === 'function') {
+        watcher.close();
       }
     });
+    this.watchers = [];
   }
 }