@xubill/xx-cli 1.0.6 → 2.0.0

package/bin/cli.js

@@ -60,12 +60,14 @@
   // 全局错误处理
   process.on('uncaughtException', (error) => {
     console.error(chalk.red('错误:'), error.message);
+    console.error(chalk.red('错误堆栈:'), error.stack);
     console.error(chalk.yellow('提示:'), '请检查命令参数是否正确，或使用 --help 查看帮助信息');
     process.exit(1);
   });
 
   process.on('unhandledRejection', (error) => {
     console.error(chalk.red('错误:'), error.message);
+    console.error(chalk.red('错误堆栈:'), error.stack);
     console.error(chalk.yellow('提示:'), '请检查命令参数是否正确，或使用 --help 查看帮助信息');
     process.exit(1);
   });

package/lib/core/index.js

@@ -8,6 +8,7 @@ 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() {
@@ -42,7 +43,7 @@ class Core {
     const userPluginsDir = path.join(
       process.env.HOME || process.env.USERPROFILE,
       ".xx-cli",
-      "plugins"
+      "plugins",
     );
 
     // 确保用户插件目录存在
@@ -64,10 +65,10 @@ class Core {
       // 将用户插件添加到插件文件列表中
       pluginFiles = [...pluginFiles, ...userPluginFiles];
     }
-
     // 只收集插件文件信息，不立即加载
     this.pluginFiles = pluginFiles;
   }
+
   /**
    * 加载单个插件
    * @param {string} pluginFile - 插件文件名
@@ -85,7 +86,7 @@ class Core {
     const userPluginsDir = path.join(
       process.env.HOME || process.env.USERPROFILE,
       ".xx-cli",
-      "plugins"
+      "plugins",
     );
 
     // 优先从内置插件目录加载
@@ -111,14 +112,14 @@ class Core {
       const coreDir = path.join(__dirname, "../core");
       pluginContent = pluginContent.replace(
         /require\('\.\.\/core\//g,
-        `require('${coreDir}/`
+        `require('${coreDir}/`,
       );
 
       // 替换 ../utils 为绝对路径
       const utilsDir = path.join(__dirname, "../utils");
       pluginContent = pluginContent.replace(
         /require\('\.\.\/utils\//g,
-        `require('${utilsDir}/`
+        `require('${utilsDir}/`,
       );
 
       // 创建一个临时模块来加载修改后的插件内容
@@ -132,8 +133,17 @@ class Core {
 
       const Plugin = tempModule.exports;
 
-      // 检查是否为类
-      if (typeof Plugin === "function" && Plugin.prototype) {
+      // 检查是否为新格式的插件对象
+      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 =
@@ -144,16 +154,28 @@ class Core {
         return pluginInstance;
       } else {
         // 保持非类插件的兼容性
-
-        // 缓存插件
-        this.pluginCache.set(pluginFile, Plugin);
-        return Plugin;
+        // 对于函数式插件，也可能是新格式
+        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} 插件信息数组
@@ -187,15 +209,29 @@ class Core {
         }
 
         const plugin = this.loadPlugin(pluginFile);
-        if (plugin && plugin.registerCommands) {
+        if (plugin) {
           try {
-            plugin.registerCommands(program);
+            // 检查是否为新格式插件
+            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} 的命令别名与其他插件冲突，已跳过此插件的命令注册`);
+            if (error.message && error.message.includes("cannot add alias")) {
+              console.warn(
+                `警告: 插件 ${pluginName} 的命令别名与其他插件冲突，已跳过此插件的命令注册`,
+              );
             } else {
-              console.error(`错误: 插件 ${pluginName} 注册命令失败: ${error.message}`);
+              console.error(
+                `错误: 插件 ${pluginName} 注册命令失败: ${error.message}`,
+              );
             }
           }
         }
@@ -206,6 +242,117 @@ class Core {
     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 实例
@@ -322,7 +469,7 @@ class Core {
           } catch (error) {
             console.error(
               `执行插件 ${pluginName} 的钩子 ${event} 时出错:`,
-              error.message
+              error.message,
             );
           }
         }

package/lib/plugins/config-manager.js

@@ -21,120 +21,145 @@
 
 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());
+/**
+ * 配置管理类
+ * 封装所有配置管理相关的方法
+ */
+class ConfigManager {
+  constructor() {
+    // 获取用户主目录，添加 process.cwd() 作为 fallback
+    this.homeDir = process.env.HOME || process.env.USERPROFILE || process.cwd();
+    this.xxDir = path.join(this.homeDir, '.xx-cli');
   }
 
   /**
    * 导出配置
    * @param {string} target - 目标路径
+   * @param {Object} helper - 插件帮助器
    */
-  exportConfig(target) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const xxDir = path.join(homeDir, '.xx-cli');
+  exportConfig(target, helper) {
     const exportDir = target || path.join(process.cwd(), 'config-backup');
-    console.log(`开始导出配置到: ${exportDir}`);
+    helper.showInfo(`开始导出配置到: ${exportDir}`);
     
     // 确保导出目录存在
     fs.ensureDirSync(exportDir);
     
     // 复制 .xx 目录
-    if (fs.existsSync(xxDir)) {
+    if (fs.existsSync(this.xxDir)) {
       const exportPath = path.join(exportDir, '.xx-cli');
       fs.ensureDirSync(path.dirname(exportPath));
-      fs.copySync(xxDir, exportPath);
-      console.log(`导出目录: ${xxDir}`);
+      fs.copySync(this.xxDir, exportPath);
+      helper.showInfo(`导出目录: ${this.xxDir}`);
     }
     
-    console.log('配置导出完成！');
+    helper.showSuccess('配置导出完成！');
   }
 
   /**
    * 导入配置
    * @param {string} source - 源路径
+   * @param {Object} helper - 插件帮助器
    */
-  importConfig(source) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const xxDir = path.join(homeDir, '.xx-cli');
+  importConfig(source, helper) {
     const importDir = source || path.join(process.cwd(), 'config-backup');
-    console.log(`开始从 ${importDir} 导入配置...`);
+    helper.showInfo(`开始从 ${importDir} 导入配置...`);
     
     // 检查导入目录是否存在
     if (!fs.existsSync(importDir)) {
-      console.log(`导入目录不存在: ${importDir}`);
+      helper.showError(`导入目录不存在: ${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}`);
+      fs.ensureDirSync(path.dirname(this.xxDir));
+      fs.copySync(importPath, this.xxDir, { overwrite: true });
+      helper.showInfo(`导入目录: ${importPath}`);
     }
     
-    console.log('配置导入完成！');
+    helper.showSuccess('配置导入完成！');
   }
 
   /**
    * 列出配置
+   * @param {Object} helper - 插件帮助器
    */
-  listConfig() {
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const xxDir = path.join(homeDir, '.xx-cli');
-    console.log('列出所有插件配置文件...\n');
+  listConfig(helper) {
+    helper.showInfo('列出所有插件配置文件...\n');
     
-    if (fs.existsSync(xxDir)) {
-      const items = fs.readdirSync(xxDir).filter(item => !item.startsWith('.') && item !== 'plugins');
+    if (fs.existsSync(this.xxDir)) {
+      const items = fs.readdirSync(this.xxDir).filter(item => !item.startsWith('.') && item !== 'plugins');
       items.forEach(item => {
-        const itemPath = path.join(xxDir, item);
+        const itemPath = path.join(this.xxDir, item);
         const stat = fs.statSync(itemPath);
         if (stat.isDirectory()) {
-          console.log(`插件配置目录: ${itemPath}`);
+          helper.showInfo(`插件配置目录: ${itemPath}`);
           const configFiles = fs.readdirSync(itemPath).filter(file => !file.startsWith('.'));
           configFiles.forEach(file => {
-            console.log(`  - ${file}`);
+            helper.showInfo(`  - ${file}`);
           });
         } else if (stat.isFile()) {
-          console.log(`配置文件: ${itemPath}`);
+          helper.showInfo(`配置文件: ${itemPath}`);
         }
       });
     } else {
-      console.log('配置目录不存在');
+      helper.showWarning('配置目录不存在');
     }
     
-    console.log('配置列表完成！');
+    helper.showSuccess('配置列表完成！');
   }
 }
 
-module.exports = ConfigManagerPlugin;
+// 创建配置管理实例
+const configManager = new ConfigManager();
+
+module.exports = {
+  name: 'config-manager',
+  alias: 'conf',
+  description: '管理所有插件的配置文件',
+  subcommands: [
+    {
+      name: 'export',
+      description: '导出所有插件配置到指定目录，默认导出到当前目录的 config-backup 文件夹',
+      action: (args, options, helper) => {
+        configManager.exportConfig(args.target, helper);
+      },
+      args: [
+        {
+          name: 'target',
+          description: '目标路径',
+          optional: true
+        }
+      ]
+    },
+    {
+      name: 'import',
+      description: '从指定目录导入配置并覆盖，默认从当前目录的 config-backup 文件夹导入',
+      action: (args, options, helper) => {
+        configManager.importConfig(args.source, helper);
+      },
+      args: [
+        {
+          name: 'source',
+          description: '源路径',
+          optional: true
+        }
+      ]
+    },
+    {
+      name: 'list',
+      description: '列出所有插件的配置文件位置和状态',
+      action: (args, options, helper) => {
+        configManager.listConfig(helper);
+      }
+    }
+  ],
+  options: [
+    {
+      name: '-h, --help',
+      description: '显示帮助信息'
+    }
+  ]
+};

package/lib/plugins/history.js

@@ -21,77 +21,88 @@
  * - 支持命令行参数
  */
 
-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));
+/**
+ * 历史记录管理类
+ * 封装所有历史记录相关的方法
+ */
+class HistoryManager {
+  constructor() {
+    // 加载历史记录管理器
+    this.historyManager = require('../utils/history-manager');
   }
 
   /**
    * 显示命令历史记录
    * @param {Object} options - 选项
+   * @param {Object} helper - 插件帮助器
    */
-  showHistory(options) {
-    const historyManager = require('../utils/history-manager');
-    
+  showHistory(options, helper) {
     if (options.clear) {
       // 清除命令历史记录
-      historyManager.clearHistory();
-      console.log('命令历史记录已清除');
+      this.historyManager.clearHistory();
+      helper.showSuccess('命令历史记录已清除');
       return;
     }
     
     if (options.search) {
       // 搜索命令历史记录
-      const searchResults = historyManager.searchHistory(options.search);
+      const searchResults = this.historyManager.searchHistory(options.search);
       if (searchResults.length > 0) {
-        console.log('\n搜索结果:');
-        console.log('=====================================');
+        helper.showInfo('\n搜索结果:');
+        helper.showInfo('=====================================');
         searchResults.forEach((item, index) => {
           const date = new Date(item.timestamp).toLocaleString();
-          console.log(`${index + 1}. ${item.command} (${date})`);
+          helper.showInfo(`${index + 1}. ${item.command} (${date})`);
         });
-        console.log('=====================================');
-        console.log(`总计: ${searchResults.length} 条记录\n`);
+        helper.showInfo('=====================================');
+        helper.showInfo(`总计: ${searchResults.length} 条记录\n`);
       } else {
-        console.log(`\n未找到匹配 "${options.search}" 的命令历史记录\n`);
+        helper.showInfo(`\n未找到匹配 "${options.search}" 的命令历史记录\n`);
       }
       return;
     }
     
     // 显示命令历史记录
-    const history = historyManager.getHistory(options.limit);
+    const history = this.historyManager.getHistory(options.limit);
     if (history.length > 0) {
-      console.log('\n命令历史记录:');
-      console.log('=====================================');
+      helper.showInfo('\n命令历史记录:');
+      helper.showInfo('=====================================');
       history.forEach((item, index) => {
         const date = new Date(item.timestamp).toLocaleString();
-        console.log(`${index + 1}. ${item.command} (${date})`);
+        helper.showInfo(`${index + 1}. ${item.command} (${date})`);
       });
-      console.log('=====================================');
-      console.log(`总计: ${history.length} 条记录\n`);
+      helper.showInfo('=====================================');
+      helper.showInfo(`总计: ${history.length} 条记录\n`);
     } else {
-      console.log('\n命令历史记录为空\n');
+      helper.showInfo('\n命令历史记录为空\n');
     }
   }
 }
 
-module.exports = HistoryPlugin;
+// 创建历史记录管理实例
+const historyManager = new HistoryManager();
+
+module.exports = {
+  name: 'history',
+  alias: 'h',
+  description: '查看命令历史记录',
+  options: [
+    {
+      name: '-l, --limit <number>',
+      description: '限制显示的历史记录数量',
+      parse: parseInt,
+      default: 10
+    },
+    {
+      name: '-c, --clear',
+      description: '清除命令历史记录'
+    },
+    {
+      name: '-s, --search <keyword>',
+      description: '搜索命令历史记录'
+    }
+  ],
+  action: (args, options, helper) => {
+    historyManager.showHistory(options, helper);
+  }
+};