@xubill/xx-cli 1.0.6

package/lib/core/index.js

@@ -0,0 +1,369 @@
+/**
+ * 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");
+
+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 (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) {
+          try {
+            plugin.registerCommands(program);
+          } catch (error) {
+            // 捕获命令别名冲突等错误，确保其他插件能够正常注册
+            if (error.message && error.message.includes('cannot add alias')) {
+              console.warn(`警告: 插件 ${pluginName} 的命令别名与其他插件冲突，已跳过此插件的命令注册`);
+            } else {
+              console.error(`错误: 插件 ${pluginName} 注册命令失败: ${error.message}`);
+            }
+          }
+        }
+      });
+    }
+
+    // 注册命令自动建议功能
+    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} 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();

package/lib/plugins/config-manager.js

@@ -0,0 +1,140 @@
+/**
+ * 配置管理插件
+ * 用于管理所有插件的配置文件
+ * 
+ * 命令说明：
+ * - config-manager [options]：管理所有插件的配置文件
+ *   - 示例：config-manager export
+ *   - 示例：config-manager import
+ *   - 示例：config-manager list
+ * 
+ * 功能说明：
+ * - 导出所有插件配置到指定目录
+ * - 从指定目录导入配置并覆盖
+ * - 列出所有插件的配置文件位置和状态
+ * 
+ * 用户体验：
+ * - 使用标准化的用户提示
+ * - 提供清晰的错误提示
+ * - 支持命令行参数
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const BasePlugin = require('../core/base-plugin');
+
+class ConfigManagerPlugin extends BasePlugin {
+  constructor(options = {}) {
+    super(options);
+    this.pluginName = 'config-manager';
+  }
+
+  /**
+   * 注册命令
+   * @param {Object} program - Commander.js 实例
+   */
+  registerCommands(program) {
+    // 配置管理命令
+    const configCommand = program.command('config-manager')
+      .alias('conf')
+      .description('管理所有插件的配置文件');
+
+    // 导出配置命令
+    configCommand.command('export [target]')
+      .description('导出所有插件配置到指定目录，默认导出到当前目录的 config-backup 文件夹')
+      .action((target) => this.exportConfig(target));
+
+    // 导入配置命令
+    configCommand.command('import [source]')
+      .description('从指定目录导入配置并覆盖，默认从当前目录的 config-backup 文件夹导入')
+      .action((source) => this.importConfig(source));
+
+    // 列出配置命令
+    configCommand.command('list')
+      .description('列出所有插件的配置文件位置和状态')
+      .action(() => this.listConfig());
+  }
+
+  /**
+   * 导出配置
+   * @param {string} target - 目标路径
+   */
+  exportConfig(target) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const xxDir = path.join(homeDir, '.xx-cli');
+    const exportDir = target || path.join(process.cwd(), 'config-backup');
+    console.log(`开始导出配置到: ${exportDir}`);
+    
+    // 确保导出目录存在
+    fs.ensureDirSync(exportDir);
+    
+    // 复制 .xx 目录
+    if (fs.existsSync(xxDir)) {
+      const exportPath = path.join(exportDir, '.xx-cli');
+      fs.ensureDirSync(path.dirname(exportPath));
+      fs.copySync(xxDir, exportPath);
+      console.log(`导出目录: ${xxDir}`);
+    }
+    
+    console.log('配置导出完成！');
+  }
+
+  /**
+   * 导入配置
+   * @param {string} source - 源路径
+   */
+  importConfig(source) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const xxDir = path.join(homeDir, '.xx-cli');
+    const importDir = source || path.join(process.cwd(), 'config-backup');
+    console.log(`开始从 ${importDir} 导入配置...`);
+    
+    // 检查导入目录是否存在
+    if (!fs.existsSync(importDir)) {
+      console.log(`导入目录不存在: ${importDir}`);
+      return;
+    }
+    
+    // 复制配置到 .xx 目录
+    const importPath = path.join(importDir, '.xx-cli');
+    if (fs.existsSync(importPath)) {
+      fs.ensureDirSync(path.dirname(xxDir));
+      fs.copySync(importPath, xxDir, { overwrite: true });
+      console.log(`导入目录: ${importPath}`);
+    }
+    
+    console.log('配置导入完成！');
+  }
+
+  /**
+   * 列出配置
+   */
+  listConfig() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const xxDir = path.join(homeDir, '.xx-cli');
+    console.log('列出所有插件配置文件...\n');
+    
+    if (fs.existsSync(xxDir)) {
+      const items = fs.readdirSync(xxDir).filter(item => !item.startsWith('.') && item !== 'plugins');
+      items.forEach(item => {
+        const itemPath = path.join(xxDir, item);
+        const stat = fs.statSync(itemPath);
+        if (stat.isDirectory()) {
+          console.log(`插件配置目录: ${itemPath}`);
+          const configFiles = fs.readdirSync(itemPath).filter(file => !file.startsWith('.'));
+          configFiles.forEach(file => {
+            console.log(`  - ${file}`);
+          });
+        } else if (stat.isFile()) {
+          console.log(`配置文件: ${itemPath}`);
+        }
+      });
+    } else {
+      console.log('配置目录不存在');
+    }
+    
+    console.log('配置列表完成！');
+  }
+}
+
+module.exports = ConfigManagerPlugin;

package/lib/plugins/history.js

@@ -0,0 +1,97 @@
+/**
+ * 历史记录插件
+ * 用于查看命令历史记录
+ * 
+ * 命令说明：
+ * - history [options]：查看命令历史记录
+ *   - 示例：history
+ *   - 示例：history --limit 20
+ *   - 示例：history --clear
+ *   - 示例：history --search <keyword>
+ * 
+ * 功能说明：
+ * - 查看命令历史记录
+ * - 限制显示的历史记录数量
+ * - 清除命令历史记录
+ * - 搜索命令历史记录
+ * 
+ * 用户体验：
+ * - 使用标准化的用户提示
+ * - 提供清晰的错误提示
+ * - 支持命令行参数
+ */
+
+const BasePlugin = require('../core/base-plugin');
+
+class HistoryPlugin extends BasePlugin {
+  constructor(options = {}) {
+    super(options);
+    this.pluginName = 'history';
+  }
+
+  /**
+   * 注册命令
+   * @param {Object} program - Commander.js 实例
+   */
+  registerCommands(program) {
+    // 命令历史记录
+    program
+      .command('history')
+      .alias('h')
+      .description('查看命令历史记录')
+      .option('-l, --limit <number>', '限制显示的历史记录数量', parseInt, 10)
+      .option('-c, --clear', '清除命令历史记录')
+      .option('-s, --search <keyword>', '搜索命令历史记录')
+      .action((options) => this.showHistory(options));
+  }
+
+  /**
+   * 显示命令历史记录
+   * @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');
+    }
+  }
+}
+
+module.exports = HistoryPlugin;