foliko 2.0.20 → 2.0.22

package/tests/core/dedupe-tool-call-ids.test.js

@@ -0,0 +1,260 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+// 测试 chat.js 的 _dedupeToolCallIds 私有方法
+// 通过 require + 拿到 AgentChatHandler 类的 prototype
+
+const { z } = require('zod');
+const { AgentChatHandler } = require('../../src/agent/chat.js');
+
+function makeHandler() {
+  // 最小化构造，跳过框架依赖
+  const handler = Object.create(AgentChatHandler.prototype);
+  return handler;
+}
+
+describe('_dedupeToolCallIds 私有方法', () => {
+  let handler;
+  beforeEach(() => {
+    handler = makeHandler();
+  });
+
+  it('空数组返回 0', () => {
+    expect(handler._dedupeToolCallIds([])).toBe(0);
+  });
+
+  it('非数组输入返回 0', () => {
+    expect(handler._dedupeToolCallIds(null)).toBe(0);
+    expect(handler._dedupeToolCallIds(undefined)).toBe(0);
+  });
+
+  it('没有重复时返回 0（保持原样）', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'call_A_1', toolName: 'read', input: {} },
+          { type: 'tool-call', toolCallId: 'call_B_1', toolName: 'write', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'call_A_1', toolName: 'read', output: { type: 'text', value: 'ok' } },
+          { type: 'tool-result', toolCallId: 'call_B_1', toolName: 'write', output: { type: 'text', value: 'ok' } },
+        ],
+      },
+    ];
+    expect(handler._dedupeToolCallIds(messages)).toBe(0);
+    expect(messages[0].content[0].toolCallId).toBe('call_A_1');
+    expect(messages[0].content[1].toolCallId).toBe('call_B_1');
+  });
+
+  it('★ 关键：去重重复的 tool-call ID + 同步 result', () => {
+    // 模拟真实场景：DeepSeek 在不同 LLM 调用中为相同 tool 生成相同 ID
+    const messages = [
+      // 第 1 轮：assistant 调 schedule_list，ID = X
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'first' } },
+        ],
+      },
+      // 第 2 轮：assistant 又调 schedule_list，ID 还是 X（DeepSeek 复用）
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'second' } },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBe(2);  // 1 个 call + 1 个 result 改名
+
+    // 第 1 轮的 call/result 保持原 ID
+    expect(messages[0].content[0].toolCallId).toBe('h_call_function_t08sdzj01nre_1');
+    expect(messages[1].content[0].toolCallId).toBe('h_call_function_t08sdzj01nre_1');
+
+    // 第 2 轮的 call/result 被改名
+    expect(messages[2].content[0].toolCallId).toMatch(/^h_call_function_t08sdzj01nre_1_dup\d+_\d+$/);
+    expect(messages[3].content[0].toolCallId).toBe(messages[2].content[0].toolCallId);
+  });
+
+  it('同一 assistant 消息里有多个 call，且都重复', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+          { type: 'tool-call', toolCallId: 'h_X_2', toolName: 'b', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+          { type: 'tool-result', toolCallId: 'h_X_2', toolName: 'b', output: {} },
+        ],
+      },
+      // 第二轮同样的两个 call
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+          { type: 'tool-call', toolCallId: 'h_X_2', toolName: 'b', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+          { type: 'tool-result', toolCallId: 'h_X_2', toolName: 'b', output: {} },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBe(4);
+
+    // 第一轮保留
+    expect(messages[0].content[0].toolCallId).toBe('h_X_1');
+    expect(messages[0].content[1].toolCallId).toBe('h_X_2');
+
+    // 第二轮都改名
+    expect(messages[2].content[0].toolCallId).not.toBe('h_X_1');
+    expect(messages[2].content[1].toolCallId).not.toBe('h_X_2');
+    expect(messages[2].content[0].toolCallId).toMatch(/dup/);
+    expect(messages[2].content[1].toolCallId).toMatch(/dup/);
+    // 第二轮的两个 call 改名后仍不同
+    expect(messages[2].content[0].toolCallId).not.toBe(messages[2].content[1].toolCallId);
+
+    // 第二轮的 result 跟随同名 call
+    expect(messages[3].content[0].toolCallId).toBe(messages[2].content[0].toolCallId);
+    expect(messages[3].content[1].toolCallId).toBe(messages[2].content[1].toolCallId);
+  });
+
+  it('★ 真实场景模拟：weixin jsonl 文件中的重复 ID', () => {
+    // 模拟用户报告的真实场景：
+    // 3 个"对话"（conv 2、3、4）都有相同的 tool-call ID
+    // getBranch(leafId) 会把它们都装进 messages 数组
+    const messages = [
+      { role: 'user', content: 'conv 2 user' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', input: { path: '/app/.foliko/skills/takumi-card' } },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'A' } },
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', output: { type: 'text', value: 'A' } },
+        ],
+      },
+      { role: 'user', content: 'conv 3 user' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', input: { path: '/app/.foliko/skills/takumi-card' } },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'B' } },
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', output: { type: 'text', value: 'B' } },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    // 2 个 call (conv 3) + 2 个 result (conv 3) = 4
+    expect(fixed).toBe(4);
+
+    // 收集所有 call IDs
+    const callIds = new Set();
+    for (const m of messages) {
+      if (m.role === 'assistant') {
+        for (const c of m.content) {
+          if (c.type === 'tool-call') callIds.add(c.toolCallId);
+        }
+      }
+    }
+    // 期望：4 个 call 都是不同的 ID（2 原始 + 2 改名）
+    expect(callIds.size).toBe(4);
+
+    // 收集所有 result IDs
+    const resultIds = new Set();
+    for (const m of messages) {
+      if (m.role === 'tool') {
+        for (const c of m.content) {
+          if (c.type === 'tool-result') resultIds.add(c.toolCallId);
+        }
+      }
+    }
+    expect(resultIds.size).toBe(4);
+
+    // ★ 关键：每个 result 都能在 call 中找到匹配
+    for (const resultId of resultIds) {
+      expect(callIds.has(resultId)).toBe(true);
+    }
+  });
+
+  it('部分 result 缺失也能正确处理（不影响已有配对）', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+        ],
+      },
+      // 没有 result（模拟加载时被截断）
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBeGreaterThan(0);
+
+    // 第一个 call 保留，第二个改名
+    expect(messages[0].content[0].toolCallId).toBe('h_X_1');
+    expect(messages[1].content[0].toolCallId).toMatch(/dup/);
+    // 最后一个 result 还是匹配第一个 call（因为它出现在第一个 call 之后）
+    // 实际上看 _renameFollowingToolResult 的实现：它从 afterMsgIdx 之后找，
+    // 所以 [0] call 后的 result 是 [2] tool message 的 [0]，会被改成第一个 call 的 ID
+    // 但第一个 call 已经是原始 ID，所以 result 也是原始 ID
+    // 这里我们只检查 IDs 都不重复
+    const ids = new Set();
+    for (const m of messages) {
+      for (const c of m.content || []) {
+        if (c.toolCallId) ids.add(c.toolCallId);
+      }
+    }
+    expect(ids.size).toBe(2);
+  });
+});

package/tests/core/edit-file.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FileSystemPlugin = require('../../plugins/io/file-system/index.js');
+
+let tempDir, framework, tool;
+let fileSystem;
+
+beforeEach(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-test-'));
+  fs.writeFileSync(path.join(tempDir, 'sample.js'),
+    'function hello() {\n  console.log("hello world");\n  return 42;\n}\n');
+
+  const registeredTools = [];
+  framework = {
+    getCwd: () => tempDir,
+    registerTool: (t) => registeredTools.push(t),
+    pluginManager: { get: () => null },
+    toolRegistry: { has: () => false, register: (t) => registeredTools.push(t) },
+  };
+  const p = new FileSystemPlugin();
+  p.install(framework);
+  tool = registeredTools.find(t => t.name === 'edit' || t.name === 'edit_file');
+  if (!tool) throw new Error('edit tool not registered');
+});
+
+afterEach(() => {
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('edit/edit_file 工具 (frs-replace 实现)', () => {
+  it('★ 基础：单次字面量替换', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'hello world', newText: 'goodbye universe' }],
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.appliedEdits).toBe(1);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(newContent).toContain('goodbye universe');
+    expect(newContent).not.toContain('hello world');
+  });
+
+  it('★ 多次替换按顺序应用', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [
+        { oldText: 'function hello', newText: 'function greet' },
+        { oldText: 'console.log', newText: 'console.warn' },
+      ],
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.appliedEdits).toBe(2);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(newContent).toContain('function greet()');
+    expect(newContent).toContain('console.warn');
+  });
+
+  it('★ 关键：找不到 oldText 报错（不再静默不生效）', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'NOT_EXISTING_TEXT_XYZ', newText: 'foo' }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('替换未生效');
+    expect(r.error).toContain('找不到');
+  });
+
+  it('★ useRegex=true 支持正则匹配', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{
+        oldText: '\\b\\w+\\(\\)',  // 匹配 "函数名()"
+        newText: 'fn()',
+        useRegex: true,
+      }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    // hello() → fn() 但 greet() 也会变（多匹配中第一个）
+    expect(newContent).toContain('fn()');
+  });
+
+  it('★ useRegex=true 无效正则报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: '[invalid(', newText: 'X', useRegex: true }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('无效的正则');
+  });
+
+  it('★ useRegex=true 多次出现都被替换（默认）', async () => {
+    fs.writeFileSync(path.join(tempDir, 'multi.txt'), 'foo foo foo bar foo');
+    const r = await tool.execute({
+      path: 'multi.txt',
+      edits: [{ oldText: 'foo', newText: 'BAZ', useRegex: true }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'multi.txt'), 'utf8');
+    expect(newContent).toBe('BAZ BAZ BAZ bar BAZ');
+  });
+
+  it('★ allOccurrences=false 只替换第一个', async () => {
+    fs.writeFileSync(path.join(tempDir, 'multi.txt'), 'foo foo foo bar foo');
+    const r = await tool.execute({
+      path: 'multi.txt',
+      edits: [{ oldText: 'foo', newText: 'BAZ', allOccurrences: false }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'multi.txt'), 'utf8');
+    expect(newContent).toBe('BAZ foo foo bar foo');
+  });
+
+  it('★ 多 edit 中第二个找不到：报错且不应用第一个', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [
+        { oldText: 'function hello', newText: 'function greet' },     // 找得到
+        { oldText: 'NOT_EXISTING', newText: 'foo' },                 // 找不到
+      ],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('edits[1]');
+    // ★ 验证第一个 edit 也没应用（避免部分应用）
+    const content = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(content).toContain('function hello');
+    expect(content).not.toContain('function greet');
+  });
+
+  it('★ 文件不存在报错', async () => {
+    const r = await tool.execute({
+      path: 'nonexistent.js',
+      edits: [{ oldText: 'foo', newText: 'bar' }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('读取文件失败');
+  });
+
+  it('★ edits 是空数组报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [],
+    }, framework);
+    expect(r.success).toBe(false);
+  });
+
+  it('★ edits[i].oldText 是空字符串报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: '', newText: 'foo' }],
+    }, framework);
+    expect(r.success).toBe(false);
+  });
+
+  it('★ 原子写入：失败时不留 .tmp 垃圾', async () => {
+    // 模拟：先创建 .tmp 但删除 source file 让 rename 失败
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'function hello', newText: 'function greet' }],
+    }, framework);
+    expect(r.success).toBe(true);
+    // 检查没有遗留 .tmp
+    const files = fs.readdirSync(tempDir);
+    expect(files.some(f => f.endsWith('.tmp'))).toBe(false);
+  });
+
+  it('★ edit_file 是 edit 的别名（同实现）', async () => {
+    // 找到 edit_file 工具
+    const p = new FileSystemPlugin();
+    p.install(framework);
+    const editFileTool = p._registeredTools?.find(t => t.name === 'edit_file')
+      || (p._registeredTools || []).find(t => t.name === 'edit_file');
+    // 由于 install 重新注册，p._registeredTools 是空（mock 没捕获 Plugin base class 的 _registeredTools）
+    // 重新调用 install 让 mock 捕获
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'function hello', newText: 'function greet' }],
+    }, framework);
+    expect(r.success).toBe(true);
+  });
+
+  it('★ 返回元数据：contentLength before/after', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'hello world', newText: 'X' }],  // 11 → 1
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.contentLength.before).toBeGreaterThan(r.data.contentLength.after);
+    expect(r.data.contentChanged).toBe(true);
+  });
+});

package/tests/core/ext-call-empty-args.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+const { z } = require('zod');
+const ExtensionExecutorPlugin = require('../../plugins/executors/extension/index.js');
+
+function makePlugin(tools = {}) {
+  const p = Object.create(ExtensionExecutorPlugin.prototype);
+  p._framework = {
+    emit: () => {},
+    pluginManager: { get: () => null },
+  };
+  p._registry = {
+    getPlugin(name) {
+      if (tools[name]) return { name, tools: tools[name].tools || [] };
+      return null;
+    },
+    getTool: () => null,
+  };
+  return p;
+}
+
+describe('_emptyArgsError 专门处理 args={} 的情况', () => {
+  it('★ 关键：args={} + 工具必填 id → 返回明确错误提示用 ext_skill', () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+        title: z.string().optional(),
+      }),
+      execute: async () => 'ok',
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    // 新签名：(plugin, tool, toolArgs, toolDef, zodError)
+    const r = p._emptyArgsError('skill:creator', 'addCover', {}, addCoverTool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('参数缺失');
+    expect(r.error).toContain('args 为空对象');
+    expect(r.receivedArgs).toEqual({});
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.hint).toContain('ext_skill');
+    expect(r.hint).toContain('id');  // 必填字段应被提及
+  });
+
+  it('★ 关键：从 zodError.issues 提取必填字段（即使 schema shape 解析失败）', () => {
+    const tool = {
+      name: 'foo',
+      inputSchema: z.object({ x: z.string(), y: z.string(), z: z.string().optional() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('plugin', 'foo', {}, tool, {
+      issues: [
+        { path: ['x'], message: 'Required' },
+        { path: ['y'], message: 'Required' },
+      ],
+    });
+    expect(r.hint).toContain('x');
+    expect(r.hint).toContain('y');
+    expect(r.hint).not.toContain('z');  // z 是 optional，不应被提及
+  });
+
+  it('★ 关键：error 中要明确"为什么失败"和"如何修复"', () => {
+    const tool = {
+      name: 'publish',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('skill:baidu', 'publish', {}, tool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    // 错误信息要包含可操作的具体指引
+    expect(r.error).toMatch(/参数缺失.*publish/);
+    expect(r.hint).toMatch(/ext_skill.*plugin.*必填字段/);
+  });
+});
+
+describe('_doExecute 集成：空 args 走特殊错误路径', () => {
+  it('★ 关键：ext_call({plugin, tool, args:{}}) → 返回 emptyArgsError', async () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+      }),
+      execute: async (args) => {
+        if (!args.id) throw new Error('视频项目不存在: undefined');
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', {});
+    expect(r.success).toBe(false);
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.error).toContain('参数缺失');
+    expect(r.hint).toContain('ext_skill');
+  });
+
+  it('★ 关键：ext_call({plugin, tool, args: {id: "abc"}}) → 正常执行', async () => {
+    let receivedArgs = null;
+    const tool = {
+      name: 'addCover',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async (args) => {
+        receivedArgs = args;
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [tool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', { id: 'abc' });
+    expect(r.success).toBe(true);
+    expect(receivedArgs).toEqual({ id: 'abc' });
+  });
+});
+
+describe('ext_call 工具描述', () => {
+  it('★ 描述里必须强调 args 必填 + 工作流（先 ext_skill）', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    expect(extCall.description).toContain('args');
+    expect(extCall.description).toContain('必填');
+    expect(extCall.description).toContain('ext_skill');
+    // 给具体的多参数示例
+    expect(extCall.description).toMatch(/id:\s*['"]/);
+  });
+
+  it('★ inputSchema.args.description 必须强调"先查 ext_skill"', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    const argDesc = extCall.inputSchema.shape.args.description;
+    expect(argDesc).toContain('必填');
+    expect(argDesc).toContain('ext_skill');
+  });
+});