foliko 1.1.93 → 2.0.0

package/plugins/{data-splitter-plugin.js → executors/data-splitter/index.js}

@@ -1,19 +1,12 @@
 /**
  * DataSplitterPlugin — 大数据自动分拆插件
- *
- * 功能：
- * 1. 注册 `split_and_process` 工具：AI 可主动调用，将大文本分拆给子 Agent 处理
- * 2. 注册 `get_content_preview` 工具：获取大内容的前 N 行，判断是否需要分拆
- * 3. 自动检测工具返回的大数据，触发透明分拆
- * 4. 系统提示词中告知 AI 大数据处理能力
  */
 
-const { Plugin } = require('../src/core/plugin-base');
+const { Plugin } = require('../../../src/plugin/base');
 const { z } = require('zod');
-const { logger } = require('../src/utils/logger');
-const { DataSplitter } = require('../src/utils/data-splitter');
+const { logger } = require('../../../src/common/logger');
+const { DataSplitter } = require('../../../src/utils/data-splitter');
 
-// 超过此大小的工具结果自动触发分拆（字符数，默认 100K tokens ≈ 200K chars）
 const AUTO_SPLIT_THRESHOLD = 50000;
 
 class DataSplitterPlugin extends Plugin {
@@ -27,7 +20,6 @@ class DataSplitterPlugin extends Plugin {
     this._framework = null;
     this._splitter = null;
 
-    // 配置
     this.config = {
       autoSplitThreshold: config.autoSplitThreshold || AUTO_SPLIT_THRESHOLD,
       chunkSize: config.chunkSize || 60000,
@@ -48,34 +40,20 @@ class DataSplitterPlugin extends Plugin {
   }
 
   start(framework) {
-    // 注册大数据处理工具
     this._registerSplitTools();
-
-    // 注册系统提示词
     this.registerPromptPart('data-splitter-rules', 85, () => this._getPromptRules());
-
-    // 注册工具结果监听器（自动检测大结果）
     this._registerAutoSplitHook();
-
-    // log.info('[DataSplitterPlugin] 已启动，阈值:', this.config.autoSplitThreshold);
   }
 
-  /**
-   * 注册分拆工具
-   * @private
-   */
   _registerSplitTools() {
     const framework = this._framework;
 
-    // ─── 工具1: split_and_process — AI 主动调用分拆 ───
     framework.registerTool({
       name: 'split_and_process',
-      description: `将大文本内容按大小分块，创建多个子 Agent 并行处理每块内容，最后自动汇总结果。
-当你读取文件或抓取网页返回的内容超过 10 万字符时，应该使用此工具来分拆处理。
-它会将内容拆成多块，每块由一个子 Agent 独立处理，最后给你一个汇总。`,
+      description: `将大文本内容按大小分块，创建多个子 Agent 并行处理每块内容，最后自动汇总结果。`,
       inputSchema: z.object({
-        content: z.string().describe('要分拆处理的大文本内容（如果超过 100K 字符建议使用此工具）'),
-        taskDescription: z.string().describe('每个子 Agent 要执行的任务描述，例如"提取所有函数定义"、"总结内容要点"等'),
+        content: z.string().describe('要分拆处理的大文本内容'),
+        taskDescription: z.string().describe('每个子 Agent 要执行的任务描述'),
         chunkSize: z.number().optional().default(60000).describe('每块最大字符数，默认 60000'),
         maxConcurrent: z.number().optional().default(3).describe('最大并行子 Agent 数，默认 3'),
       }),
@@ -89,7 +67,6 @@ class DataSplitterPlugin extends Plugin {
 
         const stats = splitter.getContentStats(content);
         if (!splitter.needsSplit(content)) {
-          // 内容较小，直接返回
           return {
             success: true,
             data: content,
@@ -101,15 +78,9 @@ class DataSplitterPlugin extends Plugin {
           };
         }
 
-        // 生成上下文中的 sessionId 用于取消信号
         const sessionCtx = ctx?.getCurrentSessionContext?.();
         const signal = sessionCtx?.abortSignal;
 
-        log.debug(
-          `[split_and_process] 开始分拆: ${stats.chars} 字符, ` +
-            `${stats.chunks} 块, 任务="${taskDescription?.slice(0, 40)}..."`
-        );
-
         const startTime = Date.now();
         const chunks = splitter.splitContent(content, chunkSize);
         const result = await splitter.dispatchToSubAgents({
@@ -135,11 +106,9 @@ class DataSplitterPlugin extends Plugin {
       },
     });
 
-    // ─── 工具2: get_content_preview — 获取大内容预览信息 ───
     framework.registerTool({
       name: 'get_content_preview',
-      description: `获取大文本内容的预览信息（前 20 行 + 统计），判断是否需要分拆处理。
-适合在读取大文件或抓取网页后用于检查内容大小。`,
+      description: `获取大文本内容的预览信息（前 20 行 + 统计），判断是否需要分拆处理。`,
       inputSchema: z.object({
         content: z.string().describe('要预览的大文本内容'),
         previewLines: z.number().optional().default(20).describe('预览前 N 行，默认 20'),
@@ -168,10 +137,6 @@ class DataSplitterPlugin extends Plugin {
     });
   }
 
-  /**
-   * 获取系统提示词
-   * @private
-   */
   _getPromptRules() {
     return `## 大数据处理能力
 
@@ -188,22 +153,14 @@ class DataSplitterPlugin extends Plugin {
 - 分拆时指定清晰的任务描述，例如"提取所有关键代码函数"、"总结每段内容要点"`;
   }
 
-  /**
-   * 注册自动分拆钩子
-   * 监听 tool:result 事件，如果结果太大自动触发分拆
-   * @private
-   */
   _registerAutoSplitHook() {
     const framework = this._framework;
 
-    // 监听工具结果，检测大数据
     this._toolResultHandler = (data) => {
       const { name, result } = data;
 
-      // 跳过已经标记为分拆结果的工具
       if (name === 'split_and_process') return;
 
-      // 检查工具返回的内容是否过大（优先使用 data 字段）
       let checkContent = '';
       if (result && typeof result === 'object' && result.data) {
         checkContent = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
@@ -211,27 +168,16 @@ class DataSplitterPlugin extends Plugin {
         checkContent = typeof result === 'string' ? result : JSON.stringify(result);
       }
       if (!checkContent || checkContent.length < this.config.autoSplitThreshold) return;
-
-      // 不阻塞执行，只在日志中记录建议
-      // log.info(
-      //   `[DataSplitter] 检测到大数据工具结果: ${name}, ` +
-      //     `${checkContent.length} 字符, 建议使用 split_and_process 分拆处理`
-      // );
     };
 
     framework.on('tool:result', this._toolResultHandler);
   }
 
-  /**
-   * 获取 DataSplitter 实例
-   * @private
-   */
   _getSplitter(ctx) {
     return this._splitter || new DataSplitter(this._framework, this.config);
   }
 
   reload(framework) {
-    // 清理旧监听器
     if (this._toolResultHandler) {
       framework.off('tool:result', this._toolResultHandler);
     }
@@ -239,12 +185,10 @@ class DataSplitterPlugin extends Plugin {
     this._framework = framework;
     this._splitter = new DataSplitter(framework, this.config);
 
-    // 重新注册
     if (framework._mainAgent) {
       this.start(framework);
     }
 
-    // 请求刷新 mainAgent 的 system prompt
     if (framework._mainAgent) {
       framework._mainAgent._refreshContext();
     }
@@ -257,27 +201,14 @@ class DataSplitterPlugin extends Plugin {
   }
 }
 
-/**
- * 自动检测工具结果是否过大，并透明处理
- * 在 agent-chat 中调用
- *
- * @param {string} toolName - 工具名称
- * @param {*} result - 工具返回结果
- * @param {Object} framework - Framework 实例
- * @returns {Promise<{ wasSplit: boolean, result: *, splitterResult?: Object }>}
- */
 async function autoSplitToolResult(toolName, result, framework) {
-  // 跳过某些工具
   const skipTools = ['split_and_process', 'get_content_preview'];
   if (skipTools.includes(toolName)) return { wasSplit: false, result };
 
-  // 无 framework 时无法创建子 Agent，跳过
   if (!framework || typeof framework.createSubAgent !== 'function') {
     return { wasSplit: false, result };
   }
 
-  // 提取用于判断大小的内容
-  // 优先使用 result.data（统一格式），再回退到整个结果字符串
   let checkContent = '';
   if (typeof result === 'object' && result !== null && result.data) {
     checkContent = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
@@ -291,10 +222,6 @@ async function autoSplitToolResult(toolName, result, framework) {
   const splitter = new DataSplitter(framework);
   const taskDescription = `从以下内容中提取关键信息（代码、配置、数据等），以结构化方式输出。`;
 
-  // log.info(
-  //   `[DataSplitter] 自动分拆工具 "${toolName}": ${checkContent.length} 字符`
-  // );
-
   try {
     const chunks = splitter.splitContent(checkContent);
     const splitResult = await splitter.dispatchToSubAgents({
@@ -305,12 +232,11 @@ async function autoSplitToolResult(toolName, result, framework) {
 
     return {
       wasSplit: true,
-      // 返回原始结果 + 分拆汇总，AI 可以同时看到两者
       result: {
         _autoSplit: true,
         _originalSize: checkContent.length,
         _summary: splitResult.summary,
-        _originalResult: result, // 保留原始结果供参考
+        _originalResult: result,
       },
       splitterResult: splitResult,
     };
@@ -320,4 +246,4 @@ async function autoSplitToolResult(toolName, result, framework) {
   }
 }
 
-module.exports = { DataSplitterPlugin, autoSplitToolResult };
+module.exports = { DataSplitterPlugin, autoSplitToolResult };

package/plugins/{extension-executor-plugin.js → executors/extension/index.js}

@@ -3,11 +3,11 @@
  * 统一管理扩展插件（如 gate-trading）的工具，通过 ext_call 调用
  */
 
-const { Plugin } = require('../src/core/plugin-base');
-const { logger } = require('../src/utils/logger');
+const { Plugin } = require('../../../src/plugin/base');
+const { logger } = require('../../../src/common/logger');
 const { z } = require('zod');
-const { PROMPT_PRIORITY } = require('../src/core/constants');
-const { zodSchemaToMarkdown,zodSchemaToTable } = require('@chnak/zod-to-markdown');
+const { PROMPT_PRIORITY } = require('../../../src/common/constants');
+const { zodSchemaToMarkdown, zodSchemaToTable } = require('@chnak/zod-to-markdown');
 
 const log = logger.child('ExtensionExecutor');
 
@@ -27,40 +27,29 @@ class ExtensionExecutorPlugin extends Plugin {
   install(framework) {
     this._framework = framework;
 
-    // 监听插件加载事件，自动扫描插件的 this.tools
     framework.on('plugin:loaded', (plugin) => {
       this._scanPluginTools(plugin);
     });
 
-    // 监听插件重载事件，重新扫描工具
     framework.on('plugin:reloaded', (plugin) => {
       this._rescanPluginTools(plugin);
     });
 
-    // 监听框架就绪事件，刷新所有动态注册的工具（确保在 install() 中通过 registerTool() 注册的工具能被扫描到）
     framework.on('framework:ready', () => {
       log.debug('Framework ready, rescanning all plugin tools...');
       const plugins = framework.pluginManager.getAll();
       for (const { instance: plugin } of plugins) {
-        // skill-manager 插件的工具已通过 Skill.registerCommands 直接注册，
-        // 不需要再通过 _scanPluginTools 扫描，避免重复注册
         if (plugin.name === 'skill-manager') {
           continue;
         }
         this._scanPluginTools(plugin);
       }
-      // 刷新所有 Agent 的扩展提示词
       this._refreshAllAgentsExtPrompt(framework);
     });
 
     return this;
   }
 
-  /**
-   * 扫描插件的 this.tools 并注册到扩展系统
-   * @param {Object} plugin - 插件实例
-   * @param {string} [extName] - 可选的扩展名（用于统一命名）
-   */
   _scanPluginTools(plugin, extName) {
     if (!plugin || !plugin.tools || typeof plugin.tools !== 'object') {
       return;
@@ -69,17 +58,14 @@ class ExtensionExecutorPlugin extends Plugin {
     const pluginName = plugin.name;
     if (!pluginName) return;
 
-    // 确定扩展名：优先使用 extName，否则使用 pluginName
     const useExtName = extName || pluginName;
 
-    // 获取插件信息
     const pluginInfo = {
       name: useExtName,
       description: plugin.description || '',
       version: plugin.version || '1.0.0',
     };
 
-    // 遍历插件的所有工具
     for (const [toolName, toolDef] of Object.entries(plugin.tools)) {
       if (!toolDef || typeof toolDef !== 'object') continue;
 
@@ -93,15 +79,11 @@ class ExtensionExecutorPlugin extends Plugin {
 
     log.debug(` Scanned ${Object.keys(plugin.tools).length} tools from plugin '${pluginName}' (as '${useExtName}')`);
 
-    // 刷新所有 Agent 的扩展提示词
     if (this._framework && this._framework._ready) {
       this._refreshAllAgentsExtPrompt(this._framework);
     }
   }
 
-  /**
-   * 重新扫描插件的工具（用于热重载）
-   */
   _rescanPluginTools(plugin) {
     if (!plugin || !plugin.tools || typeof plugin.tools !== 'object') {
       return;
@@ -110,16 +92,13 @@ class ExtensionExecutorPlugin extends Plugin {
     const pluginName = plugin.name;
     if (!pluginName) return;
 
-    // skill-manager 插件使用 'skill' 作为扩展名（保持与 Skill.registerCommands 一致）
     const extName = pluginName === 'skill-manager' ? 'skill' : pluginName;
 
-    // 先移除旧工具（同时检查 'skill' 和 'skill-manager' 两个扩展名）
     const keysToRemove = [extName, pluginName];
     for (const key of keysToRemove) {
       if (this._extensions.has(key)) {
         const ext = this._extensions.get(key);
         for (const tool of ext.tools || []) {
-          // 从 toolRouter 移除
           if (this._framework?.toolRouter) {
             this._framework.toolRouter.unregister(`ext_${tool.name}`);
           }
@@ -128,19 +107,18 @@ class ExtensionExecutorPlugin extends Plugin {
       }
     }
 
-    // 重新扫描工具，使用正确的扩展名
     this._scanPluginTools(plugin, extName);
-    //log.info(` Rescanned tools from plugin '${pluginName}' (as '${extName}')`);
   }
 
   async start(framework) {
-    // 扫描所有已加载插件的 tools
     const plugins = framework.pluginManager.getAll();
     for (const { instance: plugin } of plugins) {
+      if (plugin.name === 'skill-manager') {
+        continue;
+      }
       this._scanPluginTools(plugin);
     }
 
-    // 获取 MCP executor 引用（用于 ext_call 统一路由）
     this._mcpExecutor = framework.pluginManager?.get('mcp') || null;
 
     framework.registerTool({
@@ -153,13 +131,10 @@ class ExtensionExecutorPlugin extends Plugin {
       }),
       execute: async (args) => {
         const { plugin, tool, args: toolArgs = {} } = args;
-        //log.info(`[Extension] ext_call: plugin=${plugin}, tool=${tool}`);
 
-        // MCP 服务器工具（已注册为 server_toolname 格式，如 github_search）
         if (plugin === 'mcp' && this._mcpExecutor) {
           const mcpToolDef = this._mcpExecutor.tools?.[tool];
           if (mcpToolDef && mcpToolDef.execute) {
-            //log.info(` ext_call [MCP]: tool=${tool}`);
             return await mcpToolDef.execute(toolArgs || {});
           }
           return { success: false, error: `MCP tool '${tool}' not found` };
@@ -167,7 +142,6 @@ class ExtensionExecutorPlugin extends Plugin {
 
         const ext = this._extensions.get(plugin);
         if (!ext) {
-          // 触发错误事件
           framework.emit('tool:error', {
             name: `${plugin}:${tool}`,
             args: toolArgs,
@@ -179,7 +153,6 @@ class ExtensionExecutorPlugin extends Plugin {
 
         const toolDef = ext.tools.find((t) => t.name === tool);
         if (!toolDef) {
-          // 触发错误事件
           framework.emit('tool:error', {
             name: `${plugin}:${tool}`,
             args: toolArgs,
@@ -190,7 +163,6 @@ class ExtensionExecutorPlugin extends Plugin {
         }
 
         try {
-          // 触发扩展工具开始事件
           framework.emit('tool:call', {
             name: `${plugin}:${tool}`,
             args: toolArgs,
@@ -202,12 +174,9 @@ class ExtensionExecutorPlugin extends Plugin {
             source: 'extension'
           });
 
-          // 统一 execute 签名为 (args, framework)
           const result = await toolDef.execute(toolArgs, framework);
 
-          // 检查结果是否为错误
           if (result && result.success === false && result.error) {
-            // 触发扩展工具错误事件
             framework.emit('tool:error', {
               name: `${plugin}:${tool}`,
               args: toolArgs,
@@ -217,7 +186,6 @@ class ExtensionExecutorPlugin extends Plugin {
             return result;
           }
 
-          // 触发扩展工具完成事件
           framework.emit('tool:result', {
             name: `${plugin}:${tool}`,
             args: toolArgs,
@@ -229,7 +197,6 @@ class ExtensionExecutorPlugin extends Plugin {
         } catch (err) {
           log.error(` Tool '${tool}' failed:`, err.message);
 
-          // 触发扩展工具错误事件
           framework.emit('tool:error', {
             name: `${plugin}:${tool}`,
             args: toolArgs,
@@ -267,8 +234,8 @@ class ExtensionExecutorPlugin extends Plugin {
         plugin: z.string().describe('扩展插件名称')
       }),
       execute: async (args) => {
-        const { plugin} = args;
-        if(plugin === 'skill'){
+        const { plugin } = args;
+        if (plugin === 'skill') {
           return "请使用 `loadSkill` 获取skill的使用详情"
         }
         return this.bindAllToolSkill(plugin)
@@ -287,7 +254,6 @@ class ExtensionExecutorPlugin extends Plugin {
       });
     }
 
-    // 注册扩展插件的提示词部分（使用基类方法）
     this.registerPromptPart('extension-tools', PROMPT_PRIORITY.EXTENSION_TOOLS, () => this._buildExtensionsDescription());
 
     return this;
@@ -316,27 +282,23 @@ class ExtensionExecutorPlugin extends Plugin {
       inputSchema: toolDef.inputSchema,
       execute: toolDef.execute,
     };
-    // 保留额外属性（如 _options）
     if (toolDef._options) {
       toolEntry._options = toolDef._options;
     }
     if (existingIdx >= 0) {
-      // 更新已存在的工具
       ext.tools[existingIdx] = toolEntry;
     } else {
-      // 添加新工具
       ext.tools.push(toolEntry);
     }
 
     log.debug(` Registered tool '${toolDef.name}' for extension '${pluginName}'`);
 
-    // 刷新所有 Agent 的扩展提示词
     if (this._framework && this._framework._ready) {
       this._refreshAllAgentsExtPrompt(this._framework);
     }
   }
 
-  bindAllToolSkill(pluginName){
+  bindAllToolSkill(pluginName) {
     const mcp = this._framework.pluginManager.get('mcp');
     const sections = [
       '你可以通过 `ext_call` 工具调用以下扩展插件的功能。',
@@ -353,11 +315,10 @@ class ExtensionExecutorPlugin extends Plugin {
     ];
 
     const ext = this._extensions.get(pluginName);
-    if(!ext)return '找不到扩展！'
+    if (!ext) return '找不到扩展！'
     for (const tool of ext.tools) {
       sections.push(`#### \`${tool.name}\``, '');
       sections.push(tool.description || '无描述', '');
-      // 使用 zodSchemaToMarkdown 解析参数
       if (ext.name === 'mcp' && mcp) {
         const mcp_desc = mcp._bindMcpParamsDesc(tool.inputSchema);
         sections.push(mcp_desc, '');
@@ -376,7 +337,6 @@ class ExtensionExecutorPlugin extends Plugin {
 
     sections.push('');
     return sections.join('\n')
-
   }
 
   _refreshAllAgentsExtPrompt(framework) {
@@ -401,18 +361,13 @@ class ExtensionExecutorPlugin extends Plugin {
 
     let existingPrompt = agent._originalPrompt || '';
 
-    // 移除所有已存在的 ## 【Extensions】 部分（防止重复累积）
     const extRegex = /## 【Extensions】[\s\S]*?(?=\n## 【|$)/;
     existingPrompt = existingPrompt.replace(extRegex, '').trim();
-
-    // 添加新的 Extensions 部分
-    //agent.setSystemPrompt(existingPrompt + '\n\n' + extDesc);
   }
 
   _buildExtensionsDescription() {
     let desc = '';
 
-    // 扩展插件工具（仅列出名称和简介，详细信息通过 ext_schema 按需获取）
     if (this._extensions.size > 0 || (this._mcpExecutor && Object.keys(this._mcpExecutor.tools || {}).length > 0)) {
       desc += '## 【Extensions】扩展插件\n\n';
       desc += '**使用流程（必须按顺序执行）：**\n';
@@ -421,15 +376,13 @@ class ExtensionExecutorPlugin extends Plugin {
       desc += '> **警告**：禁止在未执行第1步获取参数的情况下直接调用 `ext_call`！\n\n';
 
       for (const [name, ext] of this._extensions) {
-          if (name === 'mcp'|| name === 'skill') continue; // MCP 和 Skill 工具单独列出
+          if (name === 'mcp' || name === 'skill') continue;
           desc += `### ${ext.name || name}\n`;
           desc += `${ext.description || '无描述'}\n`;
           const validTools = ext.tools.filter(t => t && t.name);
           desc += `**工具:** ${validTools.map(t => `\`${t.name}\``).join(', ')}\n\n`;
-  
       }
 
-      // MCP 服务器工具
       if (this._mcpExecutor && Object.keys(this._mcpExecutor.tools || {}).length > 0) {
         desc += '### mcp (MCP 服务器工具)\n';
         desc += '已注册为 `服务器_工具名` 格式\n';
@@ -447,26 +400,18 @@ class ExtensionExecutorPlugin extends Plugin {
     return desc.trim();
   }
 
-  /**
-   * 将 Schema 转换为 Markdown 格式的参数描述
-   * 支持 Zod schema 和 JSON Schema
-   */
   _convertSchemaToMarkdown(inputSchema) {
     if (!inputSchema) return null;
 
-    // 提取实际 schema（处理 { jsonSchema: {...} } 或 { inputSchema: {...} } 格式）
     let schema = inputSchema;
     if (inputSchema.jsonSchema) schema = inputSchema.jsonSchema;
     if (inputSchema.inputSchema) schema = inputSchema.inputSchema;
 
-    // 检查是否是 Zod schema
     const isZodSchema = typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
     if (isZodSchema) {
-      // Zod schema 直接转换
       return zodSchemaToMarkdown(schema);
     }
 
-    // JSON Schema 转换为 Zod 再转换
     if (schema.properties) {
       const zodSchema = this._jsonSchemaToZod(schema);
       if (zodSchema) {
@@ -474,13 +419,9 @@ class ExtensionExecutorPlugin extends Plugin {
       }
     }
 
-    // 如果都没有，回退到简单格式
     return this._schemaToMarkdown(schema);
   }
 
-  /**
-   * 将 JSON Schema 转换为 Zod schema
-   */
   _jsonSchemaToZod(jsonSchema) {
     if (!jsonSchema || !jsonSchema.properties) return null;
 
@@ -499,9 +440,6 @@ class ExtensionExecutorPlugin extends Plugin {
     }
   }
 
-  /**
-   * 将 JSON Schema 属性转换为 Zod 类型
-   */
   _jsonSchemaPropToZod(prop, isRequired) {
     if (prop.enum) {
       let zodType = z.string().enum(prop.enum);
@@ -534,9 +472,6 @@ class ExtensionExecutorPlugin extends Plugin {
     }
   }
 
-  /**
-   * 将 JSON Schema 转换为 Markdown（简单格式）
-   */
   _schemaToMarkdown(schema) {
     if (!schema || !schema.properties) return null;
 
@@ -562,9 +497,6 @@ class ExtensionExecutorPlugin extends Plugin {
     }));
   }
 
-  /**
-   * 获取 skill 命令列表（用于 autocomplete）
-   */
   getSkillCommands() {
     const ext = this._extensions.get('skill');
     if (!ext) return [];
@@ -577,9 +509,6 @@ class ExtensionExecutorPlugin extends Plugin {
       }));
   }
 
-  /**
-   * 获取 skill 命令帮助文本
-   */
   getSkillCommandsHelp() {
     const ext = this._extensions.get('skill');
     if (!ext || ext.tools.length === 0) return '';
@@ -595,12 +524,6 @@ class ExtensionExecutorPlugin extends Plugin {
     return lines.join('\n');
   }
 
-  /**
-   * 检查并执行 skill 命令
-   * @param {string} command - 命令名（如 "skillname:cmdname"）
-   * @param {string} args - 命令参数
-   * @returns {Promise<object|null>} 执行结果，失败返回 null
-   */
   async executeSkillCommand(command, args) {
     if (!command.includes(':')) return null;
     try {
@@ -618,24 +541,17 @@ class ExtensionExecutorPlugin extends Plugin {
 
   async reload(framework) {
     this._framework = framework;
-    // 重新扫描所有已加载插件的 tools
     this._extensions.clear();
     const plugins = framework.pluginManager.getAll();
     for (const { instance: plugin } of plugins) {
-      // 使用 _rescanPluginTools 以正确处理 skill-manager 的 'skill' extName 映射
-      // （_scanPluginTools 不传 extName 时会用 pluginName,对 skill-manager 不正确）
       this._rescanPluginTools(plugin);
     }
-    // 重新获取 MCP executor 引用
     this._mcpExecutor = framework.pluginManager?.get('mcp') || null;
-    // 刷新所有 Agent 的扩展提示词
     this._refreshAllAgentsExtPrompt(framework);
 
-    // 同时重载 MCP 配置
     await this._reloadMCPConfig(framework);
   }
 
-  // 重载 MCP 配置
   async _reloadMCPConfig(framework) {
     const fs = require('fs');
     const path = require('path');
@@ -661,4 +577,4 @@ class ExtensionExecutorPlugin extends Plugin {
   }
 }
 
-module.exports = ExtensionExecutorPlugin
+module.exports = ExtensionExecutorPlugin