@xubill/xx-cli 1.0.3 → 1.0.4

package/lib/core/index.js

@@ -3,13 +3,11 @@
  * 负责初始化系统、注册命令、管理插件等
  */
 
-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');
-const coreCommands = require('./commands');
+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() {
@@ -27,10 +25,10 @@ class Core {
   async init() {
     //logger.info('正在初始化 xx 核心...');
     this.loadPlugins();
-    
+
     // 触发初始化完成钩子
-    await this.triggerHook('init', { core: this });
-    
+    await this.triggerHook("init", { core: this });
+
     //logger.info('xx 核心初始化完成');
   }
 
@@ -38,12 +36,37 @@ class Core {
    * 加载插件
    */
   loadPlugins() {
-    const pluginsDir = path.join(__dirname, '../plugins');
-    if (fs.existsSync(pluginsDir)) {
-      const pluginFiles = fs.readdirSync(pluginsDir);
-      // 只收集插件文件信息，不立即加载
-      this.pluginFiles = pluginFiles.filter(file => file.endsWith('.js'));
+    // 内置插件目录（会被重新安装覆盖）
+    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;
   }
   /**
    * 加载单个插件
@@ -55,23 +78,73 @@ class Core {
     if (this.pluginCache.has(pluginFile)) {
       return this.pluginCache.get(pluginFile);
     }
-    
-    const pluginPath = path.join(__dirname, '../plugins', 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 {
-      const Plugin = require(pluginPath);
-      
+      // 读取插件文件内容
+      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) {
+      if (typeof Plugin === "function" && Plugin.prototype) {
         // 实例化类插件
         const pluginInstance = new Plugin();
-        pluginInstance.pluginName = pluginInstance.pluginName || pluginFile.replace('.js', '');
-        
+        pluginInstance.pluginName =
+          pluginInstance.pluginName || pluginFile.replace(".js", "");
+
         // 缓存插件实例
         this.pluginCache.set(pluginFile, pluginInstance);
         return pluginInstance;
       } else {
         // 保持非类插件的兼容性
-        
+
         // 缓存插件
         this.pluginCache.set(pluginFile, Plugin);
         return Plugin;
@@ -86,11 +159,11 @@ class Core {
    * @returns {Array} 插件信息数组
    */
   getPluginsInfo() {
-    return this.pluginFiles.map(pluginFile => {
-      const pluginName = pluginFile.replace('.js', '');
+    return this.pluginFiles.map((pluginFile) => {
+      const pluginName = pluginFile.replace(".js", "");
       return {
         name: pluginName,
-        file: pluginFile
+        file: pluginFile,
       };
     });
   }
@@ -102,24 +175,33 @@ class Core {
   registerCommands(program) {
     // 注册核心命令
     this.registerCoreCommands(program);
-    
+
     // 注册插件命令
     if (this.pluginFiles) {
-      this.pluginFiles.forEach(pluginFile => {
-        const pluginName = pluginFile.replace('.js', '');
-        
+      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);
+          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);
   }
@@ -131,18 +213,18 @@ class Core {
   registerCommandSuggestions(program) {
     // 收集所有命令信息
     const allCommands = this.collectAllCommands(program);
-    
+
     // 添加命令自动建议
-    program.on('command:*', (args) => {
+    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 => {
+        suggestions.forEach((suggestion) => {
           console.log(`  - ${suggestion}`);
         });
-        console.log('');
+        console.log("");
         process.exit(1);
       }
     });
@@ -155,22 +237,22 @@ class Core {
    */
   collectAllCommands(program) {
     const commands = [];
-    
+
     // 收集核心命令
     if (program.commands) {
-      program.commands.forEach(command => {
+      program.commands.forEach((command) => {
         // 添加命令名称
-        if (command._name && command._name !== '*') {
+        if (command._name && command._name !== "*") {
           commands.push(command._name);
         }
-        
+
         // 添加命令别名
         if (command._alias) {
           commands.push(command._alias);
         }
       });
     }
-    
+
     return commands;
   }
 
@@ -181,9 +263,11 @@ class Core {
    * @returns {Array} 建议的命令数组
    */
   getCommandSuggestions(input, commands) {
-    return commands.filter(command => {
-      return command.startsWith(input.toLowerCase());
-    }).slice(0, 5); // 最多返回5个建议
+    return commands
+      .filter((command) => {
+        return command.startsWith(input.toLowerCase());
+      })
+      .slice(0, 5); // 最多返回5个建议
   }
 
   /**
@@ -195,7 +279,7 @@ class Core {
     if (!this.hooks[event]) {
       this.hooks[event] = [];
     }
-    
+
     this.hooks[event].push(callback);
   }
 
@@ -207,7 +291,7 @@ class Core {
    */
   async triggerHook(event, data) {
     const results = [];
-    
+
     // 触发全局钩子
     if (this.hooks[event]) {
       for (const callback of this.hooks[event]) {
@@ -219,29 +303,32 @@ class Core {
         }
       }
     }
-    
+
     // 触发所有插件的钩子
     if (this.pluginFiles) {
       for (const pluginFile of this.pluginFiles) {
-        const pluginName = pluginFile.replace('.js', '');
-        
+        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);
+            console.error(
+              `执行插件 ${pluginName} 的钩子 ${event} 时出错:`,
+              error.message
+            );
           }
         }
       }
     }
-    
+
     return results;
   }
 
@@ -254,54 +341,6 @@ class Core {
     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 实例
@@ -309,163 +348,20 @@ class Core {
   registerCoreCommands(program) {
     // 帮助命令
     program
-      .command('help')
-      .description('显示帮助信息')
+      .command("help")
+      .description("显示帮助信息")
       .action(() => {
         program.outputHelp();
       });
 
-   // 版本命令
+    // 版本命令
     program
-      .command('version')
-      .alias('v')
-      .description('显示版本信息')
+      .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));
-
-    // 创建插件命令
-    program
-      .command('create-plugin <name>')
-      .alias('crp')
-      .description('创建指定名称的插件模板')
-      .action(async (name, options) => this.createPlugin(name, options));
-
-    // 配置管理命令
-    const configCommand = program.command('config-manager')
-      .alias('conf')
-      .description('管理所有插件的配置文件');
-
-    // 导出配置命令
-    configCommand.command('export [target]')
-      .description('导出所有插件配置到指定目录，默认导出到当前目录的 config-backup 文件夹')
-      .action((target) => this.configManager('export', target));
-
-    // 导入配置命令
-    configCommand.command('import [source]')
-      .description('从指定目录导入配置并覆盖，默认从当前目录的 config-backup 文件夹导入')
-      .action((source) => this.configManager('import', source));
-
-    // 列出配置命令
-    configCommand.command('list')
-      .description('列出所有插件的配置文件位置和状态')
-      .action(() => this.configManager('list'));
-
-    // 插件管理命令
-    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));
-  }
-
-  /**
-   * 创建插件
-   * @param {string} name - 插件名称
-   * @param {Object} options - 选项
-   */
-  async createPlugin(name, options) {
-    await coreCommands.createPlugin(name, options);
-  }
-
-  /**
-   * 配置管理
-   * @param {string} action - 操作类型
-   * @param {string} target - 目标路径
-   */
-  configManager(action, target) {
-    coreCommands.configManager(action, target);
-  }
-
-  /**
-   * 列出所有插件
-   */
-  listPlugins() {
-    coreCommands.listPlugins(this);
-  }
-
-  /**
-   * 启用插件
-   * @param {string} pluginName - 插件名称
-   */
-  enablePlugin(pluginName) {
-    coreCommands.enablePlugin(pluginName);
-  }
-
-  /**
-   * 禁用插件
-   * @param {string} pluginName - 插件名称
-   */
-  disablePlugin(pluginName) {
-    coreCommands.disablePlugin(pluginName);
-  }
-
-  /**
-   * 删除插件
-   * @param {string} pluginName - 插件名称
-   */
-  removePlugin(pluginName) {
-    coreCommands.removePlugin(pluginName);
-  }
-
-  /**
-   * 管理插件配置
-   * @param {string} pluginName - 插件名称
-   * @param {string} key - 配置键
-   * @param {string} value - 配置值
-   */
-  managePluginConfig(pluginName, key, value) {
-    coreCommands.managePluginConfig(pluginName, key, value);
-  }
-
-  /**
-   * 添加外部自定义插件
-   * @param {string} url - 插件URL或本地文件路径
-   */
-  async addExternalPlugin(url) {
-    await coreCommands.addExternalPlugin(url);
   }
 }
 

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;

package/lib/{core/commands.js → plugins/plugin-manager.js}

@@ -1,14 +1,194 @@
 /**
- * 核心命令实现
- * 存放具体的命令实现逻辑，保持 index.js 清晰
+ * 插件管理插件
+ * 用于管理所有插件
+ * 
+ * 命令说明：
+ * - plugin [options]：管理所有插件
+ *   - 示例：plugin list
+ *   - 示例：plugin enable <plugin>
+ *   - 示例：plugin disable <plugin>
+ *   - 示例：plugin add <url>
+ *   - 示例：plugin remove <plugin>
+ *   - 示例：plugin create <name>
+ *   - 示例：plugin config <plugin> [key] [value]
+ * 
+ * 功能说明：
+ * - 列出所有插件
+ * - 启用指定插件
+ * - 禁用指定插件
+ * - 添加外部插件
+ * - 删除指定插件
+ * - 创建指定名称的插件模板
+ * - 查看和设置插件配置
+ * 
+ * 用户体验：
+ * - 使用标准化的用户提示
+ * - 提供清晰的错误提示
+ * - 支持命令行参数
  */
 
 const fs = require('fs-extra');
 const path = require('path');
+const https = require('https');
+const http = require('http');
+const BasePlugin = require('../core/base-plugin');
 const validator = require('../utils/validator');
 const pluginConfig = require('../utils/plugin-config');
 
-class CoreCommands {
+class PluginManagerPlugin extends BasePlugin {
+  constructor(options = {}) {
+    super(options);
+    this.pluginName = 'plugin-manager';
+  }
+
+  /**
+   * 注册命令
+   * @param {Object} program - Commander.js 实例
+   */
+  registerCommands(program) {
+    // 插件管理命令
+    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('create <name>')
+      .alias('cr')
+      .description('创建指定名称的插件模板')
+      .action(async (name, options) => this.createPlugin(name, options));
+
+    // 插件配置管理
+    pluginCommand.command('config <plugin> [key] [value]')
+      .alias('c')
+      .description('查看和设置插件配置')
+      .action((plugin, key, value) => this.managePluginConfig(plugin, key, value));
+  }
+
+  /**
+   * 列出所有插件
+   */
+  listPlugins() {
+    const core = require('../core');
+    const pluginsInfo = core.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 builtinPluginsDir = path.join(__dirname, '../plugins');
+    // 用户插件目录
+    const userPluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
+    
+    // 构建插件文件路径
+    const pluginFileName = `${pluginName}.js`;
+    let pluginPath = path.join(builtinPluginsDir, pluginFileName);
+    
+    // 如果内置插件目录中不存在，则从用户插件目录查找
+    if (!fs.existsSync(pluginPath)) {
+      pluginPath = path.join(userPluginsDir, pluginFileName);
+    }
+    
+    // 检查插件文件是否存在
+    if (!fs.existsSync(pluginPath)) {
+      console.error(`错误: 插件文件不存在`);
+      return;
+    }
+    
+    try {
+      // 删除插件文件
+      fs.unlinkSync(pluginPath);
+      
+      // 从配置中移除插件的禁用状态
+      pluginConfig.removePluginFromConfig(pluginName);
+      
+      console.log(`已成功删除插件: ${pluginName}`);
+      console.log('提示: 请重新运行命令以应用更改');
+    } catch (error) {
+      console.error(`删除插件失败: ${error.message}`);
+    }
+  }
+
   /**
    * 创建插件
    * @param {string} name - 插件名称
@@ -18,8 +198,8 @@ class CoreCommands {
     try {
       console.log('创建插件模板...');
 
-      // 插件目录路径
-      const pluginsDir = path.join(__dirname, '../plugins');
+      // 插件目录路径（用户插件目录，不会被重新安装影响）
+      const pluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
       const pluginFileName = `${name}.js`;
       const pluginPath = path.join(pluginsDir, pluginFileName);
 
@@ -39,6 +219,32 @@ class CoreCommands {
       console.log('提示：请编辑插件文件，实现具体功能');
       console.log('测试方法：运行 "node bin/cli.js <插件命令>"');
 
+      // 使用 vscode 打开创建的插件文件
+      try {
+        const { exec } = require('child_process');
+        const os = require('os');
+        let command;
+        
+        // 根据操作系统类型构建不同的命令
+        if (os.platform() === 'win32') {
+          // Windows 系统
+          command = `start code "${pluginPath}"`;
+        } else {
+          // macOS 和 Linux 系统
+          command = `code "${pluginPath}"`;
+        }
+        
+        exec(command, (error) => {
+          if (error) {
+            console.log('提示：无法自动打开 vscode，请手动打开插件文件进行编辑');
+          } else {
+            console.log('已自动打开 vscode 编辑插件文件');
+          }
+        });
+      } catch (error) {
+        console.log('提示：无法自动打开 vscode，请手动打开插件文件进行编辑');
+      }
+
     } catch (error) {
       console.error('创建插件模板失败:', error.message);
     }
@@ -120,170 +326,6 @@ module.exports = ${this.toCamelCase(name)}Plugin;
     return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase()).replace(/^[a-z]/, (g) => g.toUpperCase());
   }
 
-  /**
-   * 配置管理
-   * @param {string} action - 操作类型
-   * @param {string} target - 目标路径
-   */
-  configManager(action, target) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const xxDir = path.join(homeDir, '.xx-cli');
-    
-    if (action === 'export') {
-      // 导出配置
-      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('配置导出完成！');
-    } else if (action === 'import') {
-      // 导入配置
-      const importDir = target || 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('配置导入完成！');
-    } else if (action === 'list') {
-      // 列出配置
-      console.log('列出所有插件配置文件...\n');
-      
-      if (fs.existsSync(xxDir)) {
-        const items = fs.readdirSync(xxDir).filter(item => !item.startsWith('.'));
-        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('配置列表完成！');
-    }
-  }
-
-  /**
-   * 列出所有插件
-   */
-  listPlugins(core) {
-    const pluginsInfo = core.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 - 插件名称
@@ -347,20 +389,15 @@ module.exports = ${this.toCamelCase(name)}Plugin;
    */
   async addExternalPlugin(url) {
     try {
-      const fs = require('fs');
-      const path = require('path');
-      const https = require('https');
-      const http = require('http');
+      // 用户插件目录（不会被重新安装影响）
+      const userPluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
       
-      // 插件目录路径
-      const pluginsDir = path.join(__dirname, '../plugins');
-      
-      // 确保插件目录存在
-      fs.ensureDirSync(pluginsDir);
+      // 确保用户插件目录存在
+      fs.ensureDirSync(userPluginsDir);
       
       // 提取插件名称
       const pluginFileName = path.basename(url);
-      const pluginPath = path.join(pluginsDir, pluginFileName);
+      const pluginPath = path.join(userPluginsDir, pluginFileName);
       
       // 检查插件是否已存在
       if (fs.existsSync(pluginPath)) {
@@ -425,7 +462,7 @@ module.exports = ${this.toCamelCase(name)}Plugin;
         
         // 提取文件名
         const pluginFileName = path.basename(url);
-        const pluginPath = path.join(pluginsDir, pluginFileName);
+        const pluginPath = path.join(userPluginsDir, pluginFileName);
         
         // 拷贝文件
         await fs.copy(url, pluginPath);
@@ -435,10 +472,17 @@ module.exports = ${this.toCamelCase(name)}Plugin;
         console.error('错误: 无效的插件URL或本地文件路径');
         return;
       }
+      
+      // 提示用户
+      console.log('\n提示:');
+      console.log('- 插件已自动注册到命令系统');
+      console.log('- 可以使用 "xx plugin list" 命令查看已安装的插件');
+      console.log('- 可以使用 "xx <plugin-command>" 命令使用插件功能');
+      console.log('- 此插件保存在用户目录中，不会被重新安装影响');
     } catch (error) {
       console.error('添加插件失败:', error.message);
     }
   }
 }
 
-module.exports = new CoreCommands();
+module.exports = PluginManagerPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xubill/xx-cli",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "个人工具集",
   "main": "lib/core/index.js",
   "bin": {

package/readme.md

@@ -30,6 +30,10 @@ xx <command> [options]
 - 创建插件和配置管理插件移动壳功能
 - 完善文档
 
+### v1.0.4
+- 修复原生插件和用户插件区别
+- 壳功能移动到原生插件目录
+
 ## 框架自带命令
 
 xx-cli 框架自带以下核心命令（位于 core 模块中）：
@@ -46,12 +50,12 @@ xx-cli 框架自带以下核心命令（位于 core 模块中）：
 
 | 命令 | 别名 | 描述 |
 |------|------|------|
-| `create-plugin <name>` | `crp <name>` | 创建指定名称的插件模板 |
 | `plugin list` | `p ls` | 列出所有插件 |
 | `plugin enable <plugin>` | `p en <plugin>` | 启用插件 |
 | `plugin disable <plugin>` | `p dis <plugin>` | 禁用插件 |
 | `plugin add <url>` | `p add <url>` | 添加外部自定义插件 |
 | `plugin remove <plugin>` | `p rm <plugin>` | 删除指定插件 |
+| `plugin create <name>` | `p cr <name>` | 创建指定名称的插件模板 |
 | `plugin config <plugin> [key] [value]` | `p c <plugin> [key] [value]` | 查看和设置插件配置 |
 
 ### 配置管理命令
@@ -62,37 +66,81 @@ xx-cli 框架自带以下核心命令（位于 core 模块中）：
 | `config-manager import [source]` | `conf import [source]` | 从指定目录导入配置并覆盖 |
 | `config-manager list` | `conf list` | 列出所有插件的配置文件位置和状态 |
 
+## 项目结构
+
+xx-cli 项目采用模块化设计，主要包含以下核心目录：
+
+### 核心模块目录 (`/Users/hthj/xx-cli/lib/core`)
+
+核心模块目录包含 xx-cli 的核心功能实现，负责初始化系统、注册命令、管理插件等。
+
+#### 文件结构
+
+```
+lib/core/
+  ├── index.js         # 核心模块，负责初始化系统、注册命令、管理插件等
+  └── base-plugin.js   # 插件基础类，提供标准化的插件接口和通用功能
+```
+
+#### 核心文件说明
+
+- **index.js**：核心模块，负责初始化系统、注册命令、管理插件等。它包含了插件加载、命令注册、钩子管理等核心功能。
+- **base-plugin.js**：插件基础类，提供标准化的插件接口和通用功能。所有插件应该继承此类以确保一致性，它提供了命令注册、配置管理、用户界面等通用功能。
+
+### 插件目录 (`/Users/hthj/xx-cli/lib/plugins`)
+
+插件目录包含 xx-cli 的内置插件，这些插件提供了各种功能，如配置管理、历史记录管理、插件管理等。
+
+#### 文件结构
+
+```
+lib/plugins/
+  ├── config-manager.js   # 配置管理插件，用于管理所有插件的配置文件
+  ├── history.js          # 历史记录插件，用于查看命令历史记录
+  └── plugin-manager.js   # 插件管理插件，用于管理所有插件
+```
+
+#### 内置插件说明
+
+- **config-manager.js**：配置管理插件，用于管理所有插件的配置文件。它提供了导出、导入、列出配置等功能。
+- **history.js**：历史记录插件，用于查看命令历史记录。它提供了查看、清除、搜索历史记录等功能。
+- **plugin-manager.js**：插件管理插件，用于管理所有插件。它提供了列出、启用、禁用、添加、删除、创建插件等功能。
+
 ## 插件开发
 
 本部分将详细介绍如何在 xx-cli 中创建、开发和部署插件。
 
 ### 创建插件
 
-#### 使用 create-plugin 命令
+#### 使用 plugin create 命令
 
-xx-cli 提供了 `create-plugin` 命令，可以快速生成插件模板。这是推荐的创建插件的方式。
+xx-cli 提供了 `plugin create` 命令，可以快速生成插件模板。这是推荐的创建插件的方式。
 
 ##### 基本用法
 
 ```bash
 # 创建插件到插件目录
-xx create-plugin <plugin-name>
+xx plugin create <plugin-name>
 
 # 或者使用别名
-xx crp <plugin-name>
+xx p create <plugin-name>
+
+# 或者使用更短的别名
+xx p cr <plugin-name>
 ```
 
 ##### 示例
 
 ```bash
 # 创建一个名为 `hello-world` 的插件
-xx create-plugin hello-world
+xx plugin create hello-world
 
 # 输出：
 # 创建插件模板...
-# 插件模板已成功创建到：/Users/hthj/xx-cli/lib/plugins/hello-world.js
+# 插件模板已成功创建到：/Users/hthj/.xx-cli/plugins/hello-world.js
 # 提示：请编辑插件文件，实现具体功能
 # 测试方法：运行 "node bin/cli.js <插件命令>"
+# 已自动打开 vscode 编辑插件文件
 ```
 
 #### 手动创建插件
@@ -106,7 +154,7 @@ xx create-plugin hello-world
 
 #### 基本插件结构
 
-使用 `create-plugin` 命令生成的插件模板包含以下结构：
+使用 `plugin create` 命令生成的插件模板包含以下结构：
 
 ```javascript
 /**
@@ -380,7 +428,7 @@ module.exports = MyPlugin;
 
 1. 创建插件：
    ```bash
-   xx create-plugin <plugin-name>
+   xx plugin create <plugin-name>
    ```
 
 2. 编辑插件文件，实现具体功能