foliko 1.1.64 → 1.1.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.1.64",
+  "version": "1.1.65",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",

package/plugins/audit-plugin.js

@@ -62,10 +62,12 @@ class AuditPlugin extends Plugin {
 
         return {
           success: true,
-          logs: logs.slice(-limit - offset, logs.length - offset),
-          total: logs.length,
-          offset,
-          limit
+          data: logs.slice(-limit - offset, logs.length - offset),
+          metadata: {
+            total: logs.length,
+            offset,
+            limit
+          }
         }
       }
     })
@@ -78,7 +80,7 @@ class AuditPlugin extends Plugin {
         const stats = this.getStats()
         return {
           success: true,
-          stats
+          data: stats
         }
       }
     })
@@ -96,8 +98,10 @@ class AuditPlugin extends Plugin {
         const result = this.exportLogs(args)
         return {
           success: true,
-          count: result.logs.length,
-          data: result.logs
+          data: result.logs,
+          metadata: {
+            count: result.logs.length
+          }
         }
       }
     })

package/plugins/coordinator-plugin.js

@@ -156,12 +156,14 @@ class CoordinatorPlugin extends Plugin {
 
           return {
             success: true,
-            workerId: result.workerId,
-            status: result.status,
-            result: result.result,
-            message: result.status === 'completed'
-              ? `Worker '${args.worker_name}' completed with result`
-              : `Worker '${args.worker_name}' ${result.status}`,
+            data: result.result,
+            metadata: {
+              workerId: result.workerId,
+              status: result.status,
+              message: result.status === 'completed'
+                ? `Worker '${args.worker_name}' completed with result`
+                : `Worker '${args.worker_name}' ${result.status}`,
+            },
           };
         } catch (err) {
           return { success: false, error: err.message };
@@ -187,8 +189,8 @@ class CoordinatorPlugin extends Plugin {
           const result = await coordinatorManager.sendToWorker(args.worker_name, args.message);
           return {
             success: true,
-            workerName: args.worker_name,
-            result: result.message || result,
+            data: result.message || result,
+            metadata: { workerName: args.worker_name },
           };
         } catch (err) {
           return { success: false, error: err.message };
@@ -214,7 +216,7 @@ class CoordinatorPlugin extends Plugin {
           const result = coordinatorManager.stopWorker(args.worker_name, args.reason);
           return {
             success: true,
-            ...result,
+            data: result,
           };
         } catch (err) {
           return { success: false, error: err.message };
@@ -236,8 +238,8 @@ class CoordinatorPlugin extends Plugin {
         const workers = coordinatorManager.listWorkers();
         return {
           success: true,
-          count: workers.length,
-          workers,
+          data: workers,
+          metadata: { count: workers.length },
         };
       },
     });
@@ -262,7 +264,7 @@ class CoordinatorPlugin extends Plugin {
 
         return {
           success: true,
-          worker,
+          data: worker,
         };
       },
     });

package/plugins/data-splitter-plugin.js

@@ -0,0 +1,323 @@
+/**
+ * DataSplitterPlugin — 大数据自动分拆插件
+ *
+ * 功能：
+ * 1. 注册 `split_and_process` 工具：AI 可主动调用，将大文本分拆给子 Agent 处理
+ * 2. 注册 `get_content_preview` 工具：获取大内容的前 N 行，判断是否需要分拆
+ * 3. 自动检测工具返回的大数据，触发透明分拆
+ * 4. 系统提示词中告知 AI 大数据处理能力
+ */
+
+const { Plugin } = require('../src/core/plugin-base');
+const { z } = require('zod');
+const { logger } = require('../src/utils/logger');
+const { DataSplitter } = require('../src/utils/data-splitter');
+
+// 超过此大小的工具结果自动触发分拆（字符数，默认 100K tokens ≈ 200K chars）
+const AUTO_SPLIT_THRESHOLD = 50000;
+
+class DataSplitterPlugin extends Plugin {
+  constructor(config = {}) {
+    super();
+    this.name = 'data-splitter';
+    this.version = '1.0.0';
+    this.description = '大数据自动分拆处理：读取大文件或抓取网页时，自动分拆为多个子Agent并行处理';
+    this.priority = 5;
+
+    this._framework = null;
+    this._splitter = null;
+
+    // 配置
+    this.config = {
+      autoSplitThreshold: config.autoSplitThreshold || AUTO_SPLIT_THRESHOLD,
+      chunkSize: config.chunkSize || 60000,
+      maxConcurrent: config.maxConcurrent || 3,
+      ...config,
+    };
+  }
+
+  install(framework) {
+    this._framework = framework;
+    this._splitter = new DataSplitter(framework, {
+      chunkSize: this.config.chunkSize,
+      safeThreshold: this.config.autoSplitThreshold,
+      maxConcurrent: this.config.maxConcurrent,
+    });
+
+    return this;
+  }
+
+  start(framework) {
+    // 注册大数据处理工具
+    this._registerSplitTools();
+
+    // 注册系统提示词
+    this.registerPromptPart('data-splitter-rules', 85, () => this._getPromptRules());
+
+    // 注册工具结果监听器（自动检测大结果）
+    this._registerAutoSplitHook();
+
+    logger.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 独立处理，最后给你一个汇总。`,
+      inputSchema: z.object({
+        content: z.string().describe('要分拆处理的大文本内容（如果超过 100K 字符建议使用此工具）'),
+        taskDescription: z.string().describe('每个子 Agent 要执行的任务描述，例如"提取所有函数定义"、"总结内容要点"等'),
+        chunkSize: z.number().optional().default(60000).describe('每块最大字符数，默认 60000'),
+        maxConcurrent: z.number().optional().default(3).describe('最大并行子 Agent 数，默认 3'),
+      }),
+      execute: async (args, ctx) => {
+        const { content, taskDescription, chunkSize, maxConcurrent } = args;
+        const splitter = this._getSplitter(ctx);
+
+        if (!content || content.length === 0) {
+          return { success: false, error: '内容为空，无需处理' };
+        }
+
+        const stats = splitter.getContentStats(content);
+        if (!splitter.needsSplit(content)) {
+          // 内容较小，直接返回
+          return {
+            success: true,
+            data: content,
+            metadata: {
+              needsSplit: false,
+              stats,
+              message: '内容大小在安全范围内，无需分拆处理。可直接使用原始内容。'
+            }
+          };
+        }
+
+        // 生成上下文中的 sessionId 用于取消信号
+        const sessionCtx = ctx?.getCurrentSessionContext?.();
+        const signal = sessionCtx?.abortSignal;
+
+        logger.info(
+          `[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({
+          chunks,
+          taskDescription,
+          maxConcurrent: maxConcurrent || this.config.maxConcurrent,
+          signal,
+        });
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+        return {
+          success: true,
+          data: result.summary,
+          metadata: {
+            needsSplit: true,
+            stats: { ...stats, actualChunks: chunks.length },
+            totalChunks: chunks.length,
+            successfulChunks: result.results.filter((r) => r.success).length,
+            failedChunks: result.errors.length,
+            durationSec: parseFloat(duration),
+          },
+        };
+      },
+    });
+
+    // ─── 工具2: get_content_preview — 获取大内容预览信息 ───
+    framework.registerTool({
+      name: 'get_content_preview',
+      description: `获取大文本内容的预览信息（前 20 行 + 统计），判断是否需要分拆处理。
+适合在读取大文件或抓取网页后用于检查内容大小。`,
+      inputSchema: z.object({
+        content: z.string().describe('要预览的大文本内容'),
+        previewLines: z.number().optional().default(20).describe('预览前 N 行，默认 20'),
+      }),
+      execute: async (args) => {
+        const { content, previewLines = 20 } = args;
+        const splitter = this._getSplitter();
+
+        const stats = splitter.getContentStats(content);
+        const lines = content.split('\n');
+        const preview = lines.slice(0, previewLines).join('\n');
+
+        return {
+          success: true,
+          data: preview || '(空内容)',
+          metadata: {
+            stats,
+            needsSplit: splitter.needsSplit(content),
+            totalLines: lines.length,
+            suggestion: splitter.needsSplit(content)
+              ? `内容较大 (${stats.chars} 字符, 约 ${stats.estimatedTokens} tokens)，建议使用 split_and_process 分拆处理`
+              : '内容大小在安全范围内',
+          }
+        };
+      },
+    });
+  }
+
+  /**
+   * 获取系统提示词
+   * @private
+   */
+  _getPromptRules() {
+    return `## 大数据处理能力
+
+你具备自动处理大文件和大网页的能力：
+
+1. **内容预览**：当工具返回的内容很大时，先用 \`get_content_preview\` 查看统计信息
+2. **分拆处理**：如果内容超过 10 万字符，用 \`split_and_process\` 将内容分块，每块交给独立的子 Agent 并行处理
+3. **自动汇总**：\`split_and_process\` 会自动汇总所有子 Agent 的处理结果，你只需基于汇总结果回答即可
+4. **性能提示**：分拆处理会并行运行多个子 Agent，处理大文件时效率很高
+
+### 使用建议
+- 读取大文件（> 100KB）时：先读取，如果内容太大，用 \`split_and_process\` 分拆分析
+- 抓取网页时：如果页面内容过多，用 \`split_and_process\` 分拆提取
+- 分拆时指定清晰的任务描述，例如"提取所有关键代码函数"、"总结每段内容要点"`;
+  }
+
+  /**
+   * 注册自动分拆钩子
+   * 监听 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);
+      } else {
+        checkContent = typeof result === 'string' ? result : JSON.stringify(result);
+      }
+      if (!checkContent || checkContent.length < this.config.autoSplitThreshold) return;
+
+      // 不阻塞执行，只在日志中记录建议
+      logger.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);
+    }
+
+    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();
+    }
+  }
+
+  uninstall(framework) {
+    if (this._toolResultHandler) {
+      framework.off('tool:result', this._toolResultHandler);
+    }
+  }
+}
+
+/**
+ * 自动检测工具结果是否过大，并透明处理
+ * 在 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);
+  } else {
+    checkContent = typeof result === 'string' ? result : JSON.stringify(result);
+  }
+  if (!checkContent || checkContent.length < AUTO_SPLIT_THRESHOLD) {
+    return { wasSplit: false, result };
+  }
+
+  const splitter = new DataSplitter(framework);
+  const taskDescription = `从以下内容中提取关键信息（代码、配置、数据等），以结构化方式输出。`;
+
+  logger.info(
+    `[DataSplitter] 自动分拆工具 "${toolName}": ${checkContent.length} 字符`
+  );
+
+  try {
+    const chunks = splitter.splitContent(checkContent);
+    const splitResult = await splitter.dispatchToSubAgents({
+      chunks,
+      taskDescription,
+      maxConcurrent: 3,
+    });
+
+    return {
+      wasSplit: true,
+      // 返回原始结果 + 分拆汇总，AI 可以同时看到两者
+      result: {
+        _autoSplit: true,
+        _originalSize: checkContent.length,
+        _summary: splitResult.summary,
+        _originalResult: result, // 保留原始结果供参考
+      },
+      splitterResult: splitResult,
+    };
+  } catch (err) {
+    logger.warn(`[DataSplitter] 自动分拆失败: ${err.message}`);
+    return { wasSplit: false, result };
+  }
+}
+
+module.exports = { DataSplitterPlugin, autoSplitToolResult };

package/plugins/default-plugins.js

@@ -364,7 +364,18 @@ async function bootstrapDefaults(framework, config = {}) {
     }
   }
 
-  // 6. 自动加载 plugins/ 目录下的所有插件
+  // 6. 大数据分拆插件
+  if (shouldLoad('data-splitter')) {
+    const { DataSplitterPlugin } = require('./data-splitter-plugin')
+    await framework.loadPlugin(new DataSplitterPlugin({
+      autoSplitThreshold: agentConfig.dataSplitter?.autoSplitThreshold || 50000,
+      chunkSize: agentConfig.dataSplitter?.chunkSize || 60000,
+      maxConcurrent: agentConfig.dataSplitter?.maxConcurrent || 3,
+    }))
+    framework._debug&&bootstrapLog.debug(' DataSplitter Plugin loaded')
+  }
+
+  // 7. 自动加载 plugins/ 目录下的所有插件
   await loadCustomPlugins(framework, agentConfig)
 
   framework._debug&&bootstrapLog.debug(' All plugins loaded')

package/plugins/extension-executor-plugin.js

@@ -208,7 +208,7 @@ class ExtensionExecutorPlugin extends Plugin {
             source: 'extension'
           });
 
-          return { success: true, result };
+          return { success: true, data: result };
         } catch (err) {
           log.error(` Tool '${tool}' failed:`, err.message);
 
@@ -239,7 +239,7 @@ class ExtensionExecutorPlugin extends Plugin {
             tools: ext.tools.map((t) => ({ name: t.name, description: t.description })),
           });
         }
-        return { success: true, extensions };
+        return { success: true, data: extensions };
       },
     });
 

package/plugins/file-system-plugin.js

@@ -76,7 +76,7 @@ class FileSystemPlugin extends Plugin {
             }
           }
           readDir(dirPath)
-          return { success: true, dirPath, items: items.slice(0, 100), total: items.length }
+          return { success: true, data: items.slice(0, 100), metadata: { dirPath, total: items.length } }
         } catch (error) {
           return { success: false, error: error.message }
         }
@@ -95,7 +95,7 @@ class FileSystemPlugin extends Plugin {
         const dirPath = args.path || args.dirPath
         try {
           fs.mkdirSync(dirPath, { recursive: true })
-          return { success: true, message: `目录已创建: ${dirPath}` }
+          return { success: true, data: `目录已创建: ${dirPath}` }
         } catch (error) {
           return { success: false, error: error.message }
         }
@@ -140,10 +140,12 @@ class FileSystemPlugin extends Plugin {
           }
           return {
             success: true,
-            filePath: pathCheck.resolved,
-            content,
-            size: stat.size,
-            lines: lines ? null : content.split('\n').length
+            data: content,
+            metadata: {
+              filePath: pathCheck.resolved,
+              size: stat.size,
+              lines: lines ? null : content.split('\n').length
+            }
           }
         } catch (error) {
           return { success: false, error: error.message }
@@ -210,10 +212,12 @@ class FileSystemPlugin extends Plugin {
               if (err) reject(err)
               else resolve({
                 success: true,
-                message: `文件已${mode === 'append' ? '追加' : '写入'}: ${pathCheck.resolved}`,
-                filePath: pathCheck.resolved,
-                size: content.length,
-                mode
+                data: `文件已${mode === 'append' ? '追加' : '写入'}: ${pathCheck.resolved}`,
+                metadata: {
+                  filePath: pathCheck.resolved,
+                  size: content.length,
+                  mode
+                }
               })
             })
           })
@@ -254,9 +258,11 @@ class FileSystemPlugin extends Plugin {
           fs.appendFileSync(pathCheck.resolved, content, 'utf8')
           return {
             success: true,
-            message: `已追加内容到: ${pathCheck.resolved}`,
-            filePath: pathCheck.resolved,
-            appendedSize: content.length
+            data: `已追加内容到: ${pathCheck.resolved}`,
+            metadata: {
+              filePath: pathCheck.resolved,
+              appendedSize: content.length
+            }
           }
         } catch (error) {
           return { success: false, error: error.message }
@@ -297,7 +303,7 @@ class FileSystemPlugin extends Plugin {
           } else {
             fs.unlinkSync(pathCheck.resolved)
           }
-          return { success: true, message: `已删除: ${pathCheck.resolved}` }
+          return { success: true, data: `已删除: ${pathCheck.resolved}` }
         } catch (error) {
           return { success: false, error: error.message }
         }
@@ -660,13 +666,15 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
 
           return {
             success: true,
-            pattern,
-            results: results.slice(0, maxResults),
-            total: results.length,
-            stats: {
-              filesWithMatches,
-              totalMatches,
-              searchPath: targetFile || dirPath
+            data: results.slice(0, maxResults),
+            metadata: {
+              pattern,
+              total: results.length,
+              stats: {
+                filesWithMatches,
+                totalMatches,
+                searchPath: targetFile || dirPath
+              }
             }
           }
         } catch (error) {
@@ -817,19 +825,23 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
               if (error) {
                 resolve({
                   success: false,
-                  command,
                   error: error.message,
-                  stderr: stderr.substring(0, 2000),
-                  stdout: stdout.substring(0, 2000),
-                  duration
+                  metadata: {
+                    command,
+                    stderr: stderr.substring(0, 2000),
+                    stdout: stdout.substring(0, 2000),
+                    duration
+                  }
                 })
               } else {
                 resolve({
                   success: true,
-                  command,
-                  stdout: stdout.substring(0, 10000),
-                  stderr: stderr.substring(0, 1000),
-                  duration
+                  data: stdout.substring(0, 10000),
+                  metadata: {
+                    command,
+                    stderr: stderr.substring(0, 1000),
+                    duration
+                  }
                 })
               }
             }
@@ -848,16 +860,18 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
         const beijingTime = new Date(now.getTime() + (8 * 60 * 60 * 1000))
         return {
           success: true,
-          beijingTime: beijingTime.toISOString().replace('T', ' ').substring(0, 19),
-          timestamp: now.getTime(),
-          timezone: 'Asia/Shanghai (UTC+8)',
-          formatted: {
-            year: beijingTime.getUTCFullYear(),
-            month: String(beijingTime.getUTCMonth() + 1).padStart(2, '0'),
-            day: String(beijingTime.getUTCDate()).padStart(2, '0'),
-            hour: String(beijingTime.getUTCHours()).padStart(2, '0'),
-            minute: String(beijingTime.getUTCMinutes()).padStart(2, '0'),
-            second: String(beijingTime.getUTCMinutes()).padStart(2, '0')
+          data: beijingTime.toISOString().replace('T', ' ').substring(0, 19),
+          metadata: {
+            timestamp: now.getTime(),
+            timezone: 'Asia/Shanghai (UTC+8)',
+            formatted: {
+              year: beijingTime.getUTCFullYear(),
+              month: String(beijingTime.getUTCMonth() + 1).padStart(2, '0'),
+              day: String(beijingTime.getUTCDate()).padStart(2, '0'),
+              hour: String(beijingTime.getUTCHours()).padStart(2, '0'),
+              minute: String(beijingTime.getUTCMinutes()).padStart(2, '0'),
+              second: String(beijingTime.getUTCMinutes()).padStart(2, '0')
+            }
           }
         }
       }
@@ -983,21 +997,25 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             : data
           return {
             success: true,
-            status: response.status,
-            statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
-            usedProxy: proxy,
-            body: truncatedData,
-            originalLength: typeof data === 'string' ? data.length : null,
-            truncated: maxLength && typeof data === 'string' && data.length > maxLength
+            data: truncatedData,
+            metadata: {
+              status: response.status,
+              statusText: response.statusText,
+              headers: Object.fromEntries(response.headers.entries()),
+              usedProxy: proxy,
+              originalLength: typeof data === 'string' ? data.length : null,
+              truncated: maxLength && typeof data === 'string' && data.length > maxLength
+            }
           }
         } catch (error) {
           return {
             success: false,
             error: error.message,
-            url,
-            method,
-            hint: '如果访问失败，可尝试设置 proxy: true'
+            metadata: {
+              url,
+              method,
+              hint: '如果访问失败，可尝试设置 proxy: true'
+            }
           }
         }
       }
@@ -1026,7 +1044,7 @@ edits 数组可以包含多个不重叠的替换操作，每个操作通过 oldT
             sessionId,
             timestamp: new Date().toISOString()
           })
-          return { success: true, message: '通知已发送' }
+          return { success: true, data: '通知已发送' }
         } catch (error) {
           return { success: false, error: error.message }
         }