minimal-agent 0.13.0 → 0.15.0

package/plugins/workflow-runner/test/cli.e2e.test.ts

@@ -1,167 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/test/cli.e2e.test.ts
- * ------------------------------------------------------------
- *  最外层 CLI 端到端：拉子进程跑 `bun src/main.tsx -p "/workflow ..."`,
- *  验证 stdout / stderr / 退出码 / 文件副作用 全链路。
- *
- *  覆盖 3 个用例：
- *    1. golden path：/workflow cli-e2e --input topic=world → exit 0 + 文件落盘
- *    2. /workflows 列出 cli-e2e
- *    3. 缺必填 input → exit 1 + 错误信息含 "topic"
- *
- *  fake provider env：workflow 是 tool-only，永不调 API；fake env 仅满足
- *  main.tsx 的 provider 配置校验。
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-
-const REPO_ROOT = resolve(import.meta.dir, '..', '..', '..');
-const FIXTURE = join(import.meta.dir, 'fixtures', 'cli-e2e.yaml');
-const FIXTURE_ASK = join(import.meta.dir, 'fixtures', 'cli-ask-e2e.yaml');
-const FIXTURE_GREEDY = join(import.meta.dir, 'fixtures', 'greedy-e2e.yaml');
-
-const SPAWN_TIMEOUT = 60_000;
-
-interface SpawnResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}
-
-async function spawnMain(promptArg: string, cwd: string): Promise<SpawnResult> {
-  const proc = Bun.spawn(
-    ['bun', 'src/main.tsx', '-d', cwd, '-p', promptArg],
-    {
-      cwd: REPO_ROOT,
-      env: {
-        ...process.env,
-        MINIMAL_AGENT_BASE_URL: 'http://fake.invalid',
-        MINIMAL_AGENT_API_KEY: 'fake-key',
-        MINIMAL_AGENT_MODEL: 'fake-model',
-        MINIMAL_AGENT_CONTEXT_WINDOW: '128000',
-      },
-      stdout: 'pipe',
-      stderr: 'pipe',
-    },
-  );
-
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-
-  return { exitCode, stdout, stderr };
-}
-
-describe('CLI 端到端 /workflow（拉子进程跑 main.tsx）', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'cli-e2e-'));
-    mkdirSync(join(tmp, 'workflows'), { recursive: true });
-    copyFileSync(FIXTURE, join(tmp, 'workflows', 'cli-e2e.yaml'));
-    copyFileSync(FIXTURE_ASK, join(tmp, 'workflows', 'cli-ask-e2e.yaml'));
-    copyFileSync(FIXTURE_GREEDY, join(tmp, 'workflows', 'greedy-e2e.yaml'));
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it(
-    'golden path：跑完 + 文件落盘 + exit 0',
-    async () => {
-      const r = await spawnMain(
-        '/workflow cli-e2e --input topic=world',
-        tmp,
-      );
-      expect(r.exitCode).toBe(0);
-      const filePath = join(tmp, 'out', 'world', 'note.txt');
-      expect(existsSync(filePath)).toBe(true);
-      expect(readFileSync(filePath, 'utf8')).toBe('topic=world ok');
-    },
-    SPAWN_TIMEOUT,
-  );
-
-  it(
-    '/workflows 列出 cli-e2e',
-    async () => {
-      const r = await spawnMain('/workflows', tmp);
-      expect(r.exitCode).toBe(0);
-      expect(r.stdout).toContain('cli-e2e');
-    },
-    SPAWN_TIMEOUT,
-  );
-
-  it(
-    '缺必填 input → exit 1 + 错误信息含 "topic"',
-    async () => {
-      const r = await spawnMain('/workflow cli-e2e', tmp);
-      expect(r.exitCode).toBe(1);
-      expect(r.stderr).toContain('topic');
-    },
-    SPAWN_TIMEOUT,
-  );
-
-  // -p 非交互下「含 AskUserQuestion 的工作流」也能跑通：askBridge 自动选推荐项、不挂起。
-  // 这是 ppt 工作流 stage0「样式推荐」在 -p / 宿主 spawn 下自动兜底那条路径的最小复现。
-  it(
-    '含 AskUserQuestion 的工作流在 -p 下自动选推荐项、不挂起、跑完 exit 0',
-    async () => {
-      const r = await spawnMain('/workflow cli-ask-e2e', tmp);
-      expect(r.exitCode).toBe(0);
-      // askBridge 非交互兜底：自动选每题首项（推荐项），stderr 注记
-      expect(r.stderr).toContain('自动选推荐项');
-      // echo 文本经 text 事件 + 末尾 turn_done 正常回到 -p stdout
-      expect(r.stdout).toContain('ASK-E2E-DONE');
-    },
-    SPAWN_TIMEOUT,
-  );
-
-  // 贪婪首参：命令行里 workflow 名之后的整句（含空格分隔段）被 join 进首个 input，
-  // 不逐位拆映射、不撞后面的 number/enum 输入。这是 ppt「打一句话自然语言就能跑」
-  // 的根因修复——曾因严格 posN↔inputs[N] 把整句拆碎、pos2 撞 number 报「必须是数字」。
-  it(
-    'greedy 首参把整句位置参数 join 进首个 input（不拆碎、不撞类型）',
-    async () => {
-      const r = await spawnMain('/workflow greedy-e2e 收集 资料 浅色', tmp);
-      expect(r.exitCode).toBe(0);
-      // 三段位置参数被空格 join 还原成整句进 brief，echo 原样回显
-      expect(r.stdout).toContain('GREEDY-BRIEF=[收集 资料 浅色]');
-    },
-    SPAWN_TIMEOUT,
-  );
-
-  // B7：用户 shell 习惯写 --input brief=A B C（没加引号），shell 拆成 --input brief=A + B + C
-  // 三个 token；引擎识别为首参已由 --input 提供、但仍存在散落位置参数，按贪婪语义自动拼回，
-  // 不丢 B、C（之前 B/C 被当占位参数映射给后续非贪婪 input，或直接静默丢弃）。
-  it(
-    'B7：贪婪首参用 --input 提供但没加引号被拆 → 位置参数自动拼回首参',
-    async () => {
-      // 注意：命令字符串本身在这里是单条 input，但引擎 tokenize 后是:
-      //   [/workflow, greedy-e2e, --input, brief=做, 一个, 小玩具]
-      // 即 greedy-e2e 之后的内容中，--input brief=做 是首参赋值，「一个」「小玩具」
-      // 是被 shell-like 拆分出来的位置参数，B7 修复后必须自动拼回为「做 一个 小玩具」。
-      const r = await spawnMain('/workflow greedy-e2e --input brief=做 一个 小玩具', tmp);
-      expect(r.exitCode).toBe(0);
-      expect(r.stdout).toContain('GREEDY-BRIEF=[做 一个 小玩具]');
-      // 修复附带的用户提示：告诉用户下次记得加引号（-p 模式 warning 走 stderr 或 stdout 都算）
-      const combined = r.stdout + '\n' + r.stderr;
-      expect(combined).toContain('已自动拼回');
-    },
-    SPAWN_TIMEOUT,
-  );
-});

package/plugins/workflow-runner/test/context-files.test.ts

@@ -1,320 +0,0 @@
-/**
- * ============================================================
- *  test/context-files.test.ts —— ADR-05 阶段 4 miniReAct 验证
- * ------------------------------------------------------------
- *  覆盖 execLlmStep + miniReAct 子循环（context_files 路径）：
- *    case 1: 基本 Read 引用 — 第一轮 tool_call，第二轮纯文本收敛
- *    case 2: maxTurns 上限 — 永不收敛 → 抛错
- *    case 3: output_schema + tools 组合 — 走 [json+tools] 前缀
- *
- *  策略：
- *    - mock '../../../src/llm/client.js' → 按调用次数依次返回不同流
- *    - mock '../../../src/tools/index.js' → executeTool 返回固定内容；
- *      同时透传 ALL_TOOLS / getToolByName（llm.ts 还要靠 ALL_TOOLS 过滤白名单）
- *    - 不真跑 Read，避免文件系统耦合
- * ============================================================
- */
-
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  mock,
-} from 'bun:test';
-
-import type { Provider, Tool } from '../../../src/types.js';
-import { execLlmStep } from '../src/stepExecutors/llm.js';
-import { VarStack } from '../src/types.js';
-import type { RunContext, StepDef } from '../src/types.js';
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-/** execLlmStep 现为 AsyncGenerator：drain 取最终 return 值（yield 的事件直接丢弃）。 */
-async function drainLlm<R>(gen: AsyncGenerator<unknown, R, void>): Promise<R> {
-  let r = await gen.next();
-  while (!r.done) r = await gen.next();
-  return r.value;
-}
-
-// ---------------- mock 基础设施 ----------------
-
-interface ChatCallRecord {
-  messages: unknown[];
-  tools: unknown[];
-  responseFormat?: unknown;
-}
-
-/** 每次 chat() 调用记录的参数 */
-const capturedChatArgs: ChatCallRecord[] = [];
-/** mock 流脚本：每轮一个；用尽后报错（避免无限循环） */
-type MockTurn =
-  | { kind: 'text'; text: string }
-  | {
-      kind: 'tool_call';
-      callId: string;
-      name: string;
-      argsJson: string;
-      /** 该轮 assistant 同时附带的可选文本 */
-      text?: string;
-    };
-let mockTurns: MockTurn[] = [];
-let mockTurnIdx = 0;
-
-interface ExecuteToolCall {
-  name: string;
-  rawArguments: string;
-}
-const capturedExecuteToolCalls: ExecuteToolCall[] = [];
-/** mock executeTool 返回值脚本（按调用顺序）；用尽则回退到 { ok:true, content:'OK' } */
-let mockToolResults: Array<
-  { ok: true; content: string } | { ok: false; error: string }
-> = [];
-
-import { chat as realChatImport } from '../../../src/llm/client.js';
-// 复用真实的 ALL_TOOLS / getToolByName（llm.ts 的白名单过滤要用），
-// 只把 executeTool 替换成 mock 版本。
-//
-// 注：bun 的 mock.module 是 process-global 且无内建 restore。即便其它文件的
-// 测试 case 没被本文件触发，只要 top-level 执行了 mock.module，整个进程的
-// 模块解析就被替换了。所以放在 beforeAll/afterAll 内成对挂钩，确保最小作用域。
-import {
-  ALL_TOOLS as REAL_ALL_TOOLS,
-  executeTool as realExecuteTool,
-  getToolByName as realGetToolByName,
-} from '../../../src/tools/index.js';
-
-// 在 mock 安装前把真实 chat 函数引用拷到值变量，避免 ESM live binding
-// 在 mock.module 后跟着变成 mock 版本（afterAll 复原才能拿到真函数）
-const ORIGINAL_CHAT = realChatImport;
-const ORIGINAL_EXECUTE_TOOL = realExecuteTool;
-
-beforeAll(() => {
-  installChatMock();
-  mock.module('../../../src/tools/index.js', () => ({
-    ALL_TOOLS: REAL_ALL_TOOLS,
-    getToolByName: realGetToolByName,
-    executeTool: async (name: string, rawArguments: string) => {
-      capturedExecuteToolCalls.push({ name, rawArguments });
-      const next = mockToolResults.shift();
-      return next ?? { ok: true, content: 'OK' };
-    },
-  }));
-});
-
-afterAll(() => {
-  // 复原 chat 为真实实现，避免污染下游 e2e / runner 等不 mock chat 的测试文件
-  // 必须用 ORIGINAL_CHAT（mock 前抓到的值快照），不能用 realChatImport（已被 mock 替换的 live binding）
-  mock.module('../../../src/llm/client.js', () => ({ chat: ORIGINAL_CHAT }));
-  // 复原 executeTool 为真实实现
-  mock.module('../../../src/tools/index.js', () => ({
-    ALL_TOOLS: REAL_ALL_TOOLS,
-    getToolByName: realGetToolByName,
-    executeTool: ORIGINAL_EXECUTE_TOOL,
-  }));
-});
-
-// chat mock 也放进 beforeAll，避免 top-level 副作用污染其它文件
-function installChatMock(): void {
-  mock.module('../../../src/llm/client.js', () => ({
-    chat: async function* (args: ChatCallRecord) {
-      capturedChatArgs.push({
-        messages: args.messages,
-        tools: args.tools,
-        responseFormat: args.responseFormat,
-      });
-      const turn = mockTurns[mockTurnIdx];
-      mockTurnIdx++;
-      if (!turn) {
-        throw new Error(
-          `mock chat: 用尽脚本（共 ${mockTurns.length} 轮，调用第 ${mockTurnIdx} 次）`,
-        );
-      }
-      if (turn.kind === 'text') {
-        yield { type: 'text_delta', delta: turn.text };
-      } else {
-        if (turn.text) yield { type: 'text_delta', delta: turn.text };
-        yield {
-          type: 'tool_call_delta',
-          index: 0,
-          id: turn.callId,
-          name: turn.name,
-          argumentsDelta: turn.argsJson,
-        };
-      }
-      yield {
-        type: 'done',
-        stopReason: turn.kind === 'tool_call' ? 'tool_calls' : 'stop',
-      };
-    },
-  }));
-}
-
-// ---------------- 测试 ----------------
-
-describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    capturedChatArgs.length = 0;
-    capturedExecuteToolCalls.length = 0;
-    mockTurns = [];
-    mockTurnIdx = 0;
-    mockToolResults = [];
-    ctx = {
-      provider: fakeProvider,
-      history: [],
-      cwd: process.cwd(),
-      tools: [],
-    };
-  });
-
-  it('pure llm 不下发工具，避免单轮设计类步骤误调工具后撞 maxTurns=1', async () => {
-    mockTurns = [{ kind: 'text', text: 'design doc' }];
-
-    const step: StepDef = {
-      id: 'pure-design',
-      llm: 'please design',
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-
-    expect(result.raw).toEqual({ text: 'design doc', result: 'design doc' });
-    expect(capturedChatArgs.length).toBe(1);
-    expect(capturedChatArgs[0].tools).toEqual([]);
-  });
-
-  it('case 1: 基本 Read 引用 — tool_call 一轮 + 纯文本一轮', async () => {
-    ctx.tools = [{ name: 'Read' } as Tool];
-    mockTurns = [
-      {
-        kind: 'tool_call',
-        callId: 'call_1',
-        name: 'Read',
-        argsJson: '{"file_path":"/tmp/x.txt"}',
-      },
-      { kind: 'text', text: 'got it' },
-    ];
-    mockToolResults = [{ ok: true, content: 'file content here' }];
-
-    const step: StepDef = {
-      id: 'read-and-answer',
-      llm: 'please summarize',
-      context_files: [{ path: '/tmp/x.txt', hint: 'source data' }],
-      // context_files 经 runQuery(TAOR) 执行；步骤白名单与宿主有效工具集取交集。
-      allowed_tools: ['Read'],
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-
-    // 返回值断言
-    expect(result.raw).toEqual({ text: 'got it', result: 'got it' });
-    expect(result.preview).toBe('got it');
-
-    // chat 被调了 2 次
-    expect(capturedChatArgs.length).toBe(2);
-    // executeTool 被调了 1 次，参数透传正确
-    expect(capturedExecuteToolCalls.length).toBe(1);
-    expect(capturedExecuteToolCalls[0].name).toBe('Read');
-    const parsedArgs = JSON.parse(capturedExecuteToolCalls[0].rawArguments) as {
-      file_path: string;
-    };
-    expect(parsedArgs.file_path).toBe('/tmp/x.txt');
-
-    // 第一轮 user message 包含路径和 hint
-    const firstUserMsg = (
-      capturedChatArgs[0].messages as Array<{ role: string; content: string }>
-    ).find((m) => m.role === 'user');
-    expect(firstUserMsg).toBeDefined();
-    expect(firstUserMsg!.content).toContain('/tmp/x.txt');
-    expect(firstUserMsg!.content).toContain('source data');
-
-    // tools 数组只含 Read（白名单生效）
-    const tools0 = capturedChatArgs[0].tools as Array<{ name: string }>;
-    expect(tools0.length).toBe(1);
-    expect(tools0[0].name).toBe('Read');
-  });
-
-  it('case 2: 永不收敛（每轮都调工具）→ 被 maxTurns 严格兜住，不无限循环', async () => {
-    ctx.tools = [{ name: 'Read' } as Tool];
-    // v0.9 重构移除了 miniReAct 的"重复工具调用早停"，改由主 TAOR 引擎(runQuery)的
-    // maxTurns 硬上限兜底。本用例验证安全属性：模型每轮都调工具、永不收敛时，chat 调用
-    // 次数被 maxTurns 严格限制（不会无限循环），不再依赖已移除的重复检测。
-    mockTurns = [
-      {
-        kind: 'tool_call',
-        callId: 'c1',
-        name: 'Read',
-        argsJson: '{"file_path":"/a"}',
-      },
-      {
-        kind: 'tool_call',
-        callId: 'c2',
-        name: 'Read',
-        argsJson: '{"file_path":"/a"}',
-      },
-    ];
-    mockToolResults = [
-      { ok: true, content: 'A' },
-      { ok: true, content: 'A' },
-    ];
-
-    const step: StepDef = {
-      id: 'never-converge',
-      llm: 'go',
-      context_files: [{ path: '/a' }],
-      maxTurns: 2,
-    };
-
-    // 不无限循环：chat 调用次数被 maxTurns(=2) 严格兜住。
-    // 撞顶后的半截产出不可信，execLlmStep 必须抛错触发 runner retry/halt。
-    await expect(
-      drainLlm(execLlmStep(step, new VarStack(), ctx)),
-    ).rejects.toThrow('达到最大轮数 2 被截断');
-    expect(capturedChatArgs.length).toBe(2);
-  });
-
-  it('case 3: output_schema + tools — 走 [json+tools] 前缀', async () => {
-    ctx.tools = [{ name: 'Read' } as Tool];
-    mockTurns = [
-      {
-        kind: 'tool_call',
-        callId: 'call_1',
-        name: 'Read',
-        argsJson: '{"file_path":"/tmp/y.txt"}',
-      },
-      { kind: 'text', text: '{"findings":["a","b"]}' },
-    ];
-    mockToolResults = [{ ok: true, content: 'raw content' }];
-
-    const step: StepDef = {
-      id: 'structured-with-tools',
-      llm: 'find',
-      context_files: [{ path: '/tmp/y.txt' }],
-      output_schema: {
-        type: 'object',
-        properties: { findings: { type: 'array', items: { type: 'string' } } },
-        required: ['findings'],
-      },
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-
-    // raw 是 parsed JSON
-    expect(result.raw).toEqual({ findings: ['a', 'b'] });
-    // v0.9：output_schema 走 prompt 内嵌 + extractJsonPayload 解析，preview 统一 [json] 前缀
-    // （不再有独立的 [json+tools] 路径，也不再走 provider-native responseFormat）。
-    expect(result.preview.startsWith('[json] ')).toBe(true);
-
-    // chat 被调两轮（读文件一轮 + 出 JSON 一轮）
-    expect(capturedChatArgs.length).toBe(2);
-  });
-});