foliko 1.0.74 → 1.0.76

package/plugins/think-plugin.js

@@ -1,343 +1,345 @@
-/**
- * Think 主动思考插件
- * 支持 LLM 自我唤醒、自动反思、持续思考
- */
-
-const { Plugin } = require('../src/core/plugin-base')
-const { z } = require('zod')
-
-class ThinkPlugin extends Plugin {
-  constructor(config = {}) {
-    super()
-    this.name = 'think'
-    this.version = '1.0.0'
-    this.description = '主动思考插件，支持 LLM 自我唤醒和持续思考'
-    this.priority = 5  // 高优先级，早期加载
-
-    this.config = {
-      autoReflect: config.autoReflect === true,  // 默认关闭自动反思
-      reflectDelay: config.reflectDelay || 2000,   // 反思延迟(ms)
-      maxReflectDepth: config.maxReflectDepth || 3,  // 最大反思深度
-      enableContinuous: config.enableContinuous || false  // 是否启用持续思考
-    }
-
-    this._framework = null
-    this._thoughts = []  // 思考记录
-    this._reflectionChain = []  // 反思链
-    this._continuousMode = false
-    this._continuousTimer = null
-    this._pendingReflection = null
-  }
-
-  install(framework) {
-    this._framework = framework
-    return this
-  }
-
-  start(framework) {
-    // 注册思考工具
-    framework.registerTool({
-      name: 'think_now',
-      description: '立即触发 LLM 主动思考（用于反思、自我检视、生成想法）',
-      inputSchema: z.object({
-        topic: z.string().optional().describe('思考主题，不提供则让 LLM 自己决定思考什么'),
-        mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式'),
-        depth: z.number().optional().describe('思考深度 1-5')
-      }),
-      execute: async (args) => {
-        return await this._triggerThinking(args)
-      }
-    })
-
-    framework.registerTool({
-      name: 'think_continue',
-      description: '让 LLM 持续思考模式（后台自动思考，定期输出结果）',
-      inputSchema: z.object({
-        interval: z.number().optional().describe('思考间隔毫秒，默认 30000 (30秒)'),
-        topic: z.string().optional().describe('思考主题')
-      }),
-      execute: async (args) => {
-        return await this._startContinuousThinking(args)
-      }
-    })
-
-    framework.registerTool({
-      name: 'think_stop',
-      description: '停止持续思考模式',
-      inputSchema: z.object({}),
-      execute: async () => {
-        return this._stopContinuousThinking()
-      }
-    })
-
-    framework.registerTool({
-      name: 'think_get_thoughts',
-      description: '获取思考历史记录',
-      inputSchema: z.object({
-        limit: z.number().optional().describe('返回条数，默认 10')
-      }),
-      execute: async (args) => {
-        const limit = args.limit || 10
-        return {
-          success: true,
-          thoughts: this._thoughts.slice(-limit).reverse(),
-          total: this._thoughts.length
-        }
-      }
-    })
-
-    return this
-  }
-
-  /**
-   * 触发主动思考
-   */
-  async _triggerThinking(args) {
-    const mode = args.mode || 'reflect'
-    const depth = Math.min(args.depth || 2, 5)
-    const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方？'
-
-    try {
-      const agent = this._getActiveAgent()
-      if (!agent) {
-        return { success: false, error: 'No active agent found' }
-      }
-
-      // 检查 agent 是否有 AI 配置
-      if (!agent.apiKey && !this._framework.pluginManager.get('ai')) {
-        return {
-          success: false,
-          error: 'AI 未配置。请在 .agent/ai.json 或环境变量中配置 AI API Key。'
-        }
-      }
-
-      const reflectPrompt = this._buildReflectPrompt(mode, depth, topic)
-      const result = await agent.pushMessage(reflectPrompt)
-
-      const thought = {
-        id: Date.now(),
-        mode,
-        depth,
-        topic,
-        prompt: reflectPrompt,
-        result: typeof result === 'string' ? result : JSON.stringify(result),
-        timestamp: new Date()
-      }
-
-      this._thoughts.push(thought)
-      if (this._thoughts.length > 100) {
-        this._thoughts = this._thoughts.slice(-100)
-      }
-
-      // 触发思考完成事件
-      if (this._framework) {
-        this._framework.emit('think:thought_completed', thought)
-      }
-
-      return {
-        success: true,
-        thought,
-        message: `【主动思考完成】\n模式: ${mode}\n主题: ${topic}\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`
-      }
-    } catch (err) {
-      return { success: false, error: err.message }
-    }
-  }
-
-  /**
-   * 构建反思提示
-   */
-  _buildReflectPrompt(mode, depth, topic) {
-    const depthDesc = {
-      1: '快速检视',
-      2: '简单反思',
-      3: '深入思考',
-      4: '批判性分析',
-      5: '全面审视'
-    }
-
-    const modePrompts = {
-      reflect: `你刚刚完成了一次对话。请${depthDesc[depth]}：
-
-1. 检查回答是否完整、准确
-2. 是否有遗漏的重要信息
-3. 是否有更好的表达方式
-4. 是否需要补充示例或细节
-
-${topic ? `额外关注: ${topic}` : ''}
-
-请直接输出你的反思结果，不需要重复之前的对话内容。`,
-
-      brainstorm: `请进行头脑风暴，针对以下主题产生更多想法：
-
-${topic || '刚才讨论的内容'}
-
-产生至少 3-5 个新的观点或方向，不必拘泥于之前讨论的内容。`,
-
-      analyze: `请对以下主题进行深度分析：
-
-${topic || '刚才讨论的内容'}
-
-分析要点：
-- 根本原因是什么？
-- 有哪些支持/反对的证据？
-- 可能的发展方向？`,
-
-      plan: `基于目前的讨论，请制定下一步计划：
-
-${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秒内不重复反思
-      }
-
-      const agent = this._getActiveAgent()
-      if (!agent) return
-
-      // 构建轻量级反思
-      const reflectPrompt = `作为助手，请快速检视刚才的回答是否：
-1. 完整回答了用户的问题
-2. 表达清晰易懂
-3. 有没有遗漏关键信息
-
-如果发现不足，请直接补充。如果没问题，请简短回复"检查完毕，无需补充"。`
-
-      // 静默思考，不打断用户
-      const result = await agent.pushMessage(reflectPrompt)
-
-      const thought = {
-        id: Date.now(),
-        mode: 'auto-reflect',
-        topic: '自动检视',
-        result: typeof result === 'string' ? result : '反思完成',
-        timestamp: new Date(),
-        auto: true
-      }
-
-      this._thoughts.push(thought)
-
-      // 如果反思有重要补充，触发事件通知
-      if (typeof result === 'string' && result.includes('补充') && !result.includes('无需补充')) {
-        this._framework.emit('think:reflection_needs_attention', {
-          thought,
-          originalData: data
-        })
-      }
-    } catch (err) {
-      console.error('[Think] Auto-reflect error:', err.message)
-    }
-  }
-
-  /**
-   * 启动持续思考模式
-   */
-  async _startContinuousThinking(args) {
-    if (this._continuousMode) {
-      return { success: false, error: 'Continuous thinking already running' }
-    }
-
-    const interval = args.interval || 30000
-    const topic = args.topic || '基于最近的对话，还有什么值得深入思考的方向？'
-
-    this._continuousMode = true
-    this._continuousTopic = topic
-
-    const runThink = async () => {
-      if (!this._continuousMode) return
-
-      try {
-        await this._triggerThinking({
-          topic: this._continuousTopic,
-          mode: 'reflect',
-          depth: 2
-        })
-
-        // 触发下一轮
-        if (this._continuousMode) {
-          this._continuousTimer = setTimeout(runThink, interval)
-        }
-      } catch (err) {
-        console.error('[Think] Continuous think error:', err.message)
-      }
-    }
-
-    // 立即执行一次
-    await runThink()
-
-    return {
-      success: true,
-      message: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
-    }
-  }
-
-  /**
-   * 停止持续思考模式
-   */
-  _stopContinuousThinking() {
-    this._continuousMode = false
-    if (this._continuousTimer) {
-      clearTimeout(this._continuousTimer)
-      this._continuousTimer = null
-    }
-    return {
-      success: true,
-      message: '持续思考已停止'
-    }
-  }
-
-  /**
-   * 获取当前活跃的 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]
-        if (agent.getStatus() === 'idle') {
-          return agent
-        }
-      }
-    }
-    return null
-  }
-
-  /**
-   * 获取待处理的反思通知
-   */
-  getPendingThoughts() {
-    return this._thoughts.slice(-10).reverse()
-  }
-
-  reload(framework) {
-    this._framework = framework
-  }
-
-  uninstall(framework) {
-    this._stopContinuousThinking()
-    this._thoughts = []
-    this._reflectionChain = []
-    this._framework = null
-  }
-}
-
-module.exports = { ThinkPlugin }
+/**
+ * Think 主动思考插件
+ * 支持 LLM 自我唤醒、自动反思、持续思考
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+const { logger } = require('../src/utils/logger')
+const log = logger.child('Think')
+const { z } = require('zod')
+
+class ThinkPlugin extends Plugin {
+  constructor(config = {}) {
+    super()
+    this.name = 'think'
+    this.version = '1.0.0'
+    this.description = '主动思考插件，支持 LLM 自我唤醒和持续思考'
+    this.priority = 5  // 高优先级，早期加载
+
+    this.config = {
+      autoReflect: config.autoReflect === true,  // 默认关闭自动反思
+      reflectDelay: config.reflectDelay || 2000,   // 反思延迟(ms)
+      maxReflectDepth: config.maxReflectDepth || 3,  // 最大反思深度
+      enableContinuous: config.enableContinuous || false  // 是否启用持续思考
+    }
+
+    this._framework = null
+    this._thoughts = []  // 思考记录
+    this._reflectionChain = []  // 反思链
+    this._continuousMode = false
+    this._continuousTimer = null
+    this._pendingReflection = null
+  }
+
+  install(framework) {
+    this._framework = framework
+    return this
+  }
+
+  start(framework) {
+    // 注册思考工具
+    framework.registerTool({
+      name: 'think_now',
+      description: '立即触发 LLM 主动思考（用于反思、自我检视、生成想法）',
+      inputSchema: z.object({
+        topic: z.string().optional().describe('思考主题，不提供则让 LLM 自己决定思考什么'),
+        mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式'),
+        depth: z.number().optional().describe('思考深度 1-5')
+      }),
+      execute: async (args) => {
+        return await this._triggerThinking(args)
+      }
+    })
+
+    framework.registerTool({
+      name: 'think_continue',
+      description: '让 LLM 持续思考模式（后台自动思考，定期输出结果）',
+      inputSchema: z.object({
+        interval: z.number().optional().describe('思考间隔毫秒，默认 30000 (30秒)'),
+        topic: z.string().optional().describe('思考主题')
+      }),
+      execute: async (args) => {
+        return await this._startContinuousThinking(args)
+      }
+    })
+
+    framework.registerTool({
+      name: 'think_stop',
+      description: '停止持续思考模式',
+      inputSchema: z.object({}),
+      execute: async () => {
+        return this._stopContinuousThinking()
+      }
+    })
+
+    framework.registerTool({
+      name: 'think_get_thoughts',
+      description: '获取思考历史记录',
+      inputSchema: z.object({
+        limit: z.number().optional().describe('返回条数，默认 10')
+      }),
+      execute: async (args) => {
+        const limit = args.limit || 10
+        return {
+          success: true,
+          thoughts: this._thoughts.slice(-limit).reverse(),
+          total: this._thoughts.length
+        }
+      }
+    })
+
+    return this
+  }
+
+  /**
+   * 触发主动思考
+   */
+  async _triggerThinking(args) {
+    const mode = args.mode || 'reflect'
+    const depth = Math.min(args.depth || 2, 5)
+    const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方？'
+
+    try {
+      const agent = this._getActiveAgent()
+      if (!agent) {
+        return { success: false, error: 'No active agent found' }
+      }
+
+      // 检查 agent 是否有 AI 配置
+      if (!agent.apiKey && !this._framework.pluginManager.get('ai')) {
+        return {
+          success: false,
+          error: 'AI 未配置。请在 .agent/ai.json 或环境变量中配置 AI API Key。'
+        }
+      }
+
+      const reflectPrompt = this._buildReflectPrompt(mode, depth, topic)
+      const result = await agent.pushMessage(reflectPrompt)
+
+      const thought = {
+        id: Date.now(),
+        mode,
+        depth,
+        topic,
+        prompt: reflectPrompt,
+        result: typeof result === 'string' ? result : JSON.stringify(result),
+        timestamp: new Date()
+      }
+
+      this._thoughts.push(thought)
+      if (this._thoughts.length > 100) {
+        this._thoughts = this._thoughts.slice(-100)
+      }
+
+      // 触发思考完成事件
+      if (this._framework) {
+        this._framework.emit('think:thought_completed', thought)
+      }
+
+      return {
+        success: true,
+        thought,
+        message: `【主动思考完成】\n模式: ${mode}\n主题: ${topic}\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`
+      }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * 构建反思提示
+   */
+  _buildReflectPrompt(mode, depth, topic) {
+    const depthDesc = {
+      1: '快速检视',
+      2: '简单反思',
+      3: '深入思考',
+      4: '批判性分析',
+      5: '全面审视'
+    }
+
+    const modePrompts = {
+      reflect: `你刚刚完成了一次对话。请${depthDesc[depth]}：
+
+1. 检查回答是否完整、准确
+2. 是否有遗漏的重要信息
+3. 是否有更好的表达方式
+4. 是否需要补充示例或细节
+
+${topic ? `额外关注: ${topic}` : ''}
+
+请直接输出你的反思结果，不需要重复之前的对话内容。`,
+
+      brainstorm: `请进行头脑风暴，针对以下主题产生更多想法：
+
+${topic || '刚才讨论的内容'}
+
+产生至少 3-5 个新的观点或方向，不必拘泥于之前讨论的内容。`,
+
+      analyze: `请对以下主题进行深度分析：
+
+${topic || '刚才讨论的内容'}
+
+分析要点：
+- 根本原因是什么？
+- 有哪些支持/反对的证据？
+- 可能的发展方向？`,
+
+      plan: `基于目前的讨论，请制定下一步计划：
+
+${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秒内不重复反思
+      }
+
+      const agent = this._getActiveAgent()
+      if (!agent) return
+
+      // 构建轻量级反思
+      const reflectPrompt = `作为助手，请快速检视刚才的回答是否：
+1. 完整回答了用户的问题
+2. 表达清晰易懂
+3. 有没有遗漏关键信息
+
+如果发现不足，请直接补充。如果没问题，请简短回复"检查完毕，无需补充"。`
+
+      // 静默思考，不打断用户
+      const result = await agent.pushMessage(reflectPrompt)
+
+      const thought = {
+        id: Date.now(),
+        mode: 'auto-reflect',
+        topic: '自动检视',
+        result: typeof result === 'string' ? result : '反思完成',
+        timestamp: new Date(),
+        auto: true
+      }
+
+      this._thoughts.push(thought)
+
+      // 如果反思有重要补充，触发事件通知
+      if (typeof result === 'string' && result.includes('补充') && !result.includes('无需补充')) {
+        this._framework.emit('think:reflection_needs_attention', {
+          thought,
+          originalData: data
+        })
+      }
+    } catch (err) {
+      log.error(' Auto-reflect error:', err.message)
+    }
+  }
+
+  /**
+   * 启动持续思考模式
+   */
+  async _startContinuousThinking(args) {
+    if (this._continuousMode) {
+      return { success: false, error: 'Continuous thinking already running' }
+    }
+
+    const interval = args.interval || 30000
+    const topic = args.topic || '基于最近的对话，还有什么值得深入思考的方向？'
+
+    this._continuousMode = true
+    this._continuousTopic = topic
+
+    const runThink = async () => {
+      if (!this._continuousMode) return
+
+      try {
+        await this._triggerThinking({
+          topic: this._continuousTopic,
+          mode: 'reflect',
+          depth: 2
+        })
+
+        // 触发下一轮
+        if (this._continuousMode) {
+          this._continuousTimer = setTimeout(runThink, interval)
+        }
+      } catch (err) {
+        log.error(' Continuous think error:', err.message)
+      }
+    }
+
+    // 立即执行一次
+    await runThink()
+
+    return {
+      success: true,
+      message: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
+    }
+  }
+
+  /**
+   * 停止持续思考模式
+   */
+  _stopContinuousThinking() {
+    this._continuousMode = false
+    if (this._continuousTimer) {
+      clearTimeout(this._continuousTimer)
+      this._continuousTimer = null
+    }
+    return {
+      success: true,
+      message: '持续思考已停止'
+    }
+  }
+
+  /**
+   * 获取当前活跃的 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]
+        if (agent.getStatus() === 'idle') {
+          return agent
+        }
+      }
+    }
+    return null
+  }
+
+  /**
+   * 获取待处理的反思通知
+   */
+  getPendingThoughts() {
+    return this._thoughts.slice(-10).reverse()
+  }
+
+  reload(framework) {
+    this._framework = framework
+  }
+
+  uninstall(framework) {
+    this._stopContinuousThinking()
+    this._thoughts = []
+    this._reflectionChain = []
+    this._framework = null
+  }
+}
+
+module.exports = { ThinkPlugin }