@lythos/skill-arena 0.15.7 → 0.16.1

package/README.md

@@ -16,20 +16,20 @@
 ```bash
 bun add -d @lythos/skill-arena
 # or use directly
-bunx @lythos/skill-arena@0.15.7 <command>
+bunx @lythos/skill-arena@0.16.1 <command>
 ```
 
 ## Quick Start
 
 ```bash
 # single — test one deck (most common)
-bunx @lythos/skill-arena@0.15.7 single \
+bunx @lythos/skill-arena@0.16.1 single \
   --deck ./examples/decks/scout.toml \
   --brief "Generate auth flow diagram" \
   --out ./output
 
 # single with explicit player
-bunx @lythos/skill-arena@0.15.7 single \
+bunx @lythos/skill-arena@0.16.1 single \
   --deck ./examples/decks/scout.toml \
   --brief "Generate auth flow diagram" \
   --player kimi \
@@ -37,10 +37,10 @@ bunx @lythos/skill-arena@0.15.7 single \
 
 # cross-deck vs — compare two decks (agent-orchestrated)
 # Create arena.toml declaring sides with different decks, then:
-bunx @lythos/skill-arena@0.15.7 vs --config ./arena.toml
+bunx @lythos/skill-arena@0.16.1 vs --config ./arena.toml
 
 # cross-player vs — compare kimi vs codex (CLI only)
-bunx @lythos/skill-arena@0.15.7 vs --config ./arena.toml --player kimi
+bunx @lythos/skill-arena@0.16.1 vs --config ./arena.toml --player kimi
 ```
 
 **What happens**: Agent creates isolated `/tmp` workdir per side, `deck link` skills, spawns parallel subagents, collects artifacts, judge scores outputs. Parent deck restored after.
@@ -50,14 +50,14 @@ bunx @lythos/skill-arena@0.15.7 vs --config ./arena.toml --player kimi
 ### `single` — one deck, one task
 
 ```bash
-bunx @lythos/skill-arena@0.15.7 single \
+bunx @lythos/skill-arena@0.16.1 single \
   --deck ./deck.toml \
   --brief "Produce a .docx report with radar chart" \
   --timeout 600000 \
   --out ./output
 
 # with explicit player
-bunx @lythos/skill-arena@0.15.7 single \
+bunx @lythos/skill-arena@0.16.1 single \
   --deck ./deck.toml \
   --brief "Produce a .docx report with radar chart" \
   --player kimi \
@@ -67,14 +67,14 @@ bunx @lythos/skill-arena@0.15.7 single \
 ### `vs` — multi-deck comparison
 
 ```bash
-bunx @lythos/skill-arena@0.15.7 vs --config ./arena.toml
-bunx @lythos/skill-arena@0.15.7 vs --config ./arena.toml --dry-run
+bunx @lythos/skill-arena@0.16.1 vs --config ./arena.toml
+bunx @lythos/skill-arena@0.16.1 vs --config ./arena.toml --dry-run
 ```
 
 ### `prepare-workdir` — isolate + link skills (agent-orchestrated)
 
 ```bash
-bunx @lythos/skill-arena@0.15.7 prepare-workdir \
+bunx @lythos/skill-arena@0.16.1 prepare-workdir \
   --deck ./skill-deck.toml \
   --out /tmp/arena-side-a \
   --brief "task description"
@@ -85,7 +85,7 @@ Creates `/tmp`-isolated workdir with deck copied, AGENTS.md written, and `deck l
 ### `archive` — collect agent outputs (agent-orchestrated)
 
 ```bash
-bunx @lythos/skill-arena@0.15.7 archive \
+bunx @lythos/skill-arena@0.16.1 archive \
   --from /tmp/arena-side-a \
   --to ./playground/output \
   --sides side-a
@@ -96,7 +96,7 @@ Copies agent artifacts from workdir(s) to output, skipping internal files (`.cla
 ### `viz` — render results (WIP — HTML report generation pending)
 
 ```bash
-bunx @lythos/skill-arena@0.15.7 viz runs/arena-<id>/
+bunx @lythos/skill-arena@0.16.1 viz runs/arena-<id>/
 ```
 
 ## Parameters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lythos/skill-arena",
-  "version": "0.15.7",
+  "version": "0.16.1",
   "description": "Skill Arena — benchmark skill effectiveness with controlled-variable comparison",
   "keywords": [
     "ai-agent",
@@ -42,15 +42,15 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@lythos/cold-pool": "^0.15.7",
-    "@lythos/infra": "^0.15.7",
-    "@lythos/test-utils": "^0.15.7",
+    "@lythos/cold-pool": "^0.16.1",
+    "@lythos/infra": "^0.16.1",
+    "@lythos/test-utils": "^0.16.1",
     "zod": "^3.24.0",
     "zod-to-json-schema": "^3.25.2"
   },
   "optionalDependencies": {
-    "@lythos/agent-adapter-claude-sdk": "^0.15.7",
-    "@lythos/agent-adapter-deepseek-serve": "^0.15.7",
-    "@lythos/agent-adapter-codex": "^0.15.7"
+    "@lythos/agent-adapter-claude-sdk": "^0.16.1",
+    "@lythos/agent-adapter-deepseek-serve": "^0.16.1",
+    "@lythos/agent-adapter-codex": "^0.16.1"
   }
 }

package/src/arena-toml.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, it, expect } from 'bun:test'
 import { parseArenaToml, buildExecutionPlan, ArenaToml } from './arena-toml'
 import { formatPlanOutput } from './runner'
 
@@ -63,7 +63,7 @@ working_dir = "/workspace"
 `
 
 describe('parseArenaToml', () => {
-  test('parses minimal two-side arena with criteria', () => {
+  it('parses minimal two-side arena with criteria', () => {
     const result = parseArenaToml(minimalToml)
     expect(result.arena.task).toBe('Test task')
     expect(result.arena.criteria).toEqual(['a', 'b'])
@@ -75,14 +75,14 @@ describe('parseArenaToml', () => {
     expect(result.side[0].control).toBe(false)
   })
 
-  test('parses arena with judge field (preferred over criteria)', () => {
+  it('parses arena with judge field (preferred over criteria)', () => {
     const result = parseArenaToml(judgeToml)
     expect(result.arena.judge).toContain('Evaluate completeness')
     expect(result.arena.criteria).toBeUndefined()
     expect(result.side).toHaveLength(2)
   })
 
-  test('parses full arena with runs_per_side and control', () => {
+  it('parses full arena with runs_per_side and control', () => {
     const result = parseArenaToml(fullToml)
     expect(result.arena.runs_per_side).toBe(3)
     expect(result.side).toHaveLength(3)
@@ -90,7 +90,7 @@ describe('parseArenaToml', () => {
     expect(result.side[2].control).toBe(true)
   })
 
-  test('parses side env block', () => {
+  it('parses side env block', () => {
     const result = parseArenaToml(fullToml)
     const env = result.side[2].env
     expect(env.container).toBe('node:20-alpine')
@@ -99,47 +99,47 @@ describe('parseArenaToml', () => {
     expect(env.env_vars).toEqual({})
   })
 
-  test('rejects fewer than 2 sides', () => {
+  it('rejects fewer than 2 sides', () => {
     const bad = `[arena]\ntask = "x"\ncriteria = ["a"]\n\n[[side]]\nname = "only"\nplayer = "c"\ndeck = "x.toml"`
     expect(() => parseArenaToml(bad)).toThrow()
   })
 
-  test('rejects neither judge nor criteria provided', () => {
+  it('rejects neither judge nor criteria provided', () => {
     const bad = `[arena]\ntask = "x"\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     expect(() => parseArenaToml(bad)).toThrow()
   })
 
-  test('accepts judge without criteria (either is sufficient)', () => {
+  it('accepts judge without criteria (either is sufficient)', () => {
     const toml = `[arena]\ntask = "x"\njudge = "Evaluate this."\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     expect(() => parseArenaToml(toml)).not.toThrow()
   })
 
-  test('rejects empty criteria and no judge', () => {
+  it('rejects empty criteria and no judge', () => {
     const bad = `[arena]\ntask = "x"\ncriteria = []\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     expect(() => parseArenaToml(bad)).toThrow()
   })
 
-  test('rejects non-object input', () => {
+  it('rejects non-object input', () => {
     expect(() => ArenaToml.parse('not valid')).toThrow()
   })
 
-  test('rejects missing arena section', () => {
+  it('rejects missing arena section', () => {
     expect(() => parseArenaToml('[[side]]\nname = "a"')).toThrow()
   })
 
-  test('rejects runs_per_side = 0', () => {
+  it('rejects runs_per_side = 0', () => {
     const bad = `[arena]\ntask = "x"\ncriteria = ["a"]\nruns_per_side = 0\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     expect(() => parseArenaToml(bad)).toThrow()
   })
 
-  test('parses integer and boolean values correctly', () => {
+  it('parses integer and boolean values correctly', () => {
     const toml = `[arena]\ntask = "x"\ncriteria = ["a"]\nruns_per_side = 2\nmax_participants = 5\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     const result = parseArenaToml(toml)
     expect(result.arena.runs_per_side).toBe(2)
     expect(result.arena.max_participants).toBe(5)
   })
 
-  test('comments are stripped', () => {
+  it('comments are stripped', () => {
     const toml = `[arena]\n# this is a comment\ntask = "x"\ncriteria = ["a"]\n\n[[side]]\nname = "a"\nplayer = "c"\ndeck = "a.toml"\n\n[[side]]\nname = "b"\nplayer = "c"\ndeck = "b.toml"`
     const result = parseArenaToml(toml)
     expect(result.arena.task).toBe('x')
@@ -147,7 +147,7 @@ describe('parseArenaToml', () => {
 })
 
 describe('buildExecutionPlan', () => {
-  test('generates plan: 2 sides × 1 run = 2 cells', () => {
+  it('generates plan: 2 sides × 1 run = 2 cells', () => {
     const toml = parseArenaToml(minimalToml)
     const plan = buildExecutionPlan(toml)
     expect(plan.task).toBe('Test task')
@@ -156,20 +156,20 @@ describe('buildExecutionPlan', () => {
     expect(plan.total_runs).toBe(2)
   })
 
-  test('generates plan with judge field populated', () => {
+  it('generates plan with judge field populated', () => {
     const toml = parseArenaToml(judgeToml)
     const plan = buildExecutionPlan(toml)
     expect(plan.judge).toContain('Evaluate completeness')
   })
 
-  test('generates plan: 3 sides × 3 runs = 9 cells', () => {
+  it('generates plan: 3 sides × 3 runs = 9 cells', () => {
     const toml = parseArenaToml(fullToml)
     const plan = buildExecutionPlan(toml)
     expect(plan.cells).toHaveLength(9)
     expect(plan.total_runs).toBe(9)
   })
 
-  test('control flag preserved in plan cells', () => {
+  it('control flag preserved in plan cells', () => {
     const toml = parseArenaToml(fullToml)
     const plan = buildExecutionPlan(toml)
     const baselineCells = plan.cells.filter(c => c.side === 'baseline')
@@ -177,7 +177,7 @@ describe('buildExecutionPlan', () => {
     expect(baselineCells.every(c => c.control)).toBe(true)
   })
 
-  test('dry-run: plan is pure data, no side effects', () => {
+  it('dry-run: plan is pure data, no side effects', () => {
     const toml = parseArenaToml(fullToml)
     const plan = buildExecutionPlan(toml)
     expect(plan.total_runs).toBeGreaterThan(0)

package/src/cli.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'bun:test'
+import { main, defaultArenaCliIO, type ArenaCliIO } from './cli'
+
+// ─── Helpers ───────────────────────────────────────────────────────────────
+
+async function catchExitAsync(fn: () => Promise<void>): Promise<number | undefined> {
+  let exitCode: number | undefined
+  try { await fn() } catch (e: any) {
+    if (!String(e).includes('EXIT:')) throw e
+    const m = String(e).match(/EXIT:(\d+)/)
+    if (m) exitCode = parseInt(m[1], 10)
+  }
+  return exitCode
+}
+
+function mockIO(): { io: Required<ArenaCliIO>; logs: string[]; errors: string[]; warns: string[] } {
+  const logs: string[] = []
+  const errors: string[] = []
+  const warns: string[] = []
+  const io: Required<ArenaCliIO> = {
+    log: (msg: string) => logs.push(msg),
+    error: (msg: string) => errors.push(msg),
+    warn: (msg: string) => warns.push(msg),
+    exit: (code: number) => { throw new Error(`EXIT:${code}`) },
+  }
+  return { io, logs, errors, warns }
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe('main', () => {
+  it('shows help on --help', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['--help'], io)
+    })
+    expect(exitCode).toBe(0)
+    expect(logs.length).toBeGreaterThan(0)
+    expect(logs[0]).toContain('lythoskill-arena')
+    expect(errors.length).toBe(0)
+  })
+
+  it('shows help on -h', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['-h'], io)
+    })
+    expect(exitCode).toBe(0)
+    expect(logs.length).toBeGreaterThan(0)
+    expect(logs[0]).toContain('lythoskill-arena')
+    expect(errors.length).toBe(0)
+  })
+
+  it('shows help on no args', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main([], io)
+    })
+    expect(exitCode).toBe(0)
+    expect(logs.length).toBeGreaterThan(0)
+    expect(errors.length).toBe(0)
+  })
+
+  it('errors on unknown command', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['bogus'], io)
+    })
+    expect(exitCode).toBe(1)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0]).toContain('Unknown command')
+    expect(errors[0]).toContain('bogus')
+  })
+})
+
+describe('singleRun', () => {
+  it('errors when --deck is missing', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['single', '--brief', 'test task'], io)
+    })
+    expect(exitCode).toBe(1)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0]).toContain('--deck')
+    expect(errors[0]).toContain('required')
+  })
+
+  it('errors when both --task and --brief are missing', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['single', '--deck', './some-deck.toml'], io)
+    })
+    expect(exitCode).toBe(1)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0]).toContain('--task')
+    expect(errors[0]).toContain('--brief')
+  })
+
+  it('errors when --brief is empty string', async () => {
+    const { io, logs, errors } = mockIO()
+    const exitCode = await catchExitAsync(async () => {
+      await main(['single', '--deck', './some-deck.toml', '--brief', ''], io)
+    })
+    expect(exitCode).toBe(1)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0]).toContain('--task')
+    expect(errors[0]).toContain('--brief')
+  })
+})
+
+describe('defaultArenaCliIO', () => {
+  it('has all required functions', () => {
+    expect(typeof defaultArenaCliIO.log).toBe('function')
+    expect(typeof defaultArenaCliIO.error).toBe('function')
+    expect(typeof defaultArenaCliIO.warn).toBe('function')
+    expect(typeof defaultArenaCliIO.exit).toBe('function')
+  })
+})