foliko 2.0.4 → 2.0.6

package/plugins/core/sub-agent/PROMPT.md

@@ -0,0 +1,10 @@
+{{subagents}}
+
+### 子 Agent 调用规则
+
+> **重要**：必须严格遵守以下规则
+
+1. 根据上述「子 Agent 匹配表」，将任务委托给最匹配的子 Agent 处理
+2. 使用 `subagent_call` 工具并指定 `agentName` 来委托任务
+3. 只有当没有匹配的子 Agent 时，才直接调用工具
+4. 子 Agent 是没有记忆的，有需要的时候，有需要的时候，需要传递给上下文给子 Agent

package/plugins/core/sub-agent/index.js

@@ -306,10 +306,14 @@ class SubAgentManagerPlugin extends Plugin {
   prompts = [
     {
       name: 'subagents',
-      slot: 'CAPABILITY',
+      file: path.join(__dirname, 'PROMPT.md'),
+      scope: 'global',
+      priority: 60,
       description: '子Agent描述与分配规则',
-      provider: function () {
-        return this._buildDescription();
+      // interpolate 在渲染时注入动态内容
+      interpolate: (content) => {
+        const list = this._buildSubAgentsList();
+        return content.replace('{{subagents}}', list || '(暂无)');
       },
     },
   ];
@@ -567,6 +571,35 @@ class SubAgentManagerPlugin extends Plugin {
     return config
   }
 
+  _buildSubAgentsList() {
+    const allSubAgents = this.getAllSubAgents();
+    if (!allSubAgents || allSubAgents.length === 0) {
+      return '';
+    }
+
+    const lines = [];
+    for (const plugin of allSubAgents) {
+      const name = plugin.name;
+      const role = plugin.role;
+      const goal = plugin.description || '';
+
+      const config = this._framework._subAgentConfigManager?.get(name);
+      if (config) {
+        const agentDesc = config.getDescription();
+        const skills = config.getSkills();
+        let info = agentDesc || role || goal || '子代理';
+        if (skills && skills.length > 0) {
+          info += ` (技能: ${skills.join(', ')})`;
+        }
+        lines.push(`- **${name}**：${info}`);
+      } else {
+        lines.push(`- **${name}**：${role || goal || '子代理'}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
   _buildDescription() {
     const allSubAgents = this.getAllSubAgents();
     if (!allSubAgents || allSubAgents.length === 0) {

package/plugins/core/think/index.js

@@ -14,6 +14,7 @@ class ThinkPlugin extends Plugin {
     this.name = 'think'
     this.version = '1.0.0'
     this.description = '主动思考插件,支持 LLM 自我唤醒和持续思考'
+    this.enabled = config.enabled === true
     this.priority = 5
 
     this.config = {

package/plugins/core/workflow/index.js

@@ -287,33 +287,93 @@ class StepExecutor {
   }
   /**
    * 执行循环步骤
+   * 支持两种模式：
+   * 1. 固定次数循环：maxIterations + loopVariable
+   * 2. 数组迭代循环：over + as + index
    */
   async executeLoop(step, context) {
     this._log.debug(` Executing loop: ${step.name || step.id}`);
     const results = [];
-    const maxIterations = step.maxIterations || 10;
-    const loopVariable = step.loopVariable || 'loopIndex';
-    for (let i = 0; i < maxIterations; i++) {
-      context.variables[loopVariable] = i;
-      this._log.debug(` Loop iteration ${i}`);
-      const iterationResults = [];
-      for (const stepConfig of step.steps || []) {
-        const result = await this.executeStep(stepConfig, context);
-        iterationResults.push(result);
+
+    // 检查是否是数组迭代模式 (over + as)
+    if (step.over && step.as) {
+      // 数组迭代模式
+      const arrayPath = step.over;
+      const itemVar = step.as;
+      const indexVar = step.index || 'index';
+
+      // 解析数组路径 - 特殊处理 input.xxx 路径
+      let array;
+      if (arrayPath.startsWith('input.')) {
+        // 直接从 context.input 获取
+        const key = arrayPath.substring(6); // 去掉 'input.' 前缀
+        array = context.input ? context.input[key] : undefined;
+      } else {
+        array = this._resolveValue(`{{${arrayPath}}}`, context);
+      }
+
+      if (!Array.isArray(array)) {
+        this._log.warn(` Loop over: '${arrayPath}' is not an array, skipping. Found:`, typeof array);
+        return results;
       }
-      results.push(iterationResults);
-      // 检查终止条件
-      if (step.until) {
-        let shouldStop = false;
-        if (typeof step.until === 'function') {
-          shouldStop = step.until(context);
-        } else if (typeof step.until === 'string') {
-          // 使用沙箱评估循环条件，防止恶意代码执行
-        shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+
+      const maxIterations = step.maxIterations || array.length;
+      for (let i = 0; i < Math.min(maxIterations, array.length); i++) {
+        // 设置循环变量
+        context.variables[indexVar] = i;
+        context.variables[itemVar] = array[i];
+        context.variables.loopIndex = i; // 兼容旧代码
+
+        this._log.debug(` Loop iteration ${i}: ${itemVar}=`, array[i]);
+
+        // 执行循环体
+        const iterationResults = [];
+        for (const stepConfig of step.steps || []) {
+          const result = await this.executeStep(stepConfig, context);
+          iterationResults.push(result);
+        }
+        results.push(iterationResults);
+
+        // 检查终止条件
+        if (step.until) {
+          let shouldStop = false;
+          if (typeof step.until === 'function') {
+            shouldStop = step.until(context);
+          } else if (typeof step.until === 'string') {
+            shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+          }
+          if (shouldStop) {
+            this._log.debug(` Loop terminated at iteration ${i}`);
+            break;
+          }
+        }
+      }
+    } else {
+      // 固定次数循环模式（原有逻辑）
+      const maxIterations = step.maxIterations || 10;
+      const loopVariable = step.loopVariable || 'loopIndex';
+      for (let i = 0; i < maxIterations; i++) {
+        context.variables[loopVariable] = i;
+        context.variables.loopIndex = i; // 兼容
+        this._log.debug(` Loop iteration ${i}`);
+        const iterationResults = [];
+        for (const stepConfig of step.steps || []) {
+          const result = await this.executeStep(stepConfig, context);
+          iterationResults.push(result);
         }
-        if (shouldStop) {
-          this._log.debug(` Loop terminated at iteration ${i}`);
-          break;
+        results.push(iterationResults);
+        // 检查终止条件
+        if (step.until) {
+          let shouldStop = false;
+          if (typeof step.until === 'function') {
+            shouldStop = step.until(context);
+          } else if (typeof step.until === 'string') {
+            shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+          }
+          if (shouldStop) {
+            this._log.debug(` Loop terminated at iteration ${i}`);
+            break;
+          }
         }
       }
     }
@@ -773,7 +833,7 @@ class WorkflowEngine extends EventEmitter {
         type = StepType.WORKFLOW;
       } else if (config.branches) {
         type = StepType.CONDITION;
-      } else if (config.steps && (config.loopVariable || config.maxIterations)) {
+      } else if (config.steps && (config.loopVariable || config.maxIterations || config.over)) {
         type = StepType.LOOP;
       } else if (config.steps) {
         type = StepType.SEQUENTIAL;
@@ -981,6 +1041,30 @@ class WorkflowPlugin extends Plugin {
       // log.info(` Registered tool: ${toolName}`);
     }
   }
+
+  /**
+   * 移除工作流
+   * @param {string} name 工作流名称
+   * @returns {boolean} 是否成功移除
+   */
+  remove(name) {
+    if (!this._workflows.has(name)) {
+      return false;
+    }
+
+    // 从工作流定义中删除
+    this._workflows.delete(name);
+
+    // 清除已注册的工具
+    const toolName = this._workflowTools.get(name);
+    if (toolName) {
+      // 工具注销需要框架支持，这里只清理内部状态
+      this._workflowTools.delete(name);
+    }
+
+    return true;
+  }
+
   /**
    * 重载工作流
    */

package/plugins/executors/data-splitter/PROMPT.md

@@ -0,0 +1,13 @@
+## 大数据处理能力
+
+你具备自动处理大文件和大网页的能力：
+
+1. **内容预览**：当工具返回的内容很大时，先用 `get_content_preview` 查看统计信息
+2. **分拆处理**：如果内容超过 10 万字符，用 `split_and_process` 将内容分块，每块交给独立的子 Agent 并行处理
+3. **自动汇总**：`split_and_process` 会自动汇总所有子 Agent 的处理结果，你只需基于汇总结果回答即可
+4. **性能提示**：分拆处理会并行运行多个子 Agent，处理大文件时效率很高
+
+### 使用建议
+- 读取大文件（> 100KB）时：先读取，如果内容太大，用 `split_and_process` 分拆分析
+- 抓取网页时：如果页面内容过多，用 `split_and_process` 分拆提取
+- 分拆时指定清晰的任务描述，例如"提取所有关键代码函数"、"总结每段内容要点"

package/plugins/executors/data-splitter/index.js

@@ -2,12 +2,14 @@
  * DataSplitterPlugin — 大数据自动分拆插件
  */
 
+const path = require('path');
 const { Plugin } = require('../../../src/plugin/base');
 const { z } = require('zod');
 const { logger } = require('../../../src/common/logger');
 const { DataSplitter } = require('../../../src/utils/data-splitter');
 
 const AUTO_SPLIT_THRESHOLD = 50000;
+const PROMPT_DIR = __dirname;
 
 class DataSplitterPlugin extends Plugin {
   constructor(config = {}) {
@@ -43,11 +45,10 @@ class DataSplitterPlugin extends Plugin {
   prompts = [
     {
       name: 'data-splitter-rules',
-      slot: 'BEHAVIOR',
+      file: path.join(PROMPT_DIR, 'PROMPT.md'),
+      scope: 'global',
+      priority: 50,
       description: '大工具结果自动分拆规则',
-      provider: function () {
-        return this._getPromptRules();
-      },
     },
   ];
 

package/plugins/executors/extension/extension-registry.js

@@ -0,0 +1,145 @@
+'use strict';
+
+/**
+ * ExtensionRegistry - 扩展注册表
+ * 管理扩展插件及其工具的增删改查
+ */
+
+class ExtensionRegistry {
+  constructor(framework) {
+    this._extensions = new Map();
+    this._framework = framework;
+  }
+
+  // ============ 注册 ============
+
+  /**
+   * 注册或获取扩展条目
+   */
+  _getOrCreate(pluginName, pluginInfo) {
+    if (!this._extensions.has(pluginName)) {
+      this._extensions.set(pluginName, {
+        name: pluginInfo.name || pluginName,
+        description: pluginInfo.description || '',
+        version: pluginInfo.version || '1.0.0',
+        tools: [],
+      });
+    }
+    return this._extensions.get(pluginName);
+  }
+
+  /**
+   * 注册扩展工具
+   */
+  registerTool(pluginName, pluginInfo, toolDef) {
+    if (!toolDef || !toolDef.name) return false;
+
+    const ext = this._getOrCreate(pluginName, pluginInfo);
+
+    const toolEntry = {
+      name: toolDef.name,
+      description: toolDef.description || '',
+      inputSchema: toolDef.inputSchema,
+      execute: toolDef.execute,
+    };
+    if (toolDef._options) {
+      toolEntry._options = toolDef._options;
+    }
+    if (toolDef._rawSchema) {
+      toolEntry._rawSchema = toolDef._rawSchema;
+    }
+
+    const existingIdx = ext.tools.findIndex((t) => t.name === toolDef.name);
+    if (existingIdx >= 0) {
+      ext.tools[existingIdx] = toolEntry;
+    } else {
+      ext.tools.push(toolEntry);
+    }
+    return true;
+  }
+
+  /**
+   * 注销扩展工具
+   * @returns {boolean} 是否真正移除了扩展
+   */
+  unregisterTool(pluginName, toolName) {
+    const ext = this._extensions.get(pluginName);
+    if (!ext) return false;
+
+    const idx = ext.tools.findIndex((t) => t.name === toolName);
+    if (idx >= 0) {
+      ext.tools.splice(idx, 1);
+    }
+
+    // 如果扩展没有工具了，删除整个扩展
+    if (ext.tools.length === 0) {
+      this._extensions.delete(pluginName);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 清空指定扩展的所有工具
+   */
+  clearPlugin(pluginName) {
+    const ext = this._extensions.get(pluginName);
+    if (!ext) return false;
+    ext.tools = [];
+    this._extensions.delete(pluginName);
+    return true;
+  }
+
+  /**
+   * 清空所有
+   */
+  clear() {
+    this._extensions.clear();
+  }
+
+  // ============ 查询 ============
+
+  hasPlugin(name) {
+    return this._extensions.has(name);
+  }
+
+  hasTool(pluginName, toolName) {
+    const ext = this._extensions.get(pluginName);
+    if (!ext) return false;
+    return ext.tools.some((t) => t.name === toolName);
+  }
+
+  getPlugin(name) {
+    return this._extensions.get(name) || null;
+  }
+
+  getTool(pluginName, toolName) {
+    const ext = this._extensions.get(pluginName);
+    if (!ext) return null;
+    return ext.tools.find((t) => t.name === toolName) || null;
+  }
+
+  listPlugins() {
+    return Array.from(this._extensions.keys());
+  }
+
+  listTools(pluginName) {
+    const ext = this._extensions.get(pluginName);
+    return ext ? ext.tools : [];
+  }
+
+  getAll() {
+    return Array.from(this._extensions.entries()).map(([name, ext]) => ({
+      name,
+      description: ext.description,
+      version: ext.version,
+      tools: ext.tools,
+    }));
+  }
+
+  size() {
+    return this._extensions.size;
+  }
+}
+
+module.exports = { ExtensionRegistry };