minimal-agent 0.1.9 → 0.2.0

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

@@ -0,0 +1,216 @@
+/**
+ * ============================================================
+ *  test/workflows/loader.test.ts
+ * ------------------------------------------------------------
+ *  loader 单测：
+ *    - 双源扫描：cwd 优先、packageRoot fallback
+ *    - 一个坏 yaml 不污染其它工作流
+ *    - 校验阻断：name/description/steps/动作字段
+ *    - 内置 book-review-short.yaml 能被解析
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
+import {
+  findWorkflowByName,
+  listWorkflows,
+  parseWorkflowFile,
+  WorkflowLoadError,
+} from '../src/loader.ts';
+
+describe('workflows/loader', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    // 抵抗其它测试文件（如 pluginRunner.test.ts）通过 mock.module 留下的
+    // workingDir.ts 全局替身——把 getWorkingDir 重新指回本测试的 tmp。
+    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function writeYaml(name: string, body: string) {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    writeFileSync(join(tmp, 'workflows', name), body, 'utf8');
+  }
+
+  it('cwd 下放 yaml 能被 listWorkflows 发现', async () => {
+    writeYaml(
+      'my.yaml',
+      `name: my-wf
+description: hello
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+`,
+    );
+
+    const list = await listWorkflows();
+    expect(list.find((w) => w.name === 'my-wf')).toBeDefined();
+  });
+
+  it('packageRoot 自带 book-review-short 也能被发现（fallback 路径）', async () => {
+    const list = await listWorkflows();
+    expect(list.find((w) => w.name === 'book-review-short')).toBeDefined();
+  });
+
+  it('cwd 同名 workflow 覆盖 packageRoot', async () => {
+    writeYaml(
+      'override.yaml',
+      `name: book-review-short
+description: cwd override
+steps:
+  - id: only
+    type: assert
+    condition: 'true'
+`,
+    );
+    const def = await findWorkflowByName('book-review-short');
+    expect(def).not.toBeNull();
+    expect(def!.description).toBe('cwd override');
+  });
+
+  it('坏 yaml 不污染其他 workflow（继续列出好的）', async () => {
+    writeYaml('good.yaml', `name: good
+description: ok
+steps:
+  - id: x
+    type: assert
+    condition: 'true'
+`);
+    writeYaml('bad.yaml', 'name: bad\n  bad-indent\n: garbage:::\n');
+
+    const list = await listWorkflows();
+    expect(list.find((w) => w.name === 'good')).toBeDefined();
+    // bad.yaml 不应阻塞其它，也不应被列出
+    expect(list.find((w) => w.name === 'bad')).toBeUndefined();
+  });
+
+  it('findWorkflowByName 未命中返回 null', async () => {
+    const def = await findWorkflowByName('nonexistent-wf-xyz');
+    expect(def).toBeNull();
+  });
+
+  it('listWorkflows 对完全缺失 workflows/ 不抛错', async () => {
+    // 没有 workflows 目录，只有 packageRoot fallback
+    const list = await listWorkflows();
+    expect(Array.isArray(list)).toBe(true);
+  });
+});
+
+describe('workflows/loader::validate', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-v-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function writeRaw(body: string): string {
+    const p = join(tmp, 'wf.yaml');
+    writeFileSync(p, body, 'utf8');
+    return p;
+  }
+
+  it('缺 name → 抛 WorkflowLoadError', async () => {
+    const p = writeRaw('description: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow(WorkflowLoadError);
+  });
+
+  it('缺 description → 抛错', async () => {
+    const p = writeRaw('name: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('steps 空数组 → 抛错', async () => {
+    const p = writeRaw('name: x\ndescription: y\nsteps: []\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('step 没有任何动作字段 → 抛错', async () => {
+    const p = writeRaw('name: x\ndescription: y\nsteps:\n  - id: a\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('step 同时设置 tool + llm → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    llm: "say hi"
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('assert step 缺 condition → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('同级 steps id 重复 → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: dup
+    type: assert
+    condition: 'true'
+  - id: dup
+    type: assert
+    condition: 'true'
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('合法 yaml 通过 + __source 字段被注入', async () => {
+    const p = writeRaw(`name: ok-wf
+description: nice
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: x.txt }
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.name).toBe('ok-wf');
+    expect(def.__source).toBe(p);
+  });
+
+  it('inputs[].type=enum 缺 values → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+inputs:
+  - name: foo
+    type: enum
+steps:
+  - id: a
+    type: assert
+    condition: 'true'
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,230 @@
+/**
+ * ============================================================
+ *  test/workflows/pluginRunner.isolation.test.ts
+ * ------------------------------------------------------------
+ *  V1 红线：默认 T-A-O-R 不退化。无论 workflows/ 是缺失 / 存在 / 全坏，
+ *  非 / 输入 100% 走 runQuery，零 workflow 副作用。
+ *
+ *  断言重点：
+ *    - 非 / 输入下 runQuery 被调用一次且参数（input + history）原样透传
+ *    - 非 / 输入下 pluginCache 保持空（说明 discoverPlugins 没被调）
+ *    - 没有任何 workflow_* / plugin_* 事件
+ *    - 即使 workflows/ 满是坏 yaml，也不影响以上结论
+ *
+ *  这是"在不 / 启动的情况下原始 T-A-O-R 要好使"硬约束的回归门。
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
+import {
+  _resetPluginCache,
+  discoverPlugins,
+} from '../../../src/plugins/commandRouter.ts';
+import type { LoopEvent, Message, Provider } from '../../../src/types.ts';
+import type { PluginEvent } from '../../../src/plugins/pluginApi.ts';
+
+type WfOrLoop = LoopEvent | PluginEvent;
+
+const fakeProvider: Provider = {
+  name: 'test',
+  baseURL: '',
+  apiKey: '',
+  model: 'm',
+  contextWindow: 128000,
+};
+
+interface RunQueryCall {
+  input: string;
+  historyLen: number;
+}
+
+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('pluginRunner V1 红线：非 / 输入不被 workflow 污染', () => {
+  let tmp: string;
+  const calls: RunQueryCall[] = [];
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-iso-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    _resetPluginCache();
+    calls.length = 0;
+
+    mock.module('../../../src/loop.ts', () => ({
+      runQuery: async function* (input: string, opts: { history: Message[] }) {
+        calls.push({ input, historyLen: opts.history.length });
+        yield { type: 'text', delta: 'fake-reply' };
+        yield { type: 'turn_done' };
+      },
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    _resetPluginCache();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  async function run(input: string, history: Message[] = []) {
+    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.ts');
+    return collect(
+      runWithPlugins(input, {
+        provider: fakeProvider,
+        history,
+      }),
+    );
+  }
+
+  it('workflows/ 缺失 + 非 / 输入 → 走 runQuery，无 workflow 事件', async () => {
+    const events = await run('hello world');
+    expect(calls.length).toBe(1);
+    expect(calls[0].input).toBe('hello world');
+
+    const noisyTypes = events
+      .map((e) => e.type)
+      .filter(
+        (t) => t.startsWith('workflow_') || t === 'plugin_progress',
+      );
+    expect(noisyTypes).toEqual([]);
+  });
+
+  it('workflows/ 存在合法 yaml + 非 / 输入 → 仍只走 runQuery（不发现 workflow，不调 listWorkflows）', async () => {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    writeFileSync(
+      join(tmp, 'workflows', 'pretty.yaml'),
+      `name: pretty
+description: x
+steps:
+  - id: a
+    type: assert
+    condition: 'true'
+`,
+      'utf8',
+    );
+
+    const events = await run('just a chat please');
+    expect(calls.length).toBe(1);
+    expect(events.some((e) => e.type.startsWith('workflow_'))).toBe(false);
+  });
+
+  it('workflows/ 全是坏 yaml + 非 / 输入 → 仍只走 runQuery', async () => {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    writeFileSync(join(tmp, 'workflows', 'broken.yaml'), '@@@\nbad:::\n', 'utf8');
+
+    const events = await run('hi there');
+    expect(calls.length).toBe(1);
+    expect(calls[0].input).toBe('hi there');
+    expect(events.some((e) => e.type.startsWith('workflow_'))).toBe(false);
+  });
+
+  it('非 / 输入 history 长度原样透传给 runQuery', async () => {
+    const history: Message[] = [
+      { role: 'system', content: 's' },
+      { role: 'user', content: 'u1' },
+      { role: 'assistant', content: 'a1' },
+    ];
+    await run('next thing', history);
+    expect(calls[0].historyLen).toBe(3);
+  });
+
+  it('非 / 输入下 pluginCache 不被填充（discoverPlugins 未被触发）', async () => {
+    await run('plain input no slash');
+    // 重置过 cache；非 / 输入应该完全跳过 discoverPlugins
+    const plugins = Array.from((await stealCache()).values());
+    expect(plugins.length).toBe(0);
+  });
+
+  it('/ 输入下 pluginCache 才被填充（对照组）', async () => {
+    await run('/nonexistent-cmd');
+    const plugins = Array.from((await stealCache()).values());
+    // 走过 discoverPlugins，应该至少能发现 ralph-wiggum（workflow 已降为内置能力）
+    expect(plugins.length).toBeGreaterThan(0);
+  });
+});
+
+/**
+ * commandRouter 的 pluginCache 是模块私有变量，没有 getter。
+ * 用一个 hack：调用 discoverPlugins()，但只看返回 —— 如果之前没被填，
+ * 这一调用结束时会把所有插件加进 cache。所以我们改为读副作用更直接的接口：
+ * listAvailableCommands()。如果没 discoverPlugins 过，listAvailableCommands
+ * 会返回空数组。
+ */
+async function stealCache(): Promise<Map<string, unknown>> {
+  const { listAvailableCommands } = await import('../../../src/plugins/commandRouter.ts');
+  const cmds = listAvailableCommands();
+  const m = new Map<string, unknown>();
+  for (const c of cmds) m.set(c.plugin, c);
+  return m;
+}
+
+describe('pluginRunner V2 红线：/workflow 命令通过 plugin.ts.runCommand 接管', () => {
+  let tmp: string;
+  const calls: RunQueryCall[] = [];
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-iso2-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    _resetPluginCache();
+    calls.length = 0;
+
+    mock.module('../../../src/loop.ts', () => ({
+      runQuery: async function* (input: string, opts: { history: Message[] }) {
+        calls.push({ input, historyLen: opts.history.length });
+        yield { type: 'text', delta: 'should-not-be-here' };
+        yield { type: 'turn_done' };
+      },
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    _resetPluginCache();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('/workflows 由插件 plugin.ts 接管 → 不走 runQuery，yield 列表 text', async () => {
+    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.ts');
+    const events = await collect(
+      runWithPlugins('/workflows', { provider: fakeProvider, history: [] }),
+    );
+    expect(calls.length).toBe(0);
+    expect(events.some((e) => e.type === 'text')).toBe(true);
+    expect(events.some((e) => e.type === 'turn_done')).toBe(true);
+  });
+
+  it('/workflow book-review-short 缺必填 input → yield error，不走 runQuery', async () => {
+    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.ts');
+    const events = await collect(
+      runWithPlugins('/workflow book-review-short', {
+        provider: fakeProvider,
+        history: [],
+      }),
+    );
+    expect(calls.length).toBe(0);
+    expect(events.some((e) => e.type === 'error')).toBe(true);
+  });
+
+  it('/workflow 以插件命令形式出现在 listAvailableCommands', async () => {
+    await discoverPlugins();
+    const { listAvailableCommands } = await import('../../../src/plugins/commandRouter.ts');
+    const cmds = listAvailableCommands();
+    const wf = cmds.find((c) => c.command === '/workflow');
+    expect(wf).toBeDefined();
+    expect(wf?.plugin).toBe('workflow-runner');
+  });
+});