@xubill/xx-cli 1.0.0

package/lib/core/index.js

@@ -0,0 +1,583 @@
+/**
+ * xx 核心模块
+ * 负责初始化系统、注册命令、管理插件等
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+const pkg = require('../../package.json');
+const validator = require('../utils/validator');
+const pluginConfig = require('../utils/plugin-config');
+
+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 pluginsDir = path.join(__dirname, '../plugins');
+    if (fs.existsSync(pluginsDir)) {
+      const pluginFiles = fs.readdirSync(pluginsDir);
+      // 只收集插件文件信息，不立即加载
+      this.pluginFiles = pluginFiles.filter(file => file.endsWith('.js'));
+    }
+  }
+
+  /**
+   * 加载单个插件
+   * @param {string} pluginFile - 插件文件名
+   * @returns {Object|null} 插件实例或null
+   */
+  loadPlugin(pluginFile) {
+    // 检查缓存中是否已存在插件实例
+    if (this.pluginCache.has(pluginFile)) {
+      return this.pluginCache.get(pluginFile);
+    }
+    
+    const pluginPath = path.join(__dirname, '../plugins', pluginFile);
+    try {
+      const Plugin = require(pluginPath);
+      
+      // 检查是否为类
+      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 {
+        // 保持非类插件的兼容性
+        
+        // 缓存插件
+        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 && plugin.registerCommands) {
+          plugin.registerCommands(program);
+        }
+      });
+    }
+    
+    // 注册命令自动建议功能
+    this.registerCommandSuggestions(program);
+  }
+
+  /**
+   * 注册命令自动建议功能
+   * @param {Object} program - Commander 实例
+   */
+  registerCommandSuggestions(program) {
+    // 收集所有命令信息
+    const allCommands = this.collectAllCommands(program);
+    
+    // 添加命令自动建议
+    program.on('command:*', (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);
+      }
+    });
+  }
+
+  /**
+   * 收集所有命令信息
+   * @param {Object} program - Commander 实例
+   * @returns {Array} 命令数组
+   */
+  collectAllCommands(program) {
+    const commands = [];
+    
+    // 收集核心命令
+    if (program.commands) {
+      program.commands.forEach(command => {
+        // 添加命令名称
+        if (command._name && command._name !== '*') {
+          commands.push(command._name);
+        }
+        
+        // 添加命令别名
+        if (command._alias) {
+          commands.push(command._alias);
+        }
+      });
+    }
+    
+    return commands;
+  }
+
+  /**
+   * 获取命令建议
+   * @param {string} input - 用户输入
+   * @param {Array} commands - 命令数组
+   * @returns {Array} 建议的命令数组
+   */
+  getCommandSuggestions(input, commands) {
+    return commands.filter(command => {
+      return command.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} options - 选项
+   */
+  showHistory(options) {
+    const historyManager = require('../utils/history-manager');
+    
+    if (options.clear) {
+      // 清除命令历史记录
+      historyManager.clearHistory();
+      console.log('命令历史记录已清除');
+      return;
+    }
+    
+    if (options.search) {
+      // 搜索命令历史记录
+      const searchResults = historyManager.searchHistory(options.search);
+      if (searchResults.length > 0) {
+        console.log('\n搜索结果:');
+        console.log('=====================================');
+        searchResults.forEach((item, index) => {
+          const date = new Date(item.timestamp).toLocaleString();
+          console.log(`${index + 1}. ${item.command} (${date})`);
+        });
+        console.log('=====================================');
+        console.log(`总计: ${searchResults.length} 条记录\n`);
+      } else {
+        console.log(`\n未找到匹配 "${options.search}" 的命令历史记录\n`);
+      }
+      return;
+    }
+    
+    // 显示命令历史记录
+    const history = historyManager.getHistory(options.limit);
+    if (history.length > 0) {
+      console.log('\n命令历史记录:');
+      console.log('=====================================');
+      history.forEach((item, index) => {
+        const date = new Date(item.timestamp).toLocaleString();
+        console.log(`${index + 1}. ${item.command} (${date})`);
+      });
+      console.log('=====================================');
+      console.log(`总计: ${history.length} 条记录\n`);
+    } else {
+      console.log('\n命令历史记录为空\n');
+    }
+  }
+
+  /**
+   * 注册核心命令
+   * @param {Object} program - Commander 实例
+   */
+  registerCoreCommands(program) {
+    // 帮助命令
+    program
+      .command('help')
+      .description('显示帮助信息')
+      .action(() => {
+        program.outputHelp();
+      });
+
+   // 版本命令
+    program
+      .command('version')
+      .alias('v')
+      .description('显示版本信息')
+      .action(() => {
+        console.log(this.version);
+      });
+
+    // 命令历史记录
+    program
+      .command('history')
+      .alias('h')
+      .description('查看命令历史记录')
+      .option('-l, --limit <number>', '限制显示的历史记录数量', parseInt, 10)
+      .option('-c, --clear', '清除命令历史记录')
+      .option('-s, --search <keyword>', '搜索命令历史记录')
+      .action((options) => this.showHistory(options));
+
+    // 插件管理命令
+    const pluginCommand = program.command('plugin')
+      .alias('p')
+      .description('插件管理');
+
+    // 列出插件
+    pluginCommand.command('list')
+      .alias('ls')
+      .description('列出所有插件')
+      .action(() => this.listPlugins());
+
+    // 启用插件
+    pluginCommand.command('enable <plugin>')
+      .alias('en')
+      .description('启用插件')
+      .action((plugin) => this.enablePlugin(plugin));
+
+    // 禁用插件
+    pluginCommand.command('disable <plugin>')
+      .alias('dis')
+      .description('禁用插件')
+      .action((plugin) => this.disablePlugin(plugin));
+
+    // 添加外部自定义插件
+    pluginCommand.command('add <url>')
+      .description('添加外部自定义插件')
+      .action((url) => this.addExternalPlugin(url));
+
+    pluginCommand.command('remove <plugin>')
+      .alias('rm')
+      .description('删除指定插件')
+      .action((plugin) => this.removePlugin(plugin));
+
+    // 插件配置管理
+    pluginCommand.command('config <plugin> [key] [value]')
+      .alias('c')
+      .description('查看和设置插件配置')
+      .action((plugin, key, value) => this.managePluginConfig(plugin, key, value));
+  }
+
+  /**
+   * 列出所有插件
+   */
+  listPlugins() {
+    const pluginsInfo = this.getPluginsInfo();
+    console.log('\n可用插件列表:');
+    console.log('=====================================');
+    pluginsInfo.forEach(plugin => {
+      const isDisabled = pluginConfig.isPluginDisabled(plugin.name);
+      const status = isDisabled ? '[已禁用]' : '[已启用]';
+      console.log(`- ${plugin.name} ${status}`);
+    });
+    console.log('=====================================');
+    console.log(`总计: ${pluginsInfo.length} 个插件\n`);
+  }
+
+  /**
+   * 启用插件
+   * @param {string} pluginName - 插件名称
+   */
+  enablePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    // 启用插件
+    pluginConfig.enablePlugin(pluginName);
+    console.log(`已启用插件: ${pluginName}`);
+    console.log('提示: 请重新运行命令以应用更改');
+  }
+
+  /**
+   * 禁用插件
+   * @param {string} pluginName - 插件名称
+   */
+  disablePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    // 禁用插件
+    pluginConfig.disablePlugin(pluginName);
+    console.log(`已禁用插件: ${pluginName}`);
+    console.log('提示: 请重新运行命令以应用更改');
+  }
+
+  /**
+   * 删除插件
+   * @param {string} pluginName - 插件名称
+   */
+  removePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    const fs = require('fs');
+    const path = require('path');
+    
+    // 插件目录路径
+    const pluginsDir = path.join(__dirname, '../plugins');
+    
+    // 构建插件文件路径
+    const pluginFileName = `${pluginName}.js`;
+    const pluginPath = path.join(pluginsDir, pluginFileName);
+    
+    // 检查插件文件是否存在
+    if (!fs.existsSync(pluginPath)) {
+      console.error(`错误: 插件文件不存在: ${pluginPath}`);
+      return;
+    }
+    
+    try {
+      // 删除插件文件
+      fs.unlinkSync(pluginPath);
+      
+      // 从配置中移除插件的禁用状态
+      pluginConfig.removePluginFromConfig(pluginName);
+      
+      console.log(`已成功删除插件: ${pluginName}`);
+      console.log('提示: 请重新运行命令以应用更改');
+    } catch (error) {
+      console.error(`删除插件失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 管理插件配置
+   * @param {string} pluginName - 插件名称
+   * @param {string} key - 配置键
+   * @param {string} value - 配置值
+   */
+  managePluginConfig(pluginName, key, value) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    const config = require('../utils/plugin-config');
+    
+    if (key && value) {
+      // 设置插件配置
+      config.setPluginConfig(pluginName, key, value);
+      console.log(`已设置插件 ${pluginName} 的配置: ${key} = ${value}`);
+    } else if (key) {
+      // 查看插件特定配置
+      const pluginConfigValue = config.getPluginConfig(pluginName, key);
+      if (pluginConfigValue !== undefined) {
+        console.log(`插件 ${pluginName} 的配置 ${key}: ${pluginConfigValue}`);
+      } else {
+        console.log(`插件 ${pluginName} 未设置配置 ${key}`);
+      }
+    } else {
+      // 查看插件所有配置
+      const pluginConfigs = config.getPluginConfigs(pluginName);
+      if (Object.keys(pluginConfigs).length > 0) {
+        console.log(`插件 ${pluginName} 的配置:`);
+        console.log('=====================================');
+        Object.entries(pluginConfigs).forEach(([k, v]) => {
+          console.log(`${k}: ${v}`);
+        });
+        console.log('=====================================');
+      } else {
+        console.log(`插件 ${pluginName} 暂无配置`);
+      }
+    }
+  }
+
+  /**
+   * 添加外部自定义插件
+   * @param {string} url - 插件URL或本地文件路径
+   */
+  async addExternalPlugin(url) {
+    const fs = require('fs-extra');
+    const path = require('path');
+    const axios = require('axios');
+    
+    // 插件目录路径
+    const pluginsDir = path.join(__dirname, '../plugins');
+    
+    try {
+      // 检查是URL还是本地文件
+      if (validator.validateUrl(url)) {
+        // 是URL，下载插件
+        console.log(`正在从URL下载插件: ${url}`);
+        
+        // 从URL中提取插件文件名
+        const urlParts = url.split('/');
+        const pluginFileName = urlParts[urlParts.length - 1];
+        const pluginPath = path.join(pluginsDir, pluginFileName);
+        
+        // 下载文件
+        const response = await axios.get(url, { 
+          responseType: 'stream',
+          onDownloadProgress: (progressEvent) => {
+            const total = progressEvent.total;
+            const current = progressEvent.loaded;
+            if (total) {
+              const percentage = Math.round((current / total) * 100);
+              process.stdout.clearLine();
+              process.stdout.cursorTo(0);
+              process.stdout.write(`下载进度: ${percentage}%`);
+            }
+          }
+        });
+        const writer = fs.createWriteStream(pluginPath);
+        
+        response.data.pipe(writer);
+        
+        await new Promise((resolve, reject) => {
+          writer.on('finish', resolve);
+          writer.on('error', reject);
+        });
+        
+        console.log(''); // 换行
+        console.log(`插件已成功下载到: ${pluginPath}`);
+      } else if (fs.existsSync(url) && url.endsWith('.js')) {
+        // 是本地文件，拷贝插件
+        console.log(`正在从本地文件拷贝插件: ${url}`);
+        
+        // 提取文件名
+        const pluginFileName = path.basename(url);
+        const pluginPath = path.join(pluginsDir, pluginFileName);
+        
+        // 拷贝文件
+        await fs.copy(url, pluginPath);
+        
+        console.log(`插件已成功拷贝到: ${pluginPath}`);
+      } else {
+        console.error('错误: 无效的插件URL或本地文件路径');
+        return;
+      }
+    } catch (error) {
+      console.error('添加插件失败:', error.message);
+    }
+  }
+}
+
+// 导出单例实例
+module.exports = new Core();