foliko 1.1.67 → 1.1.69

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

@@ -1,6 +1,6 @@
 /**
  * 默认插件配置加载器
- * 检测 .agent/ 目录下的配置，提供给 bootstrap() 使用
+ * 检测 .foliko/ 目录下的配置，提供给 bootstrap() 使用
  */
 
 const fs = require('fs')
@@ -11,10 +11,10 @@ const log = logger.child('AgentConfig')
 const bootstrapLog = logger.child('Bootstrap')
 
 /**
- * 加载 .agent 目录下的配置
+ * 加载 .foliko 目录下的配置
  * 返回配置对象，可用于手动加载插件
  */
-function loadAgentConfig(agentDir = '.agent') {
+function loadAgentConfig(agentDir = '.foliko') {
   const config = {
     agentDir,
     ai: {},
@@ -28,7 +28,7 @@ function loadAgentConfig(agentDir = '.agent') {
   const resolvedDir = path.resolve(process.cwd(), agentDir)
 
   if (!fs.existsSync(resolvedDir)) {
-    log.info(` .agent directory not found: ${resolvedDir}`)
+    log.info(` .foliko directory not found: ${resolvedDir}`)
     return config
   }
 
@@ -136,7 +136,7 @@ function loadAgentConfig(agentDir = '.agent') {
     }
   }
 
-  // 添加 .agent/skills 目录（不存在则创建）
+  // 添加 .foliko/skills 目录（不存在则创建）
   const skillsDir = path.join(resolvedDir, 'skills')
   if (fs.existsSync(resolvedDir) && !fs.existsSync(skillsDir)) {
     fs.mkdirSync(skillsDir, { recursive: true })
@@ -146,7 +146,7 @@ function loadAgentConfig(agentDir = '.agent') {
     config.skillsDirs.push(skillsDir)
   }
 
-  // 添加 .agent/skills 目录（不存在则创建）
+  // 添加 .foliko/skills 目录（不存在则创建）
   const cmdskillsDir = path.join(cmdDir, 'skills')
   if (fs.existsSync(resolvedDir) && !fs.existsSync(cmdskillsDir)) {
     fs.mkdirSync(cmdskillsDir, { recursive: true })
@@ -184,7 +184,7 @@ class DefaultPlugins extends Plugin {
     this.system = true 
 
     this._framework = null
-    this._agentDir = config.agentDir || '.agent'
+    this._agentDir = config.agentDir || '.foliko'
     this._config = null
   }
 
@@ -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')
@@ -382,8 +393,8 @@ async function bootstrapDefaults(framework, config = {}) {
 /**
  * 解析插件路径
  * 支持两种结构：
- * 1. 文件夹结构: .agent/plugins/my-plugin/index.js
- * 2. 单文件结构: .agent/plugins/my-plugin.js
+ * 1. 文件夹结构: .foliko/plugins/my-plugin/index.js
+ * 2. 单文件结构: .foliko/plugins/my-plugin.js
  * 支持符号链接
  * @param {string} pluginsDir - 插件目录
  * @param {string} name - 插件名称
@@ -501,10 +512,10 @@ async function loadCustomPlugins(framework, agentConfig) {
   const { Plugin } = require('../src/core/plugin-base')
 
   // 加载两个目录下的自定义插件：
-  // 1. .agent/plugins/ - 用户自定义插件（强制启用）
+  // 1. .foliko/plugins/ - 用户自定义插件（强制启用）
   // 2. plugins/ - 项目内置插件（自动加载）
   const dirs = [
-    { dir: path.resolve(process.cwd(), '.agent', 'plugins'), forceEnabled: true },
+    { dir: path.resolve(process.cwd(), '.foliko', 'plugins'), forceEnabled: true },
     { dir: path.resolve(process.cwd(), 'plugins'), forceEnabled: false },
     { dir: path.resolve(__dirname, '..', 'plugins'), forceEnabled: false }   
     // 项目下的 plugins 目录（兼容旧版本）

package/plugins/email/index.js

@@ -94,7 +94,7 @@ class EmailPlugin extends Plugin {
 
     // 持久化存储
     this._emailStore = null
-    this._persistencePath = config.persistencePath || '.agent/data/email/processed-emails.json'
+    this._persistencePath = config.persistencePath || '.foliko/data/email/processed-emails.json'
 
     // 防抖相关
     this._emailDebounceMap = new Map()  // msgId -> timer

package/plugins/extension-executor-plugin.js

@@ -6,6 +6,7 @@
 const { Plugin } = require('../src/core/plugin-base');
 const { logger } = require('../src/utils/logger');
 const { z } = require('zod');
+const { PROMPT_PRIORITY } = require('../src/core/constants');
 const { zodSchemaToMarkdown,zodSchemaToTable } = require('@chnak/zod-to-markdown');
 
 const log = logger.child('ExtensionExecutor');
@@ -208,7 +209,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 +240,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 };
       },
     });
 
@@ -268,7 +269,7 @@ class ExtensionExecutorPlugin extends Plugin {
     }
 
     // 注册扩展插件的提示词部分（使用基类方法）
-    this.registerPromptPart('extension-tools', 70, () => this._buildExtensionsDescription());
+    this.registerPromptPart('extension-tools', PROMPT_PRIORITY.EXTENSION_TOOLS, () => this._buildExtensionsDescription());
 
     return this;
   }
@@ -391,14 +392,41 @@ class ExtensionExecutorPlugin extends Plugin {
     if (this._extensions.size > 0 || (this._mcpExecutor && Object.keys(this._mcpExecutor.tools || {}).length > 0)) {
       desc += '## 【Extensions】扩展插件\n\n';
       desc += '**使用流程（必须按顺序执行）：**\n';
-      desc += '1. 调用 `ext_skill({ skill: "插件名" })` 获取目标扩展的详细工具参数\n';
-      desc += '2. 根据返回的参数定义，使用 `ext_call({ plugin, tool, args })` 调用扩展\n\n';
+      desc += '1. 调用 `ext_skill({ plugin: "skill" })` 获取技能命令的详细参数\n';
+      desc += '2. 根据返回的参数定义，使用 `ext_call({ plugin: "skill", tool: "技能名:命令名", args: {...} })` 调用\n\n';
       desc += '> **警告**：禁止在未执行第1步获取参数的情况下直接调用 `ext_call`！\n\n';
 
       for (const [name, ext] of this._extensions) {
-        desc += `### ${ext.name || name}\n`;
-        desc += `${ext.description || '无描述'}\n`;
-        desc += `**工具:** ${ext.tools.map(t => `\`${t.name}\``).join(', ')}\n\n`;
+        if (name === 'skill') {
+          // Skill 命令按技能名分组显示
+          const toolsBySkill = {};
+          for (const tool of ext.tools) {
+            // 命令格式: skillname:cmdname
+            const parts = tool.name.split(':');
+            const skillName = parts[0];
+            const cmdName = parts.slice(1).join(':');
+            if (!toolsBySkill[skillName]) {
+              toolsBySkill[skillName] = [];
+            }
+            toolsBySkill[skillName].push({ name: cmdName, description: tool.description });
+          }
+
+          for (const [skillName, cmds] of Object.entries(toolsBySkill)) {
+            desc += `### skill.${skillName}\n`;
+            desc += `**调用方式:**\n`;
+            desc += `1. 先调用 \`loadSkill({ skill: "${skillName}" })\` 获取 \`${skillName}\` 技能的详细参数\n`;
+            desc += `2. 调用 \`ext_call({ plugin: "skill", tool: "${skillName}:<命令名>", args: { args: "参数" } })\`\n\n`;
+            desc += `**可用命令:**\n`;
+            for (const c of cmds) {
+              desc += `- \`${c.name}\`: ${c.description}\n`;
+            }
+            desc += '\n';
+          }
+        } else {
+          desc += `### ${ext.name || name}\n`;
+          desc += `${ext.description || '无描述'}\n`;
+          desc += `**工具:** ${ext.tools.map(t => `\`${t.name}\``).join(', ')}\n\n`;
+        }
       }
 
       // MCP 服务器工具
@@ -534,6 +562,56 @@ class ExtensionExecutorPlugin extends Plugin {
     }));
   }
 
+  /**
+   * 获取 skill 命令列表（用于 autocomplete）
+   */
+  getSkillCommands() {
+    const ext = this._extensions.get('skill');
+    if (!ext) return [];
+    return ext.tools.map(t => ({
+      name: t.name.replace(/^([^:]+):(.*)$/, '$1:$2'),
+      description: t.description || t.name,
+    }));
+  }
+
+  /**
+   * 获取 skill 命令帮助文本
+   */
+  getSkillCommandsHelp() {
+    const ext = this._extensions.get('skill');
+    if (!ext || ext.tools.length === 0) return '';
+
+    const lines = [];
+    for (const tool of ext.tools) {
+      const parts = tool.name.split(':');
+      if (parts.length === 2) {
+        lines.push(`/${parts[0]}:${parts[1]} - ${tool.description || '无描述'}`);
+      }
+    }
+    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 {
+      const result = await this._framework.executeTool('ext_call', {
+        plugin: 'skill',
+        tool: command,
+        args: { args }
+      });
+      return result.success !== false ? result : null;
+    } catch (err) {
+      log.warn('Skill command failed:', err.message);
+      return null;
+    }
+  }
+
   async reload(framework) {
     this._framework = framework;
     // 重新扫描所有已加载插件的 tools
@@ -559,7 +637,7 @@ class ExtensionExecutorPlugin extends Plugin {
     if (!mcpExecutor) return;
 
     try {
-      const configPath = path.resolve('.agent/mcp_config.json');
+      const configPath = path.resolve('.foliko/mcp_config.json');
       if (fs.existsSync(configPath)) {
         const configContent = fs.readFileSync(configPath, 'utf8');
         const config = JSON.parse(configContent);