foliko 1.1.93 → 2.0.1

package/plugins/{think-plugin.js → core/think/index.js}

@@ -3,8 +3,8 @@
  * 支持 LLM 自我唤醒、自动反思、持续思考
  */
 
-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 log = logger.child('Think')
 const { z } = require('zod')
 
@@ -14,27 +14,27 @@ class ThinkPlugin extends Plugin {
     this.name = 'think'
     this.version = '1.0.0'
     this.description = '主动思考插件,支持 LLM 自我唤醒和持续思考'
-    this.priority = 5  // 高优先级,早期加载
+    this.priority = 5
 
     this.config = {
-      autoReflect: config.autoReflect === true,  // 默认关闭自动反思
-      reflectDelay: config.reflectDelay || 2000,   // 反思延迟(ms)
-      maxReflectDepth: config.maxReflectDepth || 3,  // 最大反思深度
-      enableContinuous: config.enableContinuous || false  // 是否启用持续思考
+      autoReflect: config.autoReflect === true,
+      reflectDelay: config.reflectDelay || 2000,
+      maxReflectDepth: config.maxReflectDepth || 3,
+      enableContinuous: config.enableContinuous || false
     }
-    this.tools = {}  // 存储注册的工具函数
+    this.tools = {}
     this._framework = null
-    this._thoughts = []  // 思考记录
-    this._thinkAgent = null  // 缓存的思考子 agent
-    this._reflectionChain = []  // 反思链
+    this._thoughts = []
+    this._thinkAgent = null
+    this._reflectionChain = []
     this._continuousMode = false
     this._continuousTimer = null
     this._continuousTopic = null
-    this._continuousMessages = []  // 持续思考的上下文消息
-    this._continuousRounds = 0     // 持续思考轮次计数
-    this._lastThinkResultHash = null  // 上次思考结果 hash(用于检测重复)
-    this._consecutiveSimilarRounds = 0  // 连续相似轮次计数
-    this._maxContinuousRounds = 10  // 默认最大轮次
+    this._continuousMessages = []
+    this._continuousRounds = 0
+    this._lastThinkResultHash = null
+    this._consecutiveSimilarRounds = 0
+    this._maxContinuousRounds = 10
     this._pendingReflection = null
   }
 
@@ -44,9 +44,6 @@ class ThinkPlugin extends Plugin {
   }
 
   start(framework) {
-    // 注册思考工具 - 这些工具可以让主 agent 的 LLM 调用
-    // think 支持工具执行循环,LLM 可以让它完成需要调用工具的任务
-
     framework.registerTool({
       name: 'think_now',
       description: '触发深度思考,支持调用工具分析项目代码。当需要分析、优化、修改代码或文件时使用此工具。',
@@ -101,13 +98,9 @@ class ThinkPlugin extends Plugin {
     return this
   }
 
-  /**
-   * 创建思考用的 Subagent
-   */
   _createThinkSubagent() {
     const aiPlugin = this._framework.pluginManager?.get('ai');
     const aiConfig = aiPlugin ? aiPlugin.getConfig() : {};
-    // log.info(`[Think] createSubAgent AI config: provider=${aiConfig.provider}, model=${aiConfig.model}, hasKey=${!!aiConfig.apiKey}`);
     return this._framework.createSubAgent({
       name: 'think',
       role: '思考助手',
@@ -126,26 +119,14 @@ class ThinkPlugin extends Plugin {
     })
   }
 
-  /**
-   * 触发主动思考
-   * @param {Object} args - 参数
-   * @param {string} args.topic - 思考主题
-   * @param {string} args.mode - 思考模式
-   * @param {number} args.depth - 思考深度
-   * @param {Object} args.agent - 外部 agent
-   * @param {Array} args.messages - 可选,上下文消息数组用于持续对话
-   */
   async _triggerThinking(args) {
     const mode = args.mode || 'reflect'
     const depth = Math.min(args.depth || 2, 5)
     const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方?'
-    // 支持外部传入 agent
     const externalAgent = args.agent
-    // 支持传入上下文消息
     const contextMessages = args.messages
 
     try {
-      // 检查 AI 配置
       const aiPlugin = this._framework.pluginManager?.get('ai')
       if (!aiPlugin) {
         this._emitNotification('error', '🧠 思考失败', 'AI 未配置')
@@ -157,18 +138,13 @@ class ThinkPlugin extends Plugin {
 
       const reflectPrompt = this._buildReflectPrompt(mode, depth, topic)
 
-      // 优先使用外部传入的 agent,否则使用缓存的 think agent
       const thinkAgent = externalAgent || this._thinkAgent || (this._thinkAgent = this._createThinkSubagent())
-      // log.info(`[Think] thinkAgent apiKey: ${thinkAgent.apiKey ? thinkAgent.apiKey.substring(0,8) + '...' : 'null'}, provider: ${thinkAgent.provider}, model: ${thinkAgent.model}`)
 
       let result
       if (contextMessages && contextMessages.length > 0) {
-        // 持续对话模式:传入上下文消息
         const messages = [...contextMessages, { role: 'user', content: reflectPrompt }]
-        // log.info(`[Think] round with context: contextLen=${contextMessages.length}, totalMsgs=${messages.length}`);
         result = await thinkAgent.chat(messages)
       } else {
-        // 普通模式:新对话
         result = await thinkAgent.chat(reflectPrompt)
       }
 
@@ -182,18 +158,15 @@ class ThinkPlugin extends Plugin {
         timestamp: new Date()
       }
 
-      // log.info(`[Think] result.messages length: ${result.messages ? result.messages.length : 'undefined/null'}, success: ${result.success}, msgLen: ${(result.message || '').length}`);
       this._thoughts.push(thought)
       if (this._thoughts.length > 100) {
         this._thoughts = this._thoughts.slice(-100)
       }
 
-      // 返回消息数组(用于持续对话)
       if (contextMessages) {
         thought.messages = [...contextMessages, { role: 'user', content: reflectPrompt }, { role: 'assistant', content: result.message }]
       }
 
-      // 触发思考完成事件(使用文档规定的字段结构)
       if (this._framework) {
         this._framework.emit('think:thought_completed', {
           topic: thought.topic,
@@ -201,7 +174,6 @@ class ThinkPlugin extends Plugin {
           depth: thought.depth
         })
 
-        // 发送通知
         const level = mode === 'brainstorm' ? 'success' : 'info'
         this._emitNotification(level, '🧠 思考完成', thought.result)
       }
@@ -222,9 +194,6 @@ class ThinkPlugin extends Plugin {
     }
   }
 
-  /**
-   * 发送通知
-   */
   _emitNotification(level, title, message) {
     if (!this._framework) return
     this._framework.emit('notification', {
@@ -236,9 +205,6 @@ class ThinkPlugin extends Plugin {
     })
   }
 
-  /**
-   * 构建反思提示
-   */
   _buildReflectPrompt(mode, depth, topic) {
     const depthDesc = {
       1: '快速检视',
@@ -284,20 +250,15 @@ ${topic || '接下来的行动'}
     return modePrompts[mode] || modePrompts.reflect
   }
 
-  /**
-   * 自动反思(响应完成后)
-   */
   async _autoReflect(data) {
     if (!this._framework) return
 
     try {
-      // 检查是否需要反思(避免短时间重复反思)
       const lastThought = this._thoughts[this._thoughts.length - 1]
       if (lastThought && Date.now() - lastThought.timestamp.getTime() < 10000) {
-        return  // 10秒内不重复反思
+        return
       }
 
-      // 构建轻量级反思
       const reflectPrompt = `作为助手,请快速检视刚才的回答是否:
 1. 完整回答了用户的问题
 2. 表达清晰易懂
@@ -305,7 +266,6 @@ ${topic || '接下来的行动'}
 
 如果发现不足,请直接补充。如果没问题,请简短回复"检查完毕,无需补充"。`
 
-      // 使用轻量 Subagent 静默思考,不打断用户
       const thinkAgent = this._createThinkSubagent()
       const result = await thinkAgent.chat(reflectPrompt)
 
@@ -320,7 +280,6 @@ ${topic || '接下来的行动'}
 
       this._thoughts.push(thought)
 
-      // 如果反思有重要补充,触发事件通知
       if (result.message?.includes('补充') && !result.message?.includes('无需补充')) {
         this._framework.emit('think:reflection_needs_attention', {
           thought,
@@ -332,9 +291,6 @@ ${topic || '接下来的行动'}
     }
   }
 
-  /**
-   * 启动持续思考模式
-   */
   async _startContinuousThinking(args) {
     if (this._continuousMode) {
       this._emitNotification('warning', '⚠️ 持续思考', '持续思考已在运行中')
@@ -343,16 +299,15 @@ ${topic || '接下来的行动'}
 
     const interval = args.interval || 30000
     const topic = args.topic || '基于最近的对话,还有什么值得深入思考的方向?'
-    const maxRounds = args.maxRounds || 10  // 默认最多10轮
+    const maxRounds = args.maxRounds || 10
 
     this._continuousMode = true
     this._continuousTopic = topic
-    this._continuousMessages = []  // 初始化上下文消息
-    this._continuousRounds = 0      // 当前轮次计数
-    this._lastThinkResultHash = null  // 上次思考结果的 hash,用于检测重复
-    this._consecutiveSimilarRounds = 0  // 连续相似轮次计数
+    this._continuousMessages = []
+    this._continuousRounds = 0
+    this._lastThinkResultHash = null
+    this._consecutiveSimilarRounds = 0
     this._maxContinuousRounds = maxRounds
-    // 注意:不再需要捕获 sessionId,因为总结不加到会话
 
     const runThink = async () => {
       if (!this._continuousMode) return
@@ -367,18 +322,14 @@ ${topic || '接下来的行动'}
 
         this._continuousRounds++
 
-        // 更新上下文消息(用于下次思考)
         if (result.messages) {
           this._continuousMessages = result.messages
-          // 限制上下文长度,最多保留 10 条消息
           if (this._continuousMessages.length > 10) {
             this._continuousMessages = this._continuousMessages.slice(-10)
           }
         }
 
-        // 自然停止检测:结果相似度判断 + LLM 主动确认无新论点(第一轮不触发判断)
         const currentResult = (result.thought?.result || '').trim()
-        // 第一轮不判断无新论点(还没有内容可供对比),后续轮次才判断
         const noNewPoints = this._continuousRounds > 1 && currentResult.includes('【无新增论点,思考已充分】')
         const currentHash = this._hashString(currentResult)
         if (this._lastThinkResultHash !== null && currentHash === this._lastThinkResultHash) {
@@ -388,7 +339,6 @@ ${topic || '接下来的行动'}
         }
         this._lastThinkResultHash = currentHash
 
-        // 满足自然停止条件:LLM 主动确认无新论点 或 连续3轮相似 或 达到最大轮次
         const shouldStopNaturally =
           noNewPoints ||
           this._consecutiveSimilarRounds >= 3 ||
@@ -401,7 +351,6 @@ ${topic || '接下来的行动'}
           return
         }
 
-        // 触发下一轮
         if (this._continuousMode) {
           this._continuousTimer = setTimeout(runThink, interval)
         }
@@ -411,7 +360,6 @@ ${topic || '接下来的行动'}
       }
     }
 
-    // 立即执行一次
     await runThink()
 
     this._emitNotification('success', '✅ 持续思考已启动', `间隔: ${interval}ms`)
@@ -419,12 +367,9 @@ ${topic || '接下来的行动'}
     return {
       success: true,
       data: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
-    }  
+    }
   }
 
-  /**
-   * 停止持续思考模式
-   */
   _stopContinuousThinking() {
     const rounds = this._continuousRounds
     this._continuousMode = false
@@ -432,7 +377,7 @@ ${topic || '接下来的行动'}
       clearTimeout(this._continuousTimer)
       this._continuousTimer = null
     }
-    this._continuousMessages = []  // 清空上下文
+    this._continuousMessages = []
     this._continuousTopic = null
     this._continuousRounds = 0
     this._lastThinkResultHash = null
@@ -444,16 +389,11 @@ ${topic || '接下来的行动'}
     }
   }
 
-  /**
-   * 获取当前活跃的 Agent
-   */
   _getActiveAgent() {
-    // 优先使用主 Agent
     if (this._framework._mainAgent) {
       return this._framework._mainAgent
     }
 
-    // 否则找一个空闲的 Agent
     if (this._framework._agents && this._framework._agents.length > 0) {
       for (let i = this._framework._agents.length - 1; i >= 0; i--) {
         const agent = this._framework._agents[i]
@@ -465,19 +405,12 @@ ${topic || '接下来的行动'}
     return null
   }
 
-  /**
-   * 获取待处理的反思通知
-   */
   getPendingThoughts() {
     return this._thoughts.slice(-10).reverse()
   }
 
-  /**
-   * 字符串 hash(用于判断思考结果是否重复)
-   */
   _hashString(str) {
     if (!str || str.length === 0) return ''
-    // 简化为取前64字符的 hashcode
     let hash = 0
     const s = str.substring(0, 64)
     for (let i = 0; i < s.length; i++) {

package/{src/capabilities/workflow-engine.js → plugins/core/workflow/index.js}

@@ -2,15 +2,16 @@
  * WorkflowEngine 工作流引擎
  * 支持结构化工作流定义和执行
  */
-const { EventEmitter } = require('../utils/event-emitter');
-const { Plugin } = require('../core/plugin-base');
-const { logger } = require('../utils/logger');
+const { EventEmitter } = require('../../../src/common/events');
+const { Plugin } = require('../../../src/plugin/base');
+const { logger } = require('../../../src/common/logger');
 const log = logger.child('Workflow');
 const { z } = require('zod');
-const { runScriptSafely, evaluateInSandbox, runWorkflowFileSafely, runWorkflowSafely } = require('../utils/sandbox');
+const { runScriptSafely, evaluateInSandbox, runWorkflowFileSafely, runWorkflowSafely } = require('../../../src/utils/sandbox');
 const fs = require('fs');
 const crypto = require('crypto');
 const path = require('path');
+const os = require('os');
 /**
  * 工作流步骤类型
  */
@@ -821,6 +822,7 @@ class WorkflowPlugin extends Plugin {
     this._framework = null;
     this._engine = null;
     this._workflowsDir = config.workflowsDir || '.foliko/workflows';
+    this._homeWorkflowsDir = path.join(os.homedir(), '.foliko', 'workflows');
     this._workflows = new Map();
     this._workflowTools = new Map();
   }
@@ -875,6 +877,29 @@ class WorkflowPlugin extends Plugin {
         };
       },
     });
+
+    // 注册列出工作流的工具
+    framework.registerTool({
+      name: 'listWorkflows',
+      description: '列出所有已加载的工作流及其描述信息',
+      inputSchema: z.object({}),
+      execute: async () => {
+        const workflows = [];
+        for (const [name, workflow] of this._workflows) {
+          workflows.push({
+            name,
+            description: workflow.description || '',
+            stepCount: workflow.steps?.length || 0,
+            type: workflow.type || 'sequential',
+          });
+        }
+        return {
+          success: true,
+          data: workflows,
+          metadata: { total: this._workflows.size },
+        };
+      },
+    });
     return this;
   }
   /**
@@ -882,44 +907,49 @@ class WorkflowPlugin extends Plugin {
    */
   _loadWorkflows() {
     const cwd = this._framework?.getCwd?.() ?? process.cwd();
-    const dir = path.resolve(cwd, this._workflowsDir);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-      // log.info(` Created workflows directory: ${dir}`);
-      return;
-    }
-    try {
-      const files = fs.readdirSync(dir);
-      for (const file of files) {
-        if (!file.endsWith('.json') && !file.endsWith('.js')) continue;
-        const filePath = path.join(dir, file);
-        const workflowName = path.basename(file, path.extname(file));
-        // 跳过已存在的工作流
-        if (this._workflows.has(workflowName)) continue;
-        try {
-          const content = fs.readFileSync(filePath, 'utf-8');
-          let workflowDef;
-          if (file.endsWith('.js')) {
-            // 执行 JS 文件获取工作流定义
-            // 使用沙箱加载工作流文件，防止恶意代码执行
-            workflowDef = runWorkflowFileSafely(content, { timeout: 10000 });
-            if (typeof workflowDef === 'function') {
-              workflowDef = workflowDef(this._engine || {});
+    const dirs = [
+      this._homeWorkflowsDir,                          // ~/.foliko/workflows（优先）
+      path.resolve(cwd, this._workflowsDir),            // 项目级
+    ];
+
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        // 只创建项目级目录
+        if (dir === path.resolve(cwd, this._workflowsDir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        continue;
+      }
+      try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          if (!file.endsWith('.json') && !file.endsWith('.js')) continue;
+          const filePath = path.join(dir, file);
+          const workflowName = path.basename(file, path.extname(file));
+          // 跳过已存在的工作流（先加载的优先）
+          if (this._workflows.has(workflowName)) continue;
+          try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            let workflowDef;
+            if (file.endsWith('.js')) {
+              workflowDef = runWorkflowFileSafely(content, { timeout: 10000 });
+              if (typeof workflowDef === 'function') {
+                workflowDef = workflowDef(this._engine || {});
+              }
+              workflowDef = workflowDef.default || workflowDef;
+            } else {
+              workflowDef = JSON.parse(content);
             }
-            workflowDef = workflowDef.default || workflowDef;
-          } else {
-            workflowDef = JSON.parse(content);
-          }
-          if (workflowDef && workflowDef.steps) {
-            this._workflows.set(workflowName, workflowDef);
-            //// log.info(` Loaded: ${workflowName}`)
+            if (workflowDef && workflowDef.steps) {
+              this._workflows.set(workflowName, workflowDef);
+            }
+          } catch (err) {
+            log.error(` Failed to load ${file}:`, err.message);
           }
-        } catch (err) {
-          log.error(` Failed to load ${file}:`, err.message);
         }
+      } catch (err) {
+        log.error(` Failed to read workflows directory ${dir}:`, err.message);
       }
-    } catch (err) {
-      log.error(' Failed to read workflows directory:', err.message);
     }
   }
   /**
@@ -954,56 +984,23 @@ class WorkflowPlugin extends Plugin {
    * 重载工作流
    */
   reload(framework) {
-    // 清除模块缓存，确保重新加载最新代码
-    const modulePath = require.resolve('./src/capabilities/workflow-engine');
-    if (require.cache[modulePath]) {
-      delete require.cache[modulePath];
-    }
-    // log.info(' Reloading...');
+    // 清除当前模块缓存，确保重新加载最新代码
+    delete require.cache[__filename];
     this._framework = framework;
+    const fresh = require(__filename);
     // 重新创建 engine（确保使用最新代码）
-    this._engine = new (require('./src/capabilities/workflow-engine').WorkflowEngine)(framework);
+    this._engine = new fresh.WorkflowEngine(framework);
     // 注册内置步骤类型
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.SCRIPT,
-      require('./src/capabilities/workflow-engine').ScriptStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.TOOL,
-      require('./src/capabilities/workflow-engine').ToolStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.CONDITION,
-      require('./src/capabilities/workflow-engine').ConditionStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.SWITCH,
-      require('./src/capabilities/workflow-engine').SwitchStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.TRY,
-      require('./src/capabilities/workflow-engine').TryStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.PARALLEL,
-      require('./src/capabilities/workflow-engine').ParallelStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.SEQUENTIAL,
-      require('./src/capabilities/workflow-engine').SequentialStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.LOOP,
-      require('./src/capabilities/workflow-engine').LoopStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.DELAY,
-      require('./src/capabilities/workflow-engine').DelayStep
-    );
-    this._engine.registerStepType(
-      require('./src/capabilities/workflow-engine').StepType.WORKFLOW,
-      require('./src/capabilities/workflow-engine').NestedWorkflowStep
-    );
+    this._engine.registerStepType(fresh.StepType.SCRIPT, fresh.ScriptStep);
+    this._engine.registerStepType(fresh.StepType.TOOL, fresh.ToolStep);
+    this._engine.registerStepType(fresh.StepType.CONDITION, fresh.ConditionStep);
+    this._engine.registerStepType(fresh.StepType.SWITCH, fresh.SwitchStep);
+    this._engine.registerStepType(fresh.StepType.TRY, fresh.TryStep);
+    this._engine.registerStepType(fresh.StepType.PARALLEL, fresh.ParallelStep);
+    this._engine.registerStepType(fresh.StepType.SEQUENTIAL, fresh.SequentialStep);
+    this._engine.registerStepType(fresh.StepType.LOOP, fresh.LoopStep);
+    this._engine.registerStepType(fresh.StepType.DELAY, fresh.DelayStep);
+    this._engine.registerStepType(fresh.StepType.WORKFLOW, fresh.NestedWorkflowStep);
     // 清除已注册的工具
     for (const toolName of this._workflowTools.values()) {
       // 工具注销需要框架支持，这里只清理内部状态
@@ -1015,6 +1012,11 @@ class WorkflowPlugin extends Plugin {
     this._registerWorkflowTools();
     // log.info(` Reloaded. Total workflows: ${this._workflows.size}`);
   }
+
+  async onCwdChanged(oldCwd, newCwd, framework) {
+    this._workflowTools.clear();
+    this._workflows.clear();
+  }
   /**
    * 执行工作流
    */