minimal-agent 0.2.0 → 0.3.0

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

@@ -1,511 +0,0 @@
-/**
- * ============================================================
- *  test/workflows/runner.test.ts
- * ------------------------------------------------------------
- *  runner P0 行为：
- *    - tool / llm / assert step 成功路径
- *    - capture 绑变量到 VarStack
- *    - when=false → workflow_step_skipped
- *    - onError=halt（默认）→ workflow halt + error
- *    - onError=continue → 继续下一步
- *    - 工作流完成 yield workflow_done
- *
- *  策略：
- *    - tool 步骤用真实 Write 工具（写到 tmpdir，避免 mock executeTool）
- *    - llm 步骤 mock.module('../../../src/llm/client.ts')
- *    - assert / when 走纯表达式引擎，无需 mock
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
-import { runWorkflow } from '../src/runner.ts';
-import type {
-  LoopEvent,
-  Provider,
-} from '../../../src/types.ts';
-import type {
-  RunContext,
-  WorkflowDef,
-  WorkflowEvent,
-} from '../src/types.ts';
-
-type WfOrLoop = WorkflowEvent | LoopEvent;
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-async function collect(
-  gen: AsyncGenerator<WfOrLoop, void, void>,
-): Promise<WfOrLoop[]> {
-  const out: WfOrLoop[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-describe('workflows/runner', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-runner-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    // 抵抗 pluginRunner.test.ts 等遗留的 workingDir.ts mock 全局污染
-    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [] };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('线性 assert step 全通过 → workflow_done', async () => {
-    const def: WorkflowDef = {
-      name: 'pure-assert',
-      description: 'd',
-      steps: [
-        { id: 's1', type: 'assert', condition: '1 == 1' },
-        { id: 's2', type: 'assert', condition: '"a" != "b"' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    const types = events.map((e) => e.type);
-    expect(types[0]).toBe('workflow_start');
-    expect(types.filter((t) => t === 'workflow_step_end').length).toBe(2);
-    expect(types[types.length - 1]).toBe('workflow_done');
-  });
-
-  it('assert 失败 → halt + error 事件', async () => {
-    const def: WorkflowDef = {
-      name: 'assert-fail',
-      description: 'd',
-      steps: [
-        { id: 's1', type: 'assert', condition: '1 == 2', onFail: 'nope' },
-        { id: 's2', type: 'assert', condition: 'true' }, // 不应执行
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    // s2 不应有 step_start
-    const startedIds = events
-      .filter((e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> => e.type === 'workflow_step_start')
-      .map((e) => e.id);
-    expect(startedIds).toEqual(['s1']);
-    // 没 workflow_done
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-  });
-
-  it('onError=continue → 失败后继续下一步', async () => {
-    const def: WorkflowDef = {
-      name: 'continue',
-      description: 'd',
-      steps: [
-        { id: 's1', type: 'assert', condition: 'false', onError: 'continue' },
-        { id: 's2', type: 'assert', condition: 'true' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    const ends = events.filter(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> => e.type === 'workflow_step_end',
-    );
-    expect(ends.length).toBe(2);
-    expect(ends[0].ok).toBe(false);
-    expect(ends[1].ok).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('when=false → workflow_step_skipped 而不是 step_start', async () => {
-    const def: WorkflowDef = {
-      name: 'skip',
-      description: 'd',
-      inputs: [{ name: 'flag', type: 'string' }],
-      steps: [
-        {
-          id: 's1',
-          type: 'assert',
-          condition: 'true',
-          when: 'inputs.flag == "yes"',
-        },
-        { id: 's2', type: 'assert', condition: 'true' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, { flag: 'no' }, ctx));
-    const skipped = events.find((e) => e.type === 'workflow_step_skipped');
-    expect(skipped).toBeDefined();
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('tool step 写文件 + ${var} 插值（用真实 Write 工具）', async () => {
-    const def: WorkflowDef = {
-      name: 'wr',
-      description: 'd',
-      inputs: [{ name: 'book', type: 'string' }],
-      steps: [
-        {
-          id: 'w',
-          tool: 'Write',
-          args: {
-            file_path: 'videos/${inputs.book}/x.txt',
-            content: 'hello ${inputs.book}',
-          },
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, { book: '原则' }, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-
-    const filePath = join(tmp, 'videos', '原则', 'x.txt');
-    expect(existsSync(filePath)).toBe(true);
-    expect(readFileSync(filePath, 'utf8')).toBe('hello 原则');
-  });
-
-  it('capture 把 tool 结果绑到变量，下一步 assert 能用', async () => {
-    const def: WorkflowDef = {
-      name: 'cap',
-      description: 'd',
-      steps: [
-        {
-          id: 'w',
-          tool: 'Write',
-          args: { file_path: 'a.txt', content: 'data' },
-          capture: { content: 'last_write_content' },
-        },
-        {
-          id: 'check',
-          type: 'assert',
-          condition: 'length(last_write_content) > 0',
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('未知 tool → halt + error', async () => {
-    const def: WorkflowDef = {
-      name: 'badtool',
-      description: 'd',
-      steps: [{ id: 'x', tool: 'NoSuchTool9999' }],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-  });
-
-  it('llm step 拿 chat 累积文本 + capture text', async () => {
-    mock.module('../../../src/llm/client.ts', () => ({
-      chat: async function* () {
-        yield { type: 'text_delta', delta: 'Hello ' };
-        yield { type: 'text_delta', delta: 'world' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'llm-cap',
-      description: 'd',
-      steps: [
-        {
-          id: 'g',
-          llm: 'irrelevant',
-          capture: { text: 'msg' },
-        },
-        {
-          id: 'check',
-          type: 'assert',
-          condition: 'msg == "Hello world"',
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('workflow_step_start 的 index 与 total 与 steps 长度一致', async () => {
-    const def: WorkflowDef = {
-      name: 'count',
-      description: 'd',
-      steps: [
-        { id: 'a', type: 'assert', condition: 'true' },
-        { id: 'b', type: 'assert', condition: 'true' },
-        { id: 'c', type: 'assert', condition: 'true' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    const starts = events.filter(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> => e.type === 'workflow_step_start',
-    );
-    expect(starts.length).toBe(3);
-    expect(starts.map((s) => s.index)).toEqual([0, 1, 2]);
-    expect(starts.every((s) => s.total === 3)).toBe(true);
-  });
-
-  it('signal.aborted → 立即 interrupted', async () => {
-    const ctrl = new AbortController();
-    ctrl.abort();
-    const def: WorkflowDef = {
-      name: 'abort',
-      description: 'd',
-      steps: [{ id: 'a', type: 'assert', condition: 'true' }],
-    };
-    const events = await collect(
-      runWorkflow(def, {}, { provider: fakeProvider, history: [], signal: ctrl.signal }),
-    );
-    expect(events.some((e) => e.type === 'interrupted')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-  });
-
-  it('P1 branch step：condition=true → 走 then 分支，输出 branch=true', async () => {
-    const def: WorkflowDef = {
-      name: 'branch-true',
-      description: 'd',
-      inputs: [{ name: 'x', type: 'number' }],
-      steps: [
-        {
-          id: 'br',
-          type: 'branch',
-          condition: 'inputs.x > 0',
-          then: [
-            {
-              id: 'then_w',
-              tool: 'Write',
-              args: { file_path: 'pos.txt', content: 'positive' },
-            },
-          ],
-          else: [
-            {
-              id: 'else_w',
-              tool: 'Write',
-              args: { file_path: 'neg.txt', content: 'negative' },
-            },
-          ],
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, { x: 5 }, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(existsSync(join(tmp, 'pos.txt'))).toBe(true);
-    expect(existsSync(join(tmp, 'neg.txt'))).toBe(false);
-    const ends = events.filter(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> => e.type === 'workflow_step_end',
-    );
-    // 至少 then_w (1) + br (1) = 2 个 step_end，且都 ok
-    expect(ends.length).toBe(2);
-    expect(ends.every((e) => e.ok)).toBe(true);
-    const brEnd = ends.find((e) => e.id === 'br');
-    expect(brEnd?.output).toBe('branch=true');
-  });
-
-  it('P1 branch step：condition=false → 走 else 分支', async () => {
-    const def: WorkflowDef = {
-      name: 'branch-false',
-      description: 'd',
-      inputs: [{ name: 'x', type: 'number' }],
-      steps: [
-        {
-          id: 'br',
-          type: 'branch',
-          condition: 'inputs.x > 0',
-          then: [{ id: 'then_a', type: 'assert', condition: 'true' }],
-          else: [
-            {
-              id: 'else_w',
-              tool: 'Write',
-              args: { file_path: 'neg.txt', content: 'negative' },
-            },
-          ],
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, { x: -3 }, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(existsSync(join(tmp, 'neg.txt'))).toBe(true);
-    const brEnd = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
-        e.type === 'workflow_step_end' && e.id === 'br',
-    );
-    expect(brEnd?.output).toBe('branch=false');
-  });
-
-  it('P1 branch step：缺 then/else 也合法（cond 求值后空跳过）', async () => {
-    const def: WorkflowDef = {
-      name: 'branch-empty',
-      description: 'd',
-      steps: [
-        { id: 'br', type: 'branch', condition: '1 == 1' },
-        { id: 's2', type: 'assert', condition: 'true' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    const ids = events
-      .filter((e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> => e.type === 'workflow_step_end')
-      .map((e) => e.id);
-    expect(ids).toEqual(['br', 's2']);
-  });
-
-  it('P1 loop step：over=数组字面量，子步骤用 ${as} 和 ${as}_idx', async () => {
-    const def: WorkflowDef = {
-      name: 'loop-lit',
-      description: 'd',
-      steps: [
-        {
-          id: 'lp',
-          type: 'loop',
-          over: '["a", "b", "c"]',
-          as: 'item',
-          do: [
-            {
-              id: 'w',
-              tool: 'Write',
-              args: {
-                file_path: 'items/${item_idx}-${item}.txt',
-                content: 'idx=${item_idx} val=${item}',
-              },
-            },
-          ],
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    for (let i = 0; i < 3; i++) {
-      const val = ['a', 'b', 'c'][i];
-      const filePath = join(tmp, 'items', `${i}-${val}.txt`);
-      expect(existsSync(filePath)).toBe(true);
-      expect(readFileSync(filePath, 'utf8')).toBe(`idx=${i} val=${val}`);
-    }
-    const lpEnd = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
-        e.type === 'workflow_step_end' && e.id === 'lp',
-    );
-    expect(lpEnd?.output).toBe('loop 3 次');
-  });
-
-  it('P1 loop step：迭代变量在循环外不再可见（push/pop 帧）', async () => {
-    const def: WorkflowDef = {
-      name: 'loop-scope',
-      description: 'd',
-      steps: [
-        {
-          id: 'lp',
-          type: 'loop',
-          over: '[1, 2]',
-          as: 'i',
-          do: [{ id: 'noop', type: 'assert', condition: 'i > 0' }],
-        },
-        // 循环外的 ${i} 已 pop —— 这里把它当字符串拿不到，length()=0
-        { id: 'check', type: 'assert', condition: 'length(i) == 0' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('P1 loop step：over 求值不是数组 → halt + error', async () => {
-    const def: WorkflowDef = {
-      name: 'loop-bad-over',
-      description: 'd',
-      steps: [
-        {
-          id: 'lp',
-          type: 'loop',
-          over: '"not an array"',
-          as: 'i',
-          do: [{ id: 'inner', type: 'assert', condition: 'true' }],
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-  });
-
-  it('P1 pause step：非交互模式直接 skipped + step_end ok', async () => {
-    const def: WorkflowDef = {
-      name: 'pause-skip',
-      description: 'd',
-      steps: [
-        { id: 'p1', type: 'pause', prompt: '等用户确认' },
-        { id: 's2', type: 'assert', condition: 'true' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    const skipped = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_skipped' }> =>
-        e.type === 'workflow_step_skipped' && e.id === 'p1',
-    );
-    expect(skipped?.reason).toContain('等用户确认');
-  });
-
-  it('P1 skill step：加载 cwd/skills/<name>/SKILL.md，跑 runQuery 累计 text', async () => {
-    // 在 tmp 准备一个最小 SKILL.md
-    const skillDir = join(tmp, 'skills', 'echo-bot');
-    mkdirSync(skillDir, { recursive: true });
-    writeFileSync(
-      join(skillDir, 'SKILL.md'),
-      '---\nname: echo-bot\ndescription: echo\n---\n\n按用户指示原样输出',
-      'utf8',
-    );
-
-    // skill executor 通过 plugin-sdk.runQuery 调子循环；直接 mock loop.ts
-    // 避开 chat 层（也免疫其它测试文件遗留的 loop.ts mock 污染）。
-    mock.module('../../../src/loop.ts', () => ({
-      runQuery: async function* () {
-        yield { type: 'text', delta: 'echoed-' };
-        yield { type: 'text', delta: 'OK' };
-        yield { type: 'turn_done' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'skill-test',
-      description: 'd',
-      steps: [
-        {
-          id: 'sk',
-          skill: 'echo-bot',
-          input: 'say hi',
-          capture: { text: 'msg' },
-        },
-        { id: 'check', type: 'assert', condition: 'msg == "echoed-OK"' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('P1 skill step：未找到 skill → halt + error', async () => {
-    const def: WorkflowDef = {
-      name: 'skill-missing',
-      description: 'd',
-      steps: [{ id: 'sk', skill: 'definitely-not-exists' }],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-  });
-});