foliko 1.1.4 → 1.1.5

package/cli/src/commands/chat.js

@@ -63,7 +63,12 @@ function parseArgs(args) {
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === '--model' && args[i + 1]) {
+    if (arg === '-c' || arg === '--continue' || arg === '--continuous') {
+      // 持续测试模式：传入 'sessionId:command1|command2|command3'
+      // 或 command1|command2|command3 (使用默认 sessionId)
+      options.continuous = true;
+      options.commandSequence = args[++i] || '';
+    } else if (arg === '--model' && args[i + 1]) {
       options.model = args[++i];
     } else if (arg === '--provider' && args[i + 1]) {
       options.provider = args[++i];
@@ -75,6 +80,10 @@ function parseArgs(args) {
       options.stream = true;
     } else if (arg === '--no-stream') {
       options.stream = false;
+    } else if (arg === '--clear') {
+      options.clearSession = true;
+    } else if (arg === '--session' && args[i + 1]) {
+      options.sessionId = args[++i];
     }
   }
 
@@ -86,6 +95,59 @@ function parseArgs(args) {
   return options;
 }
 
+/**
+ * 持续测试模式：自动发送多条消息进行测试
+ */
+async function runContinuousTest(agent, options) {
+  const sessionId = options.sessionId || 'cli_default';
+  const commands = options.commandSequence.split('|').filter((c) => c.trim());
+
+  if (commands.length === 0) {
+    console.log('错误：-c 参数需要提供命令序列，格式：command1|command2|command3');
+    process.exit(1);
+  }
+
+  console.log('=== 持续测试模式 ===');
+  console.log(`Session: ${sessionId}`);
+  console.log(`命令数量: ${commands.length}`);
+  console.log('');
+
+  const runWithContext = agent.framework?.runWithContext.bind(agent.framework);
+
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    console.log(`\n[${i + 1}/${commands.length}] >>> ${cmd}`);
+    console.log('-'.repeat(50));
+
+    try {
+      let fullResponse = '';
+      await runWithContext({ sessionId }, async () => {
+        for await (const chunk of agent.chatStream(cmd, { sessionId })) {
+          if (chunk.type === 'text') {
+            fullResponse += chunk.text;
+            process.stdout.write(chunk.text);
+          } else if (chunk.type === 'tool-call') {
+            console.log(`\n[工具调用] ${chunk.toolName}  ${JSON.stringify(chunk.input)}`);
+          } else if (chunk.type === 'error') {
+            console.error(`\n[错误] ${chunk.error}`);
+          }
+        }
+      });
+      console.log('\n' + '-'.repeat(50));
+      console.log(`[完成] 回复长度: ${fullResponse.length}`);
+    } catch (err) {
+      console.error(`\n[执行错误] ${err.message}`);
+      // 继续执行下一条命令
+    }
+
+    // 命令间隔 1 秒
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+
+  console.log('\n=== 测试完成 ===');
+  console.log(`共执行 ${commands.length} 条命令`);
+}
+
 /**
  * Chat 命令入口
  */
@@ -127,6 +189,12 @@ async function chatCommand(args) {
 - 禁止添加 -g 参数
 - 例如：npx skills add xxx 应该执行为 npx skills add xxx -a openclaw -y`);
 
+  // 持续测试模式
+  if (options.continuous) {
+    await runContinuousTest(agent, options);
+    return;
+  }
+
   // 初始化 UI
   const ui = new ChatUI(agent, { stream: options.stream });
 

package/cli/src/index.js

@@ -12,12 +12,21 @@ const path = require('path');
  */
 async function cli() {
   const args = process.argv.slice(2);
-  const command = args[0] || 'chat';
+  let command = args[0] || 'chat';
   const packageJsonPath = path.join(__dirname, '../../package.json');
 
+  // 如果第一个参数看起来像选项而不是命令，说明用户直接运行 "npm run chat -c ..."
+  // 把命令设为 'chat'，所有参数都传给 chat 命令
+  if (command && command.startsWith('-')) {
+    command = 'chat';
+  }
+
   switch (command) {
     case 'chat':
-      await chatCommand(args.slice(1));
+      // 如果第一个参数是选项（如 -c），args 已经是传给 chat 的参数
+      // 如果第一个参数是 'chat'，需要 slice(1) 去掉 'chat'
+      const chatArgs = args[0] === 'chat' ? args.slice(1) : args;
+      await chatCommand(chatArgs);
       break;
 
     case 'list':

package/package.json

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

package/plugins/extension-executor-plugin.js

@@ -133,15 +133,29 @@ class ExtensionExecutorPlugin extends Plugin {
       }),
       execute: async (args) => {
         const { plugin, tool, args: toolArgs = {} } = args;
-        log.info(` ext_call: plugin=${plugin}, tool=${tool}`);
+        log.info(` ext_call: plugin=${plugin}, tool=${tool}, args=${JSON.stringify(toolArgs)}`);
 
         const ext = this._extensions.get(plugin);
         if (!ext) {
+          // 触发错误事件
+          framework.emit('tool:error', {
+            name: `${plugin}:${tool}`,
+            args: toolArgs,
+            error: `扩展插件 '${plugin}' 不存在`,
+            source: 'extension'
+          });
           return { success: false, error: `扩展插件 '${plugin}' 不存在` };
         }
 
         const toolDef = ext.tools.find((t) => t.name === tool);
         if (!toolDef) {
+          // 触发错误事件
+          framework.emit('tool:error', {
+            name: `${plugin}:${tool}`,
+            args: toolArgs,
+            error: `扩展工具 '${tool}' 不存在`,
+            source: 'extension'
+          });
           return { success: false, error: `扩展工具 '${tool}' 不存在` };
         }
 
@@ -161,6 +175,18 @@ class ExtensionExecutorPlugin extends Plugin {
           // 统一 execute 签名为 (args, framework)
           const result = await toolDef.execute(toolArgs, framework);
 
+          // 检查结果是否为错误
+          if (result && result.success === false && result.error) {
+            // 触发扩展工具错误事件
+            framework.emit('tool:error', {
+              name: `${plugin}:${tool}`,
+              args: toolArgs,
+              error: result.error,
+              source: 'extension'
+            });
+            return result;
+          }
+
           // 触发扩展工具完成事件
           framework.emit('tool:result', {
             name: `${plugin}:${tool}`,

package/plugins/memory-plugin.js

@@ -10,7 +10,7 @@ const { z } = require('zod')
 const fs = require('fs')
 const path = require('path')
 const { EventEmitter } = require('events')
-
+const {cleanResponse} =require('../src/utils')
 /**
  * 记忆类型常量
  */
@@ -147,44 +147,60 @@ function _extractJSON(text) {
 
   // 去掉首尾空白
   text = text.trim()
-  if (!text.startsWith('{')) return null
 
-  // 查找配对的括号位置
-  let braceCount = 0
-  let inString = false
-  let escaped = false
+  // 方法1：如果直接以 { 开头，尝试直接解析
+  if (text.startsWith('{')) {
+    // 查找配对的括号位置
+    let braceCount = 0
+    let inString = false
+    let escaped = false
 
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i]
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i]
 
-    if (escaped) {
-      escaped = false
-      continue
-    }
+      if (escaped) {
+        escaped = false
+        continue
+      }
 
-    if (char === '\\' && inString) {
-      escaped = true
-      continue
-    }
+      if (char === '\\' && inString) {
+        escaped = true
+        continue
+      }
 
-    if (char === '"') {
-      inString = !inString
-      continue
-    }
+      if (char === '"') {
+        inString = !inString
+        continue
+      }
 
-    if (!inString) {
-      if (char === '{') {
-        braceCount++
-      } else if (char === '}') {
-        braceCount--
-        if (braceCount === 0) {
-          // 找到完整的 JSON 对象
-          return text.substring(0, i + 1)
+      if (!inString) {
+        if (char === '{') {
+          braceCount++
+        } else if (char === '}') {
+          braceCount--
+          if (braceCount === 0) {
+            return text.substring(0, i + 1)
+          }
         }
       }
     }
   }
 
+  // 方法2：从 thinking 文本中查找 JSON（处理 AI 输出 thinking 的情况）
+  // 查找最后一个 { 到最后一个 } 之间的内容
+  const firstBrace = text.indexOf('{')
+  const lastBrace = text.lastIndexOf('}')
+
+  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+    const potential = text.substring(firstBrace, lastBrace + 1)
+    try {
+      JSON.parse(potential) // 验证是否是有效 JSON
+      return potential
+    } catch (e) {
+      // 不是有效 JSON，继续尝试其他方法
+    }
+  }
+
   return null
 }
 
@@ -793,6 +809,144 @@ class MemoryPlugin extends Plugin {
         log.warn('Auto memory extraction failed:', err.message)
       }
     })
+
+    // 监听所有工具调用错误（包括 ext_call, MCP, 原生工具等）
+    framework.on('tool:error', async (data) => {
+      try {
+        await this._extractErrorLesson({
+          name: data.name || data.tool || 'unknown-tool',
+          args: data.args || {},
+          error: data.error || data.message || String(data),
+          source: data.source || 'tool'
+        })
+      } catch (err) {
+        log.warn('Auto tool error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 tool-call 别名（AI SDK 6.x 格式）
+    framework.on('tool-error', async (data) => {
+      try {
+        await this._extractErrorLesson({
+          name: data.name || data.tool || 'unknown-tool',
+          args: data.args || {},
+          error: data.error || data.message || String(data),
+          source: data.source || 'tool'
+        })
+      } catch (err) {
+        log.warn('Auto tool-error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听工具重试事件（重试可能意味着配置或参数问题）
+    framework.on('tool:retry', async (data) => {
+      try {
+        const { name, args, error, attempt } = data
+        await this._extractErrorLesson({
+          name: name || 'unknown-tool',
+          args: args || {},
+          error: `Retry attempt ${attempt} failed: ${error || data.message || 'unknown'}`,
+          source: 'tool-retry'
+        })
+      } catch (err) {
+        log.warn('Auto tool retry lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 agent 对话过程中的错误
+    framework.on('error', async (data) => {
+      try {
+        const errorObj = typeof data === 'object' ? data : { error: String(data) }
+        await this._extractErrorLesson({
+          name: errorObj.context || 'agent-error',
+          args: errorObj.data || {},
+          error: errorObj.error || errorObj.message || String(data),
+          source: 'agent'
+        })
+      } catch (err) {
+        log.warn('Auto agent error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 agent status 错误
+    framework.on('status', async (data) => {
+      if (data.status === 'error' && data.error) {
+        try {
+          await this._extractErrorLesson({
+            name: 'agent-status-error',
+            args: {},
+            error: data.error,
+            source: 'agent-status'
+          })
+        } catch (err) {
+          log.warn('Auto status error lesson extraction failed:', err.message)
+        }
+      }
+    })
+
+    // 监听会话上下文错误
+    framework.on('session:context-destroyed', async (data) => {
+      // 上下文销毁通常是正常的，但如果有错误信息则记录
+      if (data && data.error) {
+        try {
+          await this._extractErrorLesson({
+            name: 'session-context-error',
+            args: { sessionId: data.sessionId },
+            error: data.error,
+            source: 'session'
+          })
+        } catch (err) {
+          log.warn('Auto session error lesson extraction failed:', err.message)
+        }
+      }
+    })
+  }
+
+  /**
+   * 从错误中提取经验教训并保存
+   */
+  async _extractErrorLesson(errorData) {
+    const { name, args, error, source } = errorData
+
+    // 构建提取提示 - 强调"如何下次避免"
+    const extractPrompt = `你是一个经验总结专家。请分析以下错误，总结如何在未来避免类似错误。
+
+错误信息：
+- 工具名称: ${name}
+- 调用参数: ${JSON.stringify(args)}
+- 错误原因: ${error}
+- 来源: ${source || 'unknown'}
+
+请按以下格式返回（仅返回 JSON，不要有其他内容）：
+{
+  "extract": true/false,
+  "name": "【避免指南】具体说明避免什么（如：避免不传 plugin 参数调用 ext_call）",
+  "tags": ["error", "avoid", "${name}"],
+  "content": "以【下次这样做】为开头，说明正确的做法。例如：\n【下次这样做】调用 ext_call 时必须传入 plugin、tool、args 三个参数。错误原因：缺少 plugin 参数导致扩展插件无法定位。"
+}
+
+如果错误是无关紧要的（如用户主动取消、超时重试等），返回：
+{"extract": false}`
+
+    try {
+      const result = await this._runMemoryExtractionAgent(extractPrompt)
+
+      if (result && result.extract === true) {
+        try {
+          const saved = this._store.add({
+            name: result.name,
+            type: result.type || MEMORY_TYPES.FEEDBACK,
+            project: null,
+            tags: result.tags || ['error', 'avoid'],
+            body: result.content
+          })
+        } catch (saveErr) {
+          log.warn('[Memory] Failed to save error lesson:', saveErr.message)
+        }
+      }
+    } catch (err) {
+      log.warn('[Memory] Error lesson extraction failed:', err.message)
+    }
   }
 
   /**
@@ -870,16 +1024,18 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
 
       const { text } = await generateText({
         model: aiClient,
-        system: '你是一个记忆提取专家，直接返回 JSON，不要有其他内容。',
+        system: '你是一个记忆提取专家。直接返回 JSON 格式的答案，不要输出任何思考过程、解释或其他内容。格式：{"extract":true/false,"name":"...","tags":[...],"content":"..."}',
         prompt,
         maxTokens: 500,
         temperature: 0.3,
         maxSteps: 1
-      })
+      }).catch(err => {
+        return { text: null };
+      });
 
       // 解析 JSON 响应
       if (text) {
-        const cleanedText = text.trim()
+        const cleanedText = cleanResponse(text.trim())
 
         // 移除 markdown 代码块包裹
         let jsonText = cleanedText
@@ -955,13 +1111,22 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
     try {
       const userMemories = this._store.listByType(MEMORY_TYPES.USER, 10)
       const projectMemories = this._store.listByType(MEMORY_TYPES.PROJECT, 5)
+      const feedbackMemories = this._store.search('', { type: MEMORY_TYPES.FEEDBACK, tags: ['avoid'], limit: 10 })
 
-      if (userMemories.length === 0 && projectMemories.length === 0) {
+      if (userMemories.length === 0 && projectMemories.length === 0 && feedbackMemories.length === 0) {
         return null
       }
 
       const parts = ['【记忆上下文】']
 
+      // 错误避免指南（优先显示，放在最前面）
+      if (feedbackMemories.length > 0) {
+        parts.push('【错误避免指南 - 必须遵守】')
+        for (const m of feedbackMemories) {
+          parts.push(`- ${m.body}`)
+        }
+      }
+
       if (userMemories.length > 0) {
         parts.push('【用户偏好】')
         for (const m of userMemories) {