@xubill/xx-cli 2.0.4

package/lib/core/index.js

@@ -0,0 +1,550 @@
+/**
+ * xx 核心模块
+ * 负责初始化系统、注册命令、管理插件等
+ */
+
+const fs = require("fs");
+const path = require("path");
+const logger = require("../utils/logger");
+const pkg = require("../../package.json");
+const pluginConfig = require("../utils/plugin-config");
+const { createPluginsHelper } = require('../utils/plugins-helper');
+
+class Core {
+  constructor() {
+    this.plugins = [];
+    this.commands = [];
+    this.version = pkg.version;
+    this.pluginFiles = [];
+    this.pluginCache = new Map(); // 插件缓存
+    this.hooks = {}; // 全局钩子
+  }
+
+  /**
+   * 初始化核心功能
+   */
+  async init() {
+    //logger.info('正在初始化 xx 核心...');
+    this.loadPlugins();
+
+    // 触发初始化完成钩子
+    await this.triggerHook("init", { core: this });
+
+    //logger.info('xx 核心初始化完成');
+  }
+
+  /**
+   * 加载插件
+   */
+  loadPlugins() {
+    // 内置插件目录（会被重新安装覆盖）
+    const builtinPluginsDir = path.join(__dirname, "../plugins");
+    // 用户插件目录（不会被重新安装影响）
+    const userPluginsDir = path.join(
+      process.env.HOME || process.env.USERPROFILE,
+      ".xx-cli",
+      "plugins",
+    );
+
+    // 确保用户插件目录存在
+    if (!fs.existsSync(userPluginsDir)) {
+      fs.mkdirSync(userPluginsDir, { recursive: true });
+    }
+
+    // 收集内置插件
+    let pluginFiles = [];
+    if (fs.existsSync(builtinPluginsDir)) {
+      const builtinFiles = fs.readdirSync(builtinPluginsDir);
+      pluginFiles = builtinFiles.filter((file) => file.endsWith(".js"));
+    }
+
+    // 收集用户插件
+    if (fs.existsSync(userPluginsDir)) {
+      const userFiles = fs.readdirSync(userPluginsDir);
+      const userPluginFiles = userFiles.filter((file) => file.endsWith(".js"));
+      // 将用户插件添加到插件文件列表中
+      pluginFiles = [...pluginFiles, ...userPluginFiles];
+    }
+    // 只收集插件文件信息，不立即加载
+    this.pluginFiles = pluginFiles;
+  }
+
+  /**
+   * 加载单个插件
+   * @param {string} pluginFile - 插件文件名
+   * @returns {Object|null} 插件实例或null
+   */
+  loadPlugin(pluginFile) {
+    // 检查缓存中是否已存在插件实例
+    if (this.pluginCache.has(pluginFile)) {
+      return this.pluginCache.get(pluginFile);
+    }
+
+    // 内置插件目录
+    const builtinPluginsDir = path.join(__dirname, "../plugins");
+    // 用户插件目录
+    const userPluginsDir = path.join(
+      process.env.HOME || process.env.USERPROFILE,
+      ".xx-cli",
+      "plugins",
+    );
+
+    // 优先从内置插件目录加载
+    let pluginPath = path.join(builtinPluginsDir, pluginFile);
+
+    // 如果内置插件目录中不存在，则从用户插件目录加载
+    if (!fs.existsSync(pluginPath)) {
+      pluginPath = path.join(userPluginsDir, pluginFile);
+    }
+
+    // 如果两个目录中都不存在，则返回null
+    if (!fs.existsSync(pluginPath)) {
+      logger.error(`插件文件 ${pluginFile} 不存在`);
+      return null;
+    }
+
+    try {
+      // 读取插件文件内容
+      let pluginContent = fs.readFileSync(pluginPath, "utf8");
+
+      // 替换插件文件中的相对路径导入为绝对路径导入
+      // 替换 ../core 为绝对路径
+      const coreDir = path.join(__dirname, "../core");
+      pluginContent = pluginContent.replace(
+        /require\('\.\.\/core\//g,
+        `require('${coreDir}/`,
+      );
+
+      // 替换 ../utils 为绝对路径
+      const utilsDir = path.join(__dirname, "../utils");
+      pluginContent = pluginContent.replace(
+        /require\('\.\.\/utils\//g,
+        `require('${utilsDir}/`,
+      );
+
+      // 创建一个临时模块来加载修改后的插件内容
+      const Module = require("module");
+      const tempModule = new Module(pluginPath);
+      tempModule.filename = pluginPath;
+      tempModule.paths = module.paths;
+
+      // 编译并执行修改后的插件内容
+      tempModule._compile(pluginContent, pluginPath);
+
+      const Plugin = tempModule.exports;
+
+      // 检查是否为新格式的插件对象
+      if (
+        Plugin &&
+        typeof Plugin === "object" &&
+        Plugin.name &&
+        (Plugin.action || Plugin.subcommands)
+      ) {
+        // 新格式插件对象，不需要实例化
+        this.pluginCache.set(pluginFile, Plugin);
+        return Plugin;
+      } else if (typeof Plugin === "function" && Plugin.prototype) {
+        // 实例化类插件
+        const pluginInstance = new Plugin();
+        pluginInstance.pluginName =
+          pluginInstance.pluginName || pluginFile.replace(".js", "");
+
+        // 缓存插件实例
+        this.pluginCache.set(pluginFile, pluginInstance);
+        return pluginInstance;
+      } else {
+        // 保持非类插件的兼容性
+        // 对于函数式插件，也可能是新格式
+        if (
+          Plugin &&
+          typeof Plugin === "object" &&
+          Plugin.name &&
+          (Plugin.action || Plugin.subcommands)
+        ) {
+          // 新格式插件对象
+          this.pluginCache.set(pluginFile, Plugin);
+          return Plugin;
+        } else {
+          // 旧格式函数式插件
+          this.pluginCache.set(pluginFile, Plugin);
+          return Plugin;
+        }
+      }
+    } catch (error) {
+      logger.error(`加载插件 ${pluginFile} 失败: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 获取所有插件信息
+   * @returns {Array} 插件信息数组
+   */
+  getPluginsInfo() {
+    return this.pluginFiles.map((pluginFile) => {
+      const pluginName = pluginFile.replace(".js", "");
+      return {
+        name: pluginName,
+        file: pluginFile,
+      };
+    });
+  }
+
+  /**
+   * 注册命令到 Commander
+   * @param {Object} program - Commander 实例
+   */
+  registerCommands(program) {
+    // 注册核心命令
+    this.registerCoreCommands(program);
+
+    // 注册插件命令
+    if (this.pluginFiles) {
+      this.pluginFiles.forEach((pluginFile) => {
+        const pluginName = pluginFile.replace(".js", "");
+
+        // 检查插件是否已禁用
+        if (pluginConfig.isPluginDisabled(pluginName)) {
+          return;
+        }
+
+        const plugin = this.loadPlugin(pluginFile);
+        if (plugin) {
+          try {
+            // 检查是否为新格式插件
+            if (
+              plugin.name &&
+              (typeof plugin.action === "function" ||
+                (plugin.subcommands && Array.isArray(plugin.subcommands)))
+            ) {
+              this.registerNewFormatPlugin(program, plugin, pluginName);
+            } else if (plugin.registerCommands) {
+              // 旧格式插件
+              plugin.registerCommands(program);
+            }
+          } catch (error) {
+            // 捕获命令别名冲突等错误，确保其他插件能够正常注册
+            if (error.message && error.message.includes("cannot add alias")) {
+              console.warn(
+                `警告: 插件 ${pluginName} 的命令别名与其他插件冲突，已跳过此插件的命令注册`,
+              );
+            } else {
+              console.log(error)
+              console.error(
+                `错误: 插件 ${pluginName} 注册命令失败: ${error.message}`,
+              );
+            }
+          }
+        }
+      });
+    }
+
+    // 注册命令自动建议功能
+    this.registerCommandSuggestions(program);
+  }
+
+  /**
+   * 注册新格式插件命令
+   * @param {Object} program - Commander 实例
+   * @param {Object} plugin - 插件对象
+   * @param {string} pluginName - 插件名称
+   */
+  registerNewFormatPlugin(program, plugin, pluginName) {
+    const cmd = program.command(plugin.name);
+
+    // 设置描述
+    if (plugin.description) {
+      cmd.description(plugin.description);
+    }
+
+    // 设置别名
+    if (plugin.alias) {
+      cmd.alias(plugin.alias);
+    }
+
+    // 添加选项
+    if (plugin.options && Array.isArray(plugin.options)) {
+      plugin.options.forEach((option) => {
+        if (option.name && option.description) {
+          cmd.option(option.name, option.description);
+        }
+      });
+    }
+
+    // 如果插件定义了子命令，则注册它们
+    if (plugin.subcommands && Array.isArray(plugin.subcommands)) {
+      plugin.subcommands.forEach((subcmd) => {
+        const subCommand = cmd.command(subcmd.name);
+
+        if (subcmd.description) {
+          subCommand.description(subcmd.description);
+        }
+
+        if (subcmd.options && Array.isArray(subcmd.options)) {
+          subcmd.options.forEach((option) => {
+            if (option.name && option.description) {
+              subCommand.option(option.name, option.description);
+            }
+          });
+        }
+
+        subCommand.action(async (...args) => {
+          let commandArgs = [];
+          let options = {};
+          
+          if (args.length > 0) {
+            const lastArg = args[args.length - 1];
+            if (lastArg && typeof lastArg === 'object' && typeof lastArg.opts === 'function') {
+              options = { ...lastArg.opts() };
+              commandArgs = lastArg.args || [];
+            } else {
+              commandArgs = [...args];
+            }
+          }
+          
+          // 创建插件帮助器实例
+          const helper = createPluginsHelper(plugin.name);
+          // 调用子命令的 action 方法
+          await subcmd.action(commandArgs, options, helper);
+        });
+      });
+    }
+
+    // 设置主命令的 action
+    if (plugin.action) {
+      cmd.action(async (...args) => {
+        // Commander.js 会将参数和选项作为单独的参数传递
+        // 最后一个参数通常是 Command 对象，其中包含选项
+        let commandArgs = [];
+        let options = {};
+        
+        // 如果有参数，需要正确识别哪个是 Command 对象
+        if (args.length > 0) {
+          // 从后往前检查，找到 Command 对象
+          let commandObjIndex = -1;
+          for (let i = args.length - 1; i >= 0; i--) {
+            const arg = args[i];
+            if (
+              arg &&
+              typeof arg === "object" &&
+              typeof arg.opts === "function"
+            ) {
+              commandObjIndex = i;
+              break;
+            }
+          }
+          
+          if (commandObjIndex !== -1) {
+            // 找到了 Command 对象
+            options = { ...args[commandObjIndex].opts() };
+            // 从 Command 对象的 args 属性获取命令参数
+            const commandObj = args[commandObjIndex];
+            commandArgs = commandObj.args || [];
+          } else {
+            // 没有 Command 对象，所有参数都是命令参数
+            commandArgs = [...args];
+          }
+        }
+        
+        // 创建插件帮助器实例
+      const helper = createPluginsHelper(plugin.name);
+      // 调用插件的 action 方法
+      await plugin.action(commandArgs, options, helper);
+      });
+    }
+  }
+
+  /**
+   * 注册命令自动建议功能
+   * @param {Object} program - Commander 实例
+   */
+  registerCommandSuggestions(program) {
+    // 收集所有命令信息
+    const allCommands = this.collectAllCommands(program);
+
+    // 添加命令自动建议
+    program.on("command:*", async (args) => {
+      const inputCommand = args[0];
+      const suggestions = this.getCommandSuggestions(inputCommand, allCommands);
+
+      if (suggestions.length > 0) {
+        console.log(`\n未找到命令 "${inputCommand}"，您可能想要：`);
+        suggestions.forEach((suggestion) => {
+          console.log(`  - ${suggestion}`);
+        });
+        console.log("");
+        process.exit(1);
+      } else {
+        // 如果没有建议，也显示错误信息
+        console.log(`\n未找到命令 "${inputCommand}"。`);
+        console.log('使用 "xx help" 查看所有可用命令。');
+        
+        // 自动调用 AI 解释命令作为兜底
+        console.log('\n正在调用 AI 解释您的输入...');
+        
+        try {
+          // 动态导入 ai 插件
+          const aiPath = path.join(__dirname, '../plugins/ai.js');
+          if (fs.existsSync(aiPath)) {
+            const AIPlugin = require(aiPath);
+            if (AIPlugin.prototype && typeof AIPlugin === 'function') {
+              // 类继承格式插件
+              const pluginInstance = new AIPlugin();
+              if (pluginInstance.handleAI) {
+                await pluginInstance.handleAI(args, {});
+              }
+            } else if (AIPlugin.action) {
+              // 配置对象格式插件
+              await AIPlugin.action(args, {});
+            }
+          }
+        } catch (error) {
+          // AI 调用失败时不影响主流程
+          console.log('AI 解释失败:', error.message);
+        }
+        
+        console.log("");
+        process.exit(1);
+      }
+    });
+  }
+
+  /**
+   * 收集所有命令信息
+   * @param {Object} program - Commander 实例
+   * @returns {Array} 命令数组
+   */
+  collectAllCommands(program) {
+    const commands = [];
+
+    // 收集核心命令
+    if (program.commands) {
+      program.commands.forEach((command) => {
+        // 直接使用 _name 获取命令名称
+        const commandName = command._name;
+        
+        // 添加命令名称
+        if (commandName && commandName !== "*") {
+          commands.push(commandName);
+        }
+      });
+    }
+
+    return commands;
+  }
+
+  /**
+   * 获取命令建议
+   * @param {string} input - 用户输入
+   * @param {Array} commands - 命令数组
+   * @returns {Array} 建议的命令数组
+   */
+  getCommandSuggestions(input, commands) {
+    return commands
+      .filter((command) => {
+        // 确保 command 是字符串类型
+        if (typeof command !== 'string') {
+          return false;
+        }
+        return command.toLowerCase().startsWith(input.toLowerCase());
+      })
+      .slice(0, 5); // 最多返回5个建议
+  }
+
+  /**
+   * 注册全局钩子
+   * @param {string} event - 事件名称
+   * @param {Function} callback - 回调函数
+   */
+  registerHook(event, callback) {
+    if (!this.hooks[event]) {
+      this.hooks[event] = [];
+    }
+
+    this.hooks[event].push(callback);
+  }
+
+  /**
+   * 触发全局钩子
+   * @param {string} event - 事件名称
+   * @param {*} data - 事件数据
+   * @returns {Promise<Array>} 钩子执行结果
+   */
+  async triggerHook(event, data) {
+    const results = [];
+
+    // 触发全局钩子
+    if (this.hooks[event]) {
+      for (const callback of this.hooks[event]) {
+        try {
+          const result = await callback(data);
+          results.push(result);
+        } catch (error) {
+          console.error(`执行全局钩子 ${event} 时出错:`, error.message);
+        }
+      }
+    }
+
+    // 触发所有插件的钩子
+    if (this.pluginFiles) {
+      for (const pluginFile of this.pluginFiles) {
+        const pluginName = pluginFile.replace(".js", "");
+
+        // 检查插件是否已禁用
+        if (pluginConfig.isPluginDisabled(pluginName)) {
+          continue;
+        }
+
+        const plugin = this.loadPlugin(pluginFile);
+        if (plugin && plugin.triggerHook) {
+          try {
+            const pluginResults = await plugin.triggerHook(event, data);
+            results.push(...pluginResults);
+          } catch (error) {
+            console.error(
+              `执行插件 ${pluginName} 的钩子 ${event} 时出错:`,
+              error.message,
+            );
+          }
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * 检查是否注册了指定全局钩子
+   * @param {string} event - 事件名称
+   * @returns {boolean} 是否注册了钩子
+   */
+  hasHook(event) {
+    return this.hooks[event] && this.hooks[event].length > 0;
+  }
+
+  /**
+   * 注册核心命令
+   * @param {Object} program - Commander 实例
+   */
+  registerCoreCommands(program) {
+    // 帮助命令
+    program
+      .command("help")
+      .description("显示帮助信息")
+      .action(() => {
+        program.outputHelp();
+      });
+
+    // 版本命令
+    program
+      .command("version")
+      .alias("v")
+      .description("显示版本信息")
+      .action(() => {
+        console.log(this.version);
+      });
+  }
+}
+
+// 导出单例实例
+module.exports = new Core();