w-dispatch-ai 1.0.2 → 1.0.4

package/test/unit-extractJsonLoose.test.mjs

@@ -0,0 +1,78 @@
+import assert from 'assert'
+import extractJsonLoose from '../src/wkf/extractJsonLoose.mjs'
+
+
+describe('extractJsonLoose', function() {
+
+    it('整段即為合法JSON時直接解析', function() {
+        let r = [
+            extractJsonLoose('{"a":1}'),
+            extractJsonLoose('[1,2,3]'),
+            extractJsonLoose('  {"a":{"b":[1]}}  '),
+        ]
+        let rr = [{ a: 1 }, [1, 2, 3], { a: { b: [1] } }]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('去除code fence與前後說明文字後抽取第一個完整物件', function() {
+        let r = [
+            extractJsonLoose('說明文字\n```json\n{"a":1}\n```\n後記'),
+            extractJsonLoose('```\n{"a":1}\n```'),
+            extractJsonLoose('前綴 {"a":1} 後綴 {"b":2}'),
+        ]
+        let rr = [{ a: 1 }, { a: 1 }, { a: 1 }]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('去除ANSI色碼', function() {
+        let esc = String.fromCharCode(27)
+        let r = extractJsonLoose(`${esc}[0m{"a":1}${esc}[91m`)
+        let rr = { a: 1 }
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('字串值內之括號與跳脫不干擾配對', function() {
+        let r = extractJsonLoose('{"a":"x{y}[z]","b":"q\\"w"}')
+        let rr = { a: 'x{y}[z]', b: 'q"w' }
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('截斷(括號未閉合)回傳null', function() {
+        let r = [
+            extractJsonLoose('{"a":1'),
+            extractJsonLoose('[1,2'),
+            extractJsonLoose('{"a":"未閉合字串'),
+        ]
+        let rr = [null, null, null]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('非物件與陣列之JSON回傳null', function() {
+        let r = [
+            extractJsonLoose('"hello"'),
+            extractJsonLoose('123'),
+            extractJsonLoose('true'),
+            extractJsonLoose('null'),
+        ]
+        let rr = [null, null, null, null]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('無JSON內容回傳null', function() {
+        let r = [
+            extractJsonLoose('純文字回覆'),
+            extractJsonLoose(''),
+            extractJsonLoose(null),
+            extractJsonLoose(undefined),
+        ]
+        let rr = [null, null, null, null]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('第一個片段非法時回傳null(不繼續嘗試後續片段)', function() {
+        let r = extractJsonLoose('{"a":1,} {"b":2}')
+        let rr = null
+        assert.strict.deepEqual(r, rr)
+    })
+
+})

package/test/unit-runFanout.test.mjs

@@ -0,0 +1,166 @@
+import assert from 'assert'
+import runFanout, { defaultIntegratePrompt } from '../src/wkf/runFanout.mjs'
+import createFakeCli from './tools/fakeCliForTest.mjs'
+
+
+describe('runFanout', function() {
+
+    let fake = null
+    let providers = null
+    let callOpt = { promptPrefix: '' }
+
+    before(function() {
+        fake = createFakeCli('fake-wkf-fanout')
+        providers = {
+            'p-a': { kind: 'claude', exe: fake.exe, model: 'sonnet' },
+            'p-b': { kind: 'codex', exe: fake.exe, model: 'gpt-5.6-luna' },
+            'p-int': { kind: 'opencode', exe: fake.exe, model: 'opencode/free' },
+            'p-dead': { kind: 'claude', exe: fake.exe, extraArgs: ['--fake-exit=1'] },
+        }
+    })
+
+    after(function() {
+        if (fake) {
+            fake.clean()
+        }
+    })
+
+    it('task或agents無效時回傳錯誤結果物件', async function() {
+        let t1 = await runFanout({ providers, task: '', agents: [{ use: 'p-a' }], callOpt })
+        let t2 = await runFanout({ providers, task: 'abc', agents: null, callOpt })
+        let r = [[t1.ok, t1.error], [t2.ok, t2.error]]
+        let rr = [
+            [false, 'task must be a non-empty string'],
+            [false, 'agents must be a non-empty array'],
+        ]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('候選達門檻時進整合, 整合提示詞含各候選', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: { use: 'p-int' },
+            callOpt,
+        })
+        let r = [
+            t.ok,
+            t.integrated,
+            t.candidates.length,
+            t.agents.map((x) => x.providerId),
+            t.result.args[0], //整合者為opencode轉接器
+            t.result.stdin.includes('【候選 1】') && t.result.stdin.includes('【候選 2】'),
+            t.integrateDetail.providerId,
+        ]
+        let rr = [true, true, 2, ['p-a', 'p-b'], 'run', true, 'p-int']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('個別名額失敗不炸整輪, 恰1份成功候選直接放行(integrated:false)', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-dead' }, { use: 'p-a' }],
+            integrate: { use: 'p-int' },
+            callOpt,
+        })
+        let r = [t.ok, t.integrated, t.candidates.length, t.result.args, t.agents[0].ok, t.agents[1].ok]
+        let rr = [true, false, 1, ['-p', '--dangerously-skip-permissions', '--model', 'sonnet'], false, true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('候選未達minCandidates時不硬整合, 以首位候選為成果', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: { use: 'p-int' },
+            minCandidates: 3,
+            callOpt,
+        })
+        let r = [t.ok, t.integrated, t.candidates.length, t.result === t.candidates[0], t.error]
+        let rr = [true, false, 2, true, '']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('全數名額失敗時回傳all agents failed', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-dead' }, { use: 'p-dead' }],
+            integrate: { use: 'p-int' },
+            callOpt,
+        })
+        let r = [t.ok, t.result, t.candidates.length, t.error]
+        let rr = [false, null, 0, 'all agents failed']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('達門檻但缺integrate規格時回報必要性', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            callOpt,
+        })
+        let r = [t.ok, t.error, t.candidates.length]
+        let rr = [false, 'integrate spec (with use) is required', 2]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('整合失敗時成功候選仍完整回傳供接續重試', async function() {
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: { use: 'p-dead' },
+            callOpt,
+        })
+        let r = [t.ok, t.integrated, t.candidates.length, t.error.indexOf('integrate failed:') === 0]
+        let rr = [false, false, 2, true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('integrate.prompt可自訂整合提示詞', async function() {
+        let seen = null
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: {
+                use: 'p-int',
+                prompt: (candidates) => {
+                    seen = candidates.length
+                    return 'CUSTOM-INTEGRATE'
+                },
+            },
+            callOpt,
+        })
+        let r = [t.ok, seen, t.result.stdin]
+        let rr = [true, 2, 'CUSTOM-INTEGRATE']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('名額規格之額外鍵覆寫該名額呼叫設定', async function() {
+        //p-a名額帶rawText覆寫 → 該名額json為文字, 候選為字串
+        let t = await runFanout({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a', rawText: true }],
+            integrate: { use: 'p-int' },
+            callOpt,
+        })
+        let r = [t.ok, t.integrated, typeof t.result]
+        let rr = [true, false, 'string']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('defaultIntegratePrompt嵌入候選數與schema', function() {
+        let s = defaultIntegratePrompt([{ a: 1 }, { b: 2 }], { schema: '{"x":"..."}' })
+        let r = [s.includes('2 個獨立執行'), s.includes('{"x":"..."}'), s.includes('【候選 2】')]
+        let rr = [true, true, true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+})

package/test/unit-runFanoutPipeline.test.mjs

@@ -0,0 +1,86 @@
+import assert from 'assert'
+import runFanoutPipeline from '../src/wkf/runFanoutPipeline.mjs'
+import createFakeCli from './tools/fakeCliForTest.mjs'
+
+
+describe('runFanoutPipeline', function() {
+
+    let fake = null
+    let providers = null
+    let callOpt = { promptPrefix: '' }
+
+    before(function() {
+        fake = createFakeCli('fake-wkf-fp')
+        providers = {
+            'p-a': { kind: 'claude', exe: fake.exe, model: 'sonnet' },
+            'p-b': { kind: 'codex', exe: fake.exe, model: 'gpt-5.6-luna' },
+            'p-int': { kind: 'opencode', exe: fake.exe, model: 'opencode/free' },
+            'p-dead': { kind: 'claude', exe: fake.exe, extraArgs: ['--fake-exit=1'] },
+        }
+    })
+
+    after(function() {
+        if (fake) {
+            fake.clean()
+        }
+    })
+
+    it('前段多開整合, 後段以前段成果為input執行角色鏈', async function() {
+        let t = await runFanoutPipeline({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: { use: 'p-int' },
+            stages: [
+                { id: 'audit', use: 'p-b', prompt: (ctx) => `audit ${ctx.input.args[0]}` }, //input為整合者echo物件
+            ],
+            callOpt,
+        })
+        let r = [
+            t.ok,
+            t.A.ok,
+            t.A.integrated,
+            t.B.ok,
+            t.B.order,
+            t.result.stdin, //後段最末階段之echo, 其stdin含前段成果之args[0](整合者為opencode轉接器故為run)
+        ]
+        let rr = [true, true, true, true, ['audit'], 'audit run']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('前段失敗即回, 後段不執行', async function() {
+        let t = await runFanoutPipeline({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-dead' }, { use: 'p-dead' }],
+            integrate: { use: 'p-int' },
+            stages: [{ id: 's1', use: 'p-a', prompt: () => 'x' }],
+            callOpt,
+        })
+        let r = [t.ok, t.A.ok, t.B, t.error.indexOf('A failed:') === 0]
+        let rr = [false, false, null, true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('後段失敗時前段成果仍完整回傳, 可只重跑後段', async function() {
+        let t = await runFanoutPipeline({
+            providers,
+            task: 'abc',
+            agents: [{ use: 'p-a' }, { use: 'p-b' }],
+            integrate: { use: 'p-int' },
+            stages: [{ id: 's1', use: 'p-dead', prompt: () => 'x' }],
+            callOpt,
+        })
+        let r = [
+            t.ok,
+            t.A.ok,
+            t.A.result !== null,
+            t.B.ok,
+            t.B.failedStage,
+            t.error.indexOf('B failed:') === 0,
+        ]
+        let rr = [false, true, true, false, 's1', true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+})

package/test/unit-runRolePipeline.test.mjs

@@ -0,0 +1,163 @@
+import assert from 'assert'
+import runRolePipeline from '../src/wkf/runRolePipeline.mjs'
+import createFakeCli from './tools/fakeCliForTest.mjs'
+
+
+describe('runRolePipeline', function() {
+
+    let fake = null
+    let providers = null
+    let callOpt = { promptPrefix: '' }
+
+    before(function() {
+        fake = createFakeCli('fake-wkf-role')
+        providers = {
+            'p-a': { kind: 'claude', exe: fake.exe, model: 'sonnet' },
+            'p-b': { kind: 'codex', exe: fake.exe, model: 'gpt-5.6-luna' },
+            'p-dead': { kind: 'claude', exe: fake.exe, extraArgs: ['--fake-exit=1'] },
+        }
+    })
+
+    after(function() {
+        if (fake) {
+            fake.clean()
+        }
+    })
+
+    it('stages無效時回傳錯誤結果物件', async function() {
+        let t = await runRolePipeline({ providers, stages: null, callOpt })
+        let r = [t.ok, t.error, t.order]
+        let rr = [false, 'stages must be a non-empty array', []]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('各階段依序執行, ctx傳遞input與prev與results', async function() {
+        let ctxSeen = []
+        let t = await runRolePipeline({
+            providers,
+            input: 'INPUT-MARK',
+            stages: [
+                {
+                    id: 'draft',
+                    use: 'p-a',
+                    prompt: (ctx) => {
+                        ctxSeen.push(['draft', ctx.input, ctx.prev, ctx.index])
+                        return `draft on ${ctx.input}`
+                    },
+                },
+                {
+                    id: 'review',
+                    use: 'p-b',
+                    prompt: (ctx) => {
+                        ctxSeen.push(['review', ctx.input, ctx.prev === ctx.results.draft, ctx.index])
+                        return `review ${ctx.prev.stdin}` //prev為draft階段之echo物件
+                    },
+                },
+            ],
+            callOpt,
+        })
+        let r = [
+            t.ok,
+            t.order,
+            t.failedStage,
+            ctxSeen,
+            t.results.draft.stdin,
+            t.results.review.stdin,
+            t.result === t.results.review, //最末階段成果即工作流成果
+        ]
+        let rr = [
+            true,
+            ['draft', 'review'],
+            null,
+            [['draft', 'INPUT-MARK', null, 0], ['review', 'INPUT-MARK', true, 1]],
+            'draft on INPUT-MARK',
+            'review draft on INPUT-MARK',
+            true,
+        ]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('某階段失敗即中止, 已完成階段成果保留且failedStage標明斷點', async function() {
+        let t = await runRolePipeline({
+            providers,
+            stages: [
+                { id: 's1', use: 'p-a', prompt: () => 'stage1' },
+                { id: 's2', use: 'p-dead', prompt: () => 'stage2' },
+                { id: 's3', use: 'p-a', prompt: () => 'stage3' },
+            ],
+            callOpt,
+        })
+        let r = [
+            t.ok,
+            t.failedStage,
+            t.order,
+            t.results.s1.stdin,
+            t.results.s2,
+            t.error.indexOf('stage[s2] failed:') === 0,
+        ]
+        let rr = [false, 's2', ['s1', 's2'], 'stage1', undefined, true]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('prompt非函數或回傳空值時回報該階段錯誤', async function() {
+        let t1 = await runRolePipeline({ providers, stages: [{ id: 'x', use: 'p-a', prompt: 'not-fn' }], callOpt })
+        let t2 = await runRolePipeline({ providers, stages: [{ id: 'y', use: 'p-a', prompt: () => '' }], callOpt })
+        let r = [
+            [t1.ok, t1.failedStage, t1.error],
+            [t2.ok, t2.failedStage, t2.error],
+        ]
+        let rr = [
+            [false, 'x', 'stage[x].prompt must be a function'],
+            [false, 'y', 'stage[y].prompt returned empty'],
+        ]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('未給id之階段自動命名stageN', async function() {
+        let t = await runRolePipeline({
+            providers,
+            stages: [{ use: 'p-a', prompt: () => 'abc' }],
+            callOpt,
+        })
+        let r = [t.ok, t.order]
+        let rr = [true, ['stage1']]
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('階段可自帶fallback, 主模型失敗自動遞補', async function() {
+        let t = await runRolePipeline({
+            providers,
+            stages: [{ id: 's1', use: 'p-dead', fallback: ['p-b'], prompt: () => 'abc' }],
+            callOpt,
+        })
+        let r = [t.ok, t.stages.s1.providerId]
+        let rr = [true, 'p-b']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('rawText階段之成果為文字並可傳遞至下一階段', async function() {
+        let t = await runRolePipeline({
+            providers,
+            stages: [
+                { id: 's1', use: 'p-a', rawText: true, prompt: () => 'abc' },
+                { id: 's2', use: 'p-b', prompt: (ctx) => `got ${typeof ctx.prev}` },
+            ],
+            callOpt,
+        })
+        let r = [t.ok, typeof t.results.s1, t.results.s2.stdin]
+        let rr = [true, 'string', 'got string']
+        assert.strict.deepEqual(r, rr)
+    })
+
+    it('階段check未過視為該階段失敗', async function() {
+        let t = await runRolePipeline({
+            providers,
+            stages: [{ id: 's1', use: 'p-a', prompt: () => 'abc', check: () => false }],
+            callOpt,
+        })
+        let r = [t.ok, t.failedStage]
+        let rr = [false, 's1']
+        assert.strict.deepEqual(r, rr)
+    })
+
+})