rl-rockcli 0.0.8 → 0.0.9

package/utils/plugin-manager.js

@@ -0,0 +1,348 @@
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('./logger');
+const { gracefulExit } = require('./execution_logger');
+const DependencyResolver = require('./dependency-resolver');
+const PluginLoader = require('./plugin-loader');
+
+/**
+ * 插件管理器
+ * 负责插件系统的初始化、加载和命令注册
+ */
+class PluginManager {
+  constructor(configManager, hookManager) {
+    this._configManager = configManager;
+    this._hookManager = hookManager;
+    this._loader = new PluginLoader();
+    this._resolver = new DependencyResolver();
+    this._loadedPlugins = [];
+    this._registeredCommands = [];
+    this._currentPluginMetadata = null;
+  }
+
+  /**
+   * 初始化插件系统
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    // 检查是否禁用插件
+    if (process.env.ROCK_DISABLE_PLUGINS === 'true') {
+      logger.info('Plugin system disabled via ROCK_DISABLE_PLUGINS');
+      return;
+    }
+
+    // 读取插件配置
+    const pluginsConfig = this._configManager.getPlugins();
+
+    // 转换插件配置为路径数组（包括用户配置的插件）
+    const pluginPaths = this._convertPluginsConfigToPaths(pluginsConfig);
+
+    // 扫描并添加内置插件（plugins/ 目录）
+    const builtInPlugins = await this._scanBuiltInPlugins(pluginsConfig);
+    pluginPaths.push(...builtInPlugins);
+
+    if (!pluginPaths || pluginPaths.length === 0) {
+      logger.debug('No plugins configured');
+      return;
+    }
+
+    logger.debug(`Initializing plugin system with ${pluginPaths.length} plugins`);
+
+    try {
+      // 解析插件元数据
+      const pluginsMetadata = await this._parseAllPluginsMetadata(pluginPaths);
+
+      // 检测依赖环并确定加载顺序
+      const loadOrder = this._resolver.resolveLoadOrder(pluginsMetadata);
+      logger.debug(`Plugin load order: ${loadOrder.join(' -> ')}`);
+
+      // 按顺序加载插件
+      for (const pluginName of loadOrder) {
+        const pluginInfo = pluginsMetadata.find(p => p.name === pluginName);
+        if (pluginInfo) {
+          await this._loadSinglePlugin(pluginInfo);
+        }
+      }
+
+      // 触发 plugin-load 钩子
+      await this._hookManager.executeHooks('plugin-load', {
+        plugins: this._loadedPlugins.map(p => ({
+          name: p.name,
+          path: p.path,
+          priority: p.priority
+        }))
+      });
+
+      logger.debug(`Plugin system initialized: ${this._loadedPlugins.length} plugins loaded`);
+    } catch (error) {
+      logger.error('Failed to initialize plugin system');
+      logger.error(error);
+      // 不抛出异常，允许 CLI 继续运行
+    }
+  }
+
+  /**
+   * 将插件配置转换为路径数组
+   * @private
+   */
+  _convertPluginsConfigToPaths(pluginsConfig) {
+    const paths = [];
+
+    // 如果配置为空或不为对象，返回空数组
+    if (!pluginsConfig) {
+      return paths;
+    }
+
+    // 如果配置是数组（旧格式），直接返回
+    if (Array.isArray(pluginsConfig)) {
+      return pluginsConfig;
+    }
+
+    // 如果配置是对象（新格式），提取路径并过滤禁用的插件
+    for (const [pluginName, pluginDef] of Object.entries(pluginsConfig)) {
+      // 检查是否禁用
+      if (pluginDef.enabled === false) {
+        logger.debug(`Plugin disabled: ${pluginName}`);
+        continue;
+      }
+
+      // 获取路径
+      if (pluginDef.path) {
+        paths.push(pluginDef.path);
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * 扫描并加载内置插件（plugins/ 目录）
+   * 内置插件默认启用，除非在配置中明确禁用
+   * @private
+   */
+  async _scanBuiltInPlugins(pluginsConfig) {
+    const builtInPaths = [];
+    const pluginsDir = path.join(__dirname, '..', 'plugins');
+
+    // 检查 plugins 目录是否存在
+    if (!fs.existsSync(pluginsDir)) {
+      return builtInPaths;
+    }
+
+    // 读取 plugins 目录下的所有子目录
+    const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      const pluginName = entry.name;
+      const pluginPath = path.join(pluginsDir, pluginName);
+
+      // 检查插件是否在配置中明确禁用
+      const isDisabled = pluginsConfig &&
+                        pluginsConfig[pluginName] &&
+                        pluginsConfig[pluginName].enabled === false;
+
+      if (isDisabled) {
+        logger.debug(`Built-in plugin disabled: ${pluginName}`);
+        continue;
+      }
+
+      // 添加到内置插件列表
+      builtInPaths.push(pluginPath);
+      logger.debug(`Built-in plugin auto-loaded: ${pluginName}`);
+    }
+
+    return builtInPaths;
+  }
+
+  /**
+   * 解析所有插件的元数据
+   * @private
+   */  /**
+   * 解析所有插件的元数据
+   * @private
+   */
+  async _parseAllPluginsMetadata(pluginPaths) {
+    const metadata = [];
+
+    for (const pluginPath of pluginPaths) {
+      try {
+        const meta = await this._loader.parsePluginMetadata(pluginPath);
+        meta.path = pluginPath;
+        metadata.push(meta);
+      } catch (error) {
+        logger.warn(`Failed to parse plugin metadata: ${pluginPath}`);
+        logger.warn(error.message);
+      }
+    }
+
+    return metadata;
+  }
+
+  /**
+   * 加载单个插件
+   * @private
+   */
+  async _loadSinglePlugin(pluginInfo) {
+    const { name, path: pluginPath, priority = 0 } = pluginInfo;
+
+    // 触发 pre-plugin-load 钩子
+    const preContext = await this._hookManager.executeHooks('pre-plugin-load', {
+      pluginName: name,
+      pluginPath,
+      modifyPath: (newPath) => {
+        pluginInfo.path = newPath;
+      }
+    });
+
+    if (preContext.prevented) {
+      logger.warn(`Plugin loading prevented: ${name} (${preContext.message})`);
+      return;
+    }
+
+    try {
+      // 设置当前插件元数据
+      this._currentPluginMetadata = pluginInfo;
+
+      // 创建注册 API
+      const registerAPI = this._createRegisterAPI(name, priority);
+
+      // 加载插件
+      const loadedPlugin = await this._loader.loadPlugin(pluginInfo.path, name, registerAPI);
+
+      // 添加到已加载插件列表
+      this._loadedPlugins.push({
+        ...loadedPlugin,
+        priority
+      });
+
+      // 触发 post-plugin-load 钩子
+      await this._hookManager.executeHooks('post-plugin-load', {
+        pluginName: name
+      });
+
+      logger.debug(`Plugin loaded: ${name} (priority: ${priority})`);
+    } catch (error) {
+      logger.warn(`Failed to load plugin: ${name}`);
+      logger.warn(error.message);
+      // 继续加载其他插件
+    } finally {
+      this._currentPluginMetadata = null;
+    }
+  }
+
+  /**
+   * 创建注册 API (ROCKCLI)
+   * @private
+   */
+  _createRegisterAPI(pluginName, defaultPriority) {
+    return {
+      /**
+       * 注册命令
+       * @param {Object} commandDef - 命令定义
+       * @param {string} commandDef.command - 命令名称
+       * @param {string} commandDef.describe - 命令描述
+       * @param {Object} [commandDef.helpConfig] - 帮助配置（可选，用于本地化描述）
+       */
+      registerCommand: (commandDef) => {
+        // 检查命令冲突
+        if (this._isCommandRegistered(commandDef.command)) {
+          throw new Error(
+            `Command "${commandDef.command}" is already registered by another plugin or built-in command`
+          );
+        }
+
+        this._registeredCommands.push({
+          ...commandDef,
+          pluginName
+        });
+
+        logger.debug(`Command registered by plugin ${pluginName}: ${commandDef.command}`);
+      },
+
+      /**
+       * 注册钩子
+       */
+      registerHook: (hookName, hookDef) => {
+        const priority = hookDef.priority !== undefined ? hookDef.priority : defaultPriority;
+        this._hookManager.registerHook(hookName, hookDef, priority, pluginName);
+        logger.debug(`Hook registered by plugin ${pluginName}: ${hookName} (priority: ${priority})`);
+      },
+
+      /**
+       * 获取插件配置
+       * @param {string} [key] - 配置键，不提供则返回完整配置
+       * @returns {*} 配置值或完整配置对象
+       */
+      getConfig: (key) => {
+        const config = this._configManager.getPluginConfig(pluginName);
+        if (key !== undefined) {
+          return config[key];
+        }
+        return config;
+      },
+
+      /**
+       * 获取全局配置（带优先级合并）
+       * @param {Object} argv - 命令行参数对象
+       * @returns {Object} - 合并后的全局配置
+       */
+      getGlobalConfig: (argv) => {
+        return this._configManager.getGlobalConfigWithPriority(argv);
+      },
+
+      /**
+       * 日志工具
+       */
+      logger: {
+        error: (...args) => logger.error(...args),
+        warn: (...args) => logger.warn(...args),
+        info: (...args) => logger.info(...args),
+        debug: (...args) => logger.debug(...args),
+      },
+
+      /**
+       * 优雅退出函数
+       * @param {number} code - 退出码
+       */
+      gracefulExit,
+    };
+  }
+
+  /**
+   * 检查命令是否已注册
+   * @private
+   */
+  _isCommandRegistered(command) {
+    return this._registeredCommands.some(cmd => cmd.command === command);
+  }
+
+  /**
+   * 获取所有插件注册的命令
+   * @returns {Array<Object>}
+   */
+  getRegisteredCommands() {
+    return [...this._registeredCommands];
+  }
+
+  /**
+   * 获取所有已加载的插件信息
+   * @returns {Array<Object>}
+   */
+  getLoadedPlugins() {
+    return [...this._loadedPlugins];
+  }
+
+  /**
+   * 获取 HookManager 实例
+   * @returns {HookManager}
+   */
+  getHookManager() {
+    return this._hookManager;
+  }
+}
+
+module.exports = PluginManager;