subrouter-cli 0.0.0-stage → 0.1.0

package/test/loop.test.ts

@@ -0,0 +1,387 @@
+// loop.ts tests — scripted fake client driving the round driver: tool→result→answer,
+// permission gate (y/a/n), denial, round cap, budget warnings, abort.
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { runAgentTurn, type Approval, type ChatClient, type ToolProgressPhase } from '../src/loop.ts';
+import { estimateTokens } from '../src/token.ts';
+import { TOOL_DEFINITIONS } from '../src/tools.ts';
+import type { AssistantTurn, ChatMessage, ChatRequest, StreamEvent, ToolCall, ToolDefinition } from '../src/types.ts';
+
+const WRITE_TOOL: ToolDefinition = {
+  name: 'write_file',
+  description: 'write',
+  parameters: { type: 'object' },
+  requiresApproval: true,
+};
+const READ_TOOL: ToolDefinition = {
+  name: 'read_file',
+  description: 'read',
+  parameters: { type: 'object' },
+  requiresApproval: false,
+};
+
+function toolCall(name: string, id = 'call_1'): ToolCall {
+  return { id, name, arguments: { path: 'x' }, argumentsJson: '{"path":"x"}' };
+}
+
+function turnWithCalls(calls: ToolCall[]): AssistantTurn {
+  return {
+    message: { role: 'assistant', content: 'thinking…', toolCalls: calls },
+    stopReason: 'tool_calls',
+    usage: { inputTokens: 10, outputTokens: 5 },
+  };
+}
+
+function finalTurn(content: string): AssistantTurn {
+  return { message: { role: 'assistant', content }, stopReason: 'stop', usage: { inputTokens: 3, outputTokens: 2 } };
+}
+
+/** A scripted client: each chat() call consumes the next script entry and records the request. */
+function scriptedClient(script: AssistantTurn[]): ChatClient & { requests: ChatRequest[] } {
+  const requests: ChatRequest[] = [];
+  return {
+    requests,
+    async chat(req: ChatRequest, _onEvent: (e: StreamEvent) => void): Promise<AssistantTurn> {
+      requests.push(req);
+      const turn = script.shift();
+      if (!turn) throw new Error('script exhausted');
+      return turn;
+    },
+  };
+}
+
+interface Harness {
+  history: ChatMessage[];
+  progress: { phase: ToolProgressPhase; call: ToolCall; note?: string }[];
+  askLog: ToolCall[];
+  executeLog: ToolCall[];
+  budgetLog: (80 | 95)[];
+  requests: ChatRequest[];
+  result: Awaited<ReturnType<typeof runAgentTurn>>;
+}
+
+/** The request size loop.ts sees on the first round (system + user + tool defs). */
+function budgetTotal(): number {
+  const texts = [
+    'system prompt',
+    'do it',
+    `${READ_TOOL.name}${READ_TOOL.description}${JSON.stringify(READ_TOOL.parameters)}`,
+    `${WRITE_TOOL.name}${WRITE_TOOL.description}${JSON.stringify(WRITE_TOOL.parameters)}`,
+  ];
+  return texts.reduce((sum, t) => sum + estimateTokens(t), 0);
+}
+
+async function run(overrides: {
+  script: AssistantTurn[];
+  tools?: ToolDefinition[];
+  ask?: (call: ToolCall) => Promise<Approval>;
+  autoApprove?: boolean;
+  fileApproval?: () => boolean;
+  maxRounds?: number;
+  contextTokens?: number;
+  countTokens?: (model: string, system: string, messages: ChatMessage[], tools?: ToolDefinition[]) => Promise<number>;
+  signal?: AbortSignal;
+}): Promise<Harness> {
+  const client = scriptedClient(overrides.script);
+  const history: ChatMessage[] = [{ role: 'user', content: 'do it' }];
+  const progress: Harness['progress'] = [];
+  const askLog: ToolCall[] = [];
+  const executeLog: ToolCall[] = [];
+  const budgetLog: Harness['budgetLog'] = [];
+  const result = await runAgentTurn({
+    client,
+    model: 'opencode/fake',
+    history,
+    system: 'system prompt',
+    tools: overrides.tools ?? [READ_TOOL, WRITE_TOOL],
+    execute: async (call) => {
+      executeLog.push(call);
+      return { toolCallId: call.id, content: 'tool ok' };
+    },
+    ask: async (call) => {
+      askLog.push(call); // log centrally — custom ask callbacks in tests bypass the default
+      return (overrides.ask ?? (async () => 'yes' as Approval))(call);
+    },
+    autoApprove: overrides.autoApprove ?? false,
+    fileApproval: overrides.fileApproval,
+    maxRounds: overrides.maxRounds ?? 3,
+    maxTokens: 1024,
+    contextTokens: overrides.contextTokens,
+    countTokens: overrides.countTokens,
+    signal: overrides.signal ?? new AbortController().signal,
+    onEvent: () => {},
+    onToolProgress: (phase, call, note) => progress.push({ phase, call, note }),
+    onBudget: (p) => budgetLog.push(p),
+  });
+  return { history, progress, askLog, executeLog, budgetLog, requests: client.requests, result };
+}
+
+describe('runAgentTurn', () => {
+  it('live file permission state overrides a captured file approve-all latch', async () => {
+    const denied = await run({
+      script: [turnWithCalls([toolCall('write_file')]), finalTurn('Denied.')],
+      autoApprove: true,
+      fileApproval: () => false,
+      ask: async () => 'no',
+    });
+    assert.equal(denied.askLog.length, 1);
+    assert.equal(denied.executeLog.length, 0);
+    const allowed = await run({
+      script: [turnWithCalls([toolCall('write_file')]), finalTurn('Done.')],
+      autoApprove: false,
+      fileApproval: () => true,
+    });
+    assert.equal(allowed.askLog.length, 0);
+    assert.equal(allowed.executeLog.length, 1);
+  });
+
+  it('drives tool → result → answer and returns the final turn', async () => {
+    const { history, result, executeLog, requests } = await run({
+      script: [turnWithCalls([toolCall('read_file')]), finalTurn('done!')],
+    });
+    assert.equal(result.stopReason, 'stop');
+    assert.equal(result.rounds, 1);
+    assert.deepEqual(result.usage, { inputTokens: 13, outputTokens: 7 }); // summed across rounds
+    assert.deepEqual(history.map((m) => m.role), ['user', 'assistant', 'tool', 'assistant']);
+    assert.equal(history.at(-1)?.content, 'done!');
+    assert.equal(history[2].toolCallId, 'call_1');
+    assert.equal(history[2].content, 'tool ok');
+    assert.equal(executeLog.length, 1);
+    assert.deepEqual(requests[0].messages, [{ role: 'user', content: 'do it' }]); // snapshot before the round
+    assert.deepEqual(requests[1].messages.map((m) => m.role), ['user', 'assistant', 'tool']); // includes the result
+    assert.ok(requests[1].tools);
+  });
+
+  it('permission-gates every filesystem mutation and lets inspection tools run without prompts', async () => {
+    const calls = TOOL_DEFINITIONS.map((tool, i) => toolCall(tool.name, `c${i}`));
+    const { askLog, executeLog, history } = await run({
+      tools: TOOL_DEFINITIONS,
+      script: [turnWithCalls(calls), finalTurn('ok')],
+      ask: async () => 'no',
+    });
+    assert.deepEqual(askLog.map((call) => call.name), TOOL_DEFINITIONS.filter((tool) => tool.requiresApproval).map((tool) => tool.name));
+    assert.deepEqual(executeLog.map((call) => call.name), TOOL_DEFINITIONS.filter((tool) => !tool.requiresApproval).map((tool) => tool.name));
+    assert.equal(history.filter((message) => message.role === 'tool' && message.isError).length, askLog.length);
+  });
+
+  it('terminal commands always ask despite auto-approve or file approve-all', async () => {
+    for (const autoApprove of [false, true]) {
+      const { askLog, executeLog } = await run({
+        tools: TOOL_DEFINITIONS, autoApprove,
+        script: [turnWithCalls([toolCall('write_file', 'f'), toolCall('run_command', 'a'), toolCall('run_command', 'b')]), turnWithCalls([toolCall('run_command', 'c')]), finalTurn('done')],
+        ask: async (call) => call.name === 'write_file' ? 'all' : 'yes',
+      });
+      assert.deepEqual(askLog.filter((call) => call.name === 'run_command').map((call) => call.id), ['a', 'b', 'c']);
+      assert.equal(executeLog.length, 4);
+    }
+  });
+
+  it('terminal all is denied and terminal yes never grants file approval', async () => {
+    const { askLog, executeLog, history } = await run({
+      tools: TOOL_DEFINITIONS,
+      script: [turnWithCalls([toolCall('run_command', 'a'), toolCall('write_file', 'f'), toolCall('run_command', 'b')]), finalTurn('done')],
+      ask: async (call) => call.id === 'a' ? 'all' : call.id === 'b' ? 'yes' : 'no',
+    });
+    assert.deepEqual(askLog.map((call) => call.id), ['a', 'f', 'b']);
+    assert.deepEqual(executeLog.map((call) => call.id), ['b']);
+    assert.equal(history.filter((message) => message.role === 'tool' && message.isError).length, 2);
+  });
+
+  it('pairs every tool call on cancellation during approval, without executing', async () => {
+    const controller = new AbortController();
+    const client = scriptedClient([turnWithCalls([toolCall('run_command', 'a'), toolCall('write_file', 'b')])]);
+    const history: ChatMessage[] = [];
+    let executed = 0;
+    await assert.rejects(runAgentTurn({
+      client, model: 'openai/test', history, system: '', tools: TOOL_DEFINITIONS,
+      ask: async () => { controller.abort(); return 'yes'; },
+      execute: async (call) => { executed++; return { toolCallId: call.id, content: 'bad' }; },
+      autoApprove: false, maxRounds: 3, maxTokens: 1024, signal: controller.signal, onEvent: () => {},
+    }), { name: 'AbortError' });
+    assert.equal(executed, 0);
+    assert.deepEqual(history.map((message) => message.role), ['assistant', 'tool', 'tool']);
+    assert.deepEqual(history.slice(1).map((message) => message.toolCallId), ['a', 'b']);
+    assert.ok(history.slice(1).every((message) => message.isError));
+  });
+
+  it('keeps completed siblings and normalizes execution rejection before propagating cancellation', async () => {
+    const controller = new AbortController();
+    const client = scriptedClient([turnWithCalls([toolCall('run_command', 'a'), toolCall('read_file', 'b'), toolCall('read_file', 'c')])]);
+    const history: ChatMessage[] = [];
+    await assert.rejects(runAgentTurn({
+      client, model: 'openai/test', history, system: '', tools: TOOL_DEFINITIONS,
+      ask: async () => 'yes',
+      execute: async (call, signal) => {
+        assert.equal(signal, controller.signal);
+        if (call.id === 'a') { await new Promise(setImmediate); controller.abort(); return { toolCallId: call.id, content: 'cancelled', isError: true }; }
+        if (call.id === 'b') return { toolCallId: call.id, content: 'completed' };
+        throw new Error('controlled rejection');
+      },
+      autoApprove: false, maxRounds: 3, maxTokens: 1024, signal: controller.signal, onEvent: () => {},
+    }), { name: 'AbortError' });
+    assert.deepEqual(history.slice(1).map((message) => [message.toolCallId, message.content]), [['a', 'cancelled'], ['b', 'completed'], ['c', 'controlled rejection']]);
+  });
+
+  it('does not prompt for read-only tools', async () => {
+    const { askLog } = await run({ script: [turnWithCalls([toolCall('read_file')]), finalTurn('ok')] });
+    assert.equal(askLog.length, 0);
+  });
+
+  it('prompts per call and denies on n, feeding an error result', async () => {
+    const { history, askLog, executeLog, progress } = await run({
+      script: [turnWithCalls([toolCall('write_file', 'c1'), toolCall('write_file', 'c2')]), finalTurn('ok')],
+      ask: async (call) => (call.id === 'c1' ? 'no' : 'yes'),
+    });
+    assert.equal(askLog.length, 2);
+    assert.equal(executeLog.length, 1); // only c2 ran
+    const denied = history.find((m) => m.toolCallId === 'c1');
+    assert.equal(denied?.isError, true);
+    assert.deepEqual(JSON.parse(denied?.content ?? '{}'), { error: 'Tool call denied by user' });
+    assert.deepEqual(progress.map((p) => p.phase), ['start', 'start', 'denied', 'done']);
+  });
+
+  it('approve-all stops prompting for the rest of the session', async () => {
+    const { askLog, executeLog } = await run({
+      script: [
+        turnWithCalls([toolCall('write_file', 'c1')]),
+        turnWithCalls([toolCall('write_file', 'c2')]),
+        finalTurn('ok'),
+      ],
+      ask: async () => 'all',
+    });
+    assert.equal(askLog.length, 1); // only the first write prompted
+    assert.equal(executeLog.length, 2);
+  });
+
+  it('autoApprove skips the gate entirely', async () => {
+    const { askLog, executeLog } = await run({
+      script: [turnWithCalls([toolCall('write_file')]), finalTurn('ok')],
+      autoApprove: true,
+    });
+    assert.equal(askLog.length, 0);
+    assert.equal(executeLog.length, 1);
+  });
+
+  it('caps rounds with a stop message', async () => {
+    const { result, history, executeLog } = await run({
+      script: Array.from({ length: 2 }, () => turnWithCalls([toolCall('read_file')])), // every round asks for tools
+      maxRounds: 2,
+    });
+    assert.equal(result.stopReason, 'length');
+    assert.equal(executeLog.length, 2);
+    assert.equal(history.at(-1)?.content, '(stopped after too many tool calls)');
+  });
+
+  it('fires the 95% budget warning once across rounds', async () => {
+    const total = budgetTotal();
+    const { budgetLog } = await run({
+      script: [turnWithCalls([toolCall('read_file')]), finalTurn('ok')],
+      contextTokens: Math.floor(total / 0.95), // just over the 95% threshold
+    });
+    assert.deepEqual(budgetLog, [95]);
+  });
+
+  it('fires only the 80% warning when between thresholds', async () => {
+    const total = budgetTotal();
+    const { budgetLog } = await run({
+      script: [finalTurn('ok')], // single round — the request fits between the thresholds
+      contextTokens: Math.floor(total / 0.8), // over 80%, under 95%
+    });
+    assert.deepEqual(budgetLog, [80]);
+  });
+
+  it('uses the exact counter when injected', async () => {
+    const { budgetLog } = await run({
+      script: [finalTurn('ok')],
+      contextTokens: 1000, // the estimate alone would never trip this window
+      countTokens: async () => 2000,
+    });
+    assert.deepEqual(budgetLog, [95]);
+  });
+
+  it('falls back to the estimate when the exact counter fails', async () => {
+    const total = budgetTotal();
+    const { budgetLog } = await run({
+      script: [finalTurn('ok')],
+      contextTokens: Math.floor(total / 0.95), // estimate trips 95%
+      countTokens: async () => {
+        throw new Error('counter down');
+      },
+    });
+    assert.deepEqual(budgetLog, [95]);
+  });
+
+  it('throws an AbortError on an aborted signal', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    await assert.rejects(
+      () =>
+        runAgentTurn({
+          client: scriptedClient([finalTurn('never')]),
+          model: 'opencode/fake',
+          history: [{ role: 'user', content: 'hi' }],
+          system: 's',
+          tools: [READ_TOOL],
+          execute: async (c) => ({ toolCallId: c.id, content: 'ok' }),
+          ask: async () => 'no',
+          autoApprove: false,
+          maxRounds: 3,
+          maxTokens: 1024,
+          signal: controller.signal,
+          onEvent: () => {},
+        }),
+      (err: unknown) => err instanceof DOMException && err.name === 'AbortError',
+    );
+  });
+
+  it('passes text and reasoning events straight through', async () => {
+    const events: StreamEvent[] = [];
+    const script: AssistantTurn[] = [finalTurn('ok')];
+    const client = {
+      async chat(_req: ChatRequest, onEvent: (e: StreamEvent) => void): Promise<AssistantTurn> {
+        onEvent({ kind: 'text', text: 'a' });
+        onEvent({ kind: 'reasoning', text: 'b' });
+        return script.shift() as AssistantTurn;
+      },
+    };
+    await runAgentTurn({
+      client,
+      model: 'opencode/fake',
+      history: [{ role: 'user', content: 'hi' }],
+      system: 's',
+      tools: [READ_TOOL],
+      execute: async (c) => ({ toolCallId: c.id, content: 'ok' }),
+      ask: async () => 'no',
+      autoApprove: false,
+      maxRounds: 3,
+      maxTokens: 1024,
+      signal: new AbortController().signal,
+      onEvent: (e) => events.push(e),
+    });
+    assert.deepEqual(events.map((e) => e.kind), ['text', 'reasoning']);
+  });
+
+  it('marks failed tool executions as errors', async () => {
+    const client = scriptedClient([turnWithCalls([toolCall('read_file')]), finalTurn('ok')]);
+    const phases: { phase: ToolProgressPhase }[] = [];
+    const h: ChatMessage[] = [{ role: 'user', content: 'hi' }];
+    await runAgentTurn({
+      client,
+      model: 'opencode/fake',
+      history: h,
+      system: 's',
+      tools: [READ_TOOL],
+      execute: async (c) => ({ toolCallId: c.id, content: 'boom', isError: true }),
+      ask: async () => 'no',
+      autoApprove: false,
+      maxRounds: 3,
+      maxTokens: 1024,
+      signal: new AbortController().signal,
+      onEvent: () => {},
+      onToolProgress: (phase) => phases.push({ phase }),
+    });
+    assert.equal(h[2].isError, true);
+    assert.deepEqual(phases.map((p) => p.phase), ['start', 'error']);
+  });
+});

package/test/m5.test.ts

@@ -0,0 +1,127 @@
+// M5 tests: sessions transcripts, usage rendering, and the pure line-editor core.
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { editLine } from '../src/lineinput.ts';
+import { appendMarkdown, appendRecord, startSession, type TurnRecord } from '../src/sessions.ts';
+import { bar, renderUsage } from '../src/usage.ts';
+
+describe('sessions', () => {
+  it('creates a chmod-600 transcript pair and appends', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-sessions-'));
+    const session = startSession(dir);
+    assert.ok(session.id.startsWith('sess-'));
+    assert.ok(fs.existsSync(session.mdPath));
+    assert.ok(fs.existsSync(session.jsonlPath));
+    assert.equal(fs.statSync(session.mdPath).mode & 0o777, 0o600);
+    assert.equal(fs.statSync(session.jsonlPath).mode & 0o777, 0o600);
+    const header = fs.readFileSync(session.mdPath, 'utf8');
+    assert.match(header, /^# sub session sess-/);
+    appendMarkdown(session, 'hello');
+    assert.match(fs.readFileSync(session.mdPath, 'utf8'), /hello/);
+    const record: TurnRecord = {
+      type: 'turn',
+      ts: '2026-10-10T00:00:00.000Z',
+      model: 'opencode/fake',
+      stopReason: 'stop',
+      rounds: 0,
+      messages: [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'yo' }],
+    };
+    appendRecord(session, record);
+    const lines = fs.readFileSync(session.jsonlPath, 'utf8').trim().split('\n');
+    assert.equal(lines.length, 1);
+    assert.deepEqual(JSON.parse(lines[0]), record);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
+
+describe('bar', () => {
+  it('scales percents to a 20-char block bar', () => {
+    assert.equal(bar(0), '░'.repeat(20));
+    assert.equal(bar(100), '█'.repeat(20));
+    assert.equal(bar(50), '█'.repeat(10) + '░'.repeat(10));
+    assert.equal(bar(-5), '░'.repeat(20)); // clamped
+    assert.equal(bar(120), '█'.repeat(20)); // clamped
+    assert.equal(bar('nope'), 'unknown'); // never a fabricated number
+  });
+});
+
+describe('renderUsage', () => {
+  it('renders the live user-quota shape with null limits as unlimited', () => {
+    const lines = renderUsage({
+      user: {
+        rpm_limit: 60,
+        daily_token_limit: null,
+        today_tokens: 250000,
+        resets_at: '2026-10-11T00:00:00.000Z',
+        weekly_usd_limit: 5,
+        week_usd: 1.25,
+      },
+      pools: [],
+    });
+    assert.match(lines[0], /60 rpm · 250,000 tokens today \/ unlimited · \$5\/week · \$1\.25 used · resets 2026-10-11/);
+  });
+
+  it('keeps the documented quotas-key fallback', () => {
+    const lines = renderUsage({
+      quotas: { rpm_limit: 60, daily_token_limit: 1000000, weekly_usd_limit: 5, daily_tokens_used: 250000 },
+      pools: [],
+    });
+    // today_tokens is absent from the docs' shape — reported unknown, never zero
+    assert.match(lines[0], /60 rpm · unknown tokens today \/ 1,000,000 · \$5\/week/);
+  });
+
+  it('renders live provider/window pool bars', () => {
+    const lines = renderUsage({
+      pools: [
+        { provider: 'opencode', window: '7d', used_percent: 57, resets_at: 1791763200 },
+        { provider: 'grok', window: 'weekly', used_percent: 'nope', resets_at: '2026-10-11T04:00:00Z' },
+      ],
+    });
+    assert.equal(lines[1], 'pools:');
+    const expectedReset = new Date(1791763200 * 1000).toISOString().slice(0, 16);
+    assert.match(lines[2], new RegExp(`opencode 7d █{11}░{9} 57% · resets ${expectedReset}`));
+    assert.match(lines[3], /grok weekly unknown unknown · resets 2026-10-11/);
+  });
+
+  it('tolerates missing everything without fabricating zeros', () => {
+    const lines = renderUsage({});
+    assert.equal(lines.length, 1);
+    assert.match(lines[0], /unknown rpm/);
+    const lines2 = renderUsage('garbage');
+    assert.equal(lines2[0], 'usage: unrecognized response');
+  });
+});
+
+describe('editLine', () => {
+  const s = (buffer = '', cursor = 0): { buffer: string; cursor: number } => ({ buffer, cursor });
+
+  it('inserts characters at the cursor', () => {
+    assert.deepEqual(editLine('ab', s()), { buffer: 'ab', cursor: 2 });
+    const mid = editLine('x', s('ab', 1));
+    assert.equal(mid.buffer, 'axb');
+    assert.equal(mid.cursor, 2);
+  });
+
+  it('backspaces at the cursor', () => {
+    assert.deepEqual(editLine('\x7f', s('ab', 2)), { buffer: 'a', cursor: 1 });
+    assert.deepEqual(editLine('\x7f', s('ab', 0)), { buffer: 'ab', cursor: 0 }); // nothing to delete
+  });
+
+  it('supports Ctrl+A/E/U/K', () => {
+    assert.equal(editLine('\x01', s('abc', 3)).cursor, 0);
+    assert.equal(editLine('\x05', s('abc', 0)).cursor, 3);
+    assert.deepEqual(editLine('\x15', s('abc', 3)), { buffer: '', cursor: 0 });
+    assert.deepEqual(editLine('\x0b', s('abc', 1)), { buffer: 'a', cursor: 1 });
+  });
+
+  it('submits on newline and interrupts on Ctrl+C', () => {
+    assert.equal(editLine('\r', s('done')).submit, 'done');
+    const interrupted = editLine('\x03', s('partial', 4));
+    assert.equal(interrupted.interrupt, true);
+    assert.deepEqual({ buffer: interrupted.buffer, cursor: interrupted.cursor }, { buffer: '', cursor: 0 });
+  });
+});