subrouter-cli 0.0.0-stage → 0.1.0

package/test/markdown.test.ts

@@ -0,0 +1,201 @@
+// Markdown renderer. Colors are gated on process.stdout.isTTY, so we fake a TTY before
+// the module's first import (node --test isolates each file in its own process, so the
+// dynamic import here is the module's only load) and assert real ANSI sequences.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+test('renderMarkdown styles headings, bold, code, lists and drops link URLs', async () => {
+  Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+  const { renderMarkdown } = await import('../src/markdown.ts');
+
+  const md = [
+    '# Title',
+    '',
+    'Some **bold** and `code` and [a link](https://x.example/path).',
+    '',
+    '```ts',
+    'const x = 1;',
+    '```',
+    '',
+    '- item',
+    '1. first',
+    '',
+    '- [x] done',
+  ].join('\n');
+
+  const out = renderMarkdown(md);
+
+  assert.match(out, /\x1b\[1m# Title\x1b\[0m/); // heading is bold
+  assert.match(out, /\x1b\[1mbold\x1b\[0m/); // **bold**
+  assert.match(out, /\x1b\[38;2;166;116;255m\x1b\[1m# Title/); // violet heading
+  assert.match(out, /\x1b\[38;2;143;167;255mcode\x1b\[0m/); // blue code span
+  assert.match(out, /\x1b\[38;2;143;167;255mconst x = 1;\x1b\[0m/); // blue fenced block
+  assert.match(out, /\x1b\[38;2;143;167;255m- \x1b\[0mitem/); // blue bullet
+  assert.match(out, /\x1b\[38;2;143;167;255m1\. \x1b\[0mfirst/); // blue number
+  assert.match(out, /\x1b\[92m☒ \x1b\[0mdone/); // task checkbox
+  assert.ok(out.includes('a link')); // link text kept…
+  assert.ok(!out.includes('https://x.example/path')); // …URL dropped
+});
+
+test('streamed replies trim boundary gaps and collapse prose spacing without changing code blocks', async () => {
+  const { MarkdownStream } = await import('../src/markdown.ts');
+  const { ui } = await import('../src/ui.ts');
+  const { stripVTControlCharacters } = await import('node:util');
+  const output: string[] = [];
+  const say = ui.say, streamText = ui.streamText;
+  ui.say = (line) => { output.push(line + '\n'); };
+  ui.streamText = (text) => { output.push(text); };
+  try {
+    const md = new MarkdownStream();
+    md.write('\n'); md.write('\nHi.\n\n\n\nParagraph.\n\n'); md.flush();
+    assert.equal(stripVTControlCharacters(output.join('')), 'Hi.\n\nParagraph.\n');
+    output.length = 0;
+    const code = new MarkdownStream();
+    code.write('\n\n```ts\nconst first = 1;\n\n\nconst second = 2;\n```\n\n\n');
+    code.flush();
+    assert.equal(stripVTControlCharacters(output.join('')), '```ts\nconst first = 1;\n\n\nconst second = 2;\n```\n');
+  } finally {
+    ui.say = say;
+    ui.streamText = streamText;
+  }
+});
+
+test('partial prose is appended immediately without repainting or duplicate flush output', async () => {
+  const { MarkdownStream } = await import('../src/markdown.ts');
+  const { ui } = await import('../src/ui.ts');
+  const output: string[] = [];
+  const say = ui.say, streamText = ui.streamText, rewrite = ui.rewrite;
+  ui.say = (line) => { output.push(line + '\n'); };
+  ui.streamText = (text) => { output.push(text); };
+  ui.rewrite = () => { assert.fail('streaming Markdown must not repaint wrapped text'); };
+  try {
+    const md = new MarkdownStream();
+    md.write('The image shows ');
+    assert.equal(output.join(''), 'The image shows '); // no newline or flush
+    const long = 'a wide scene '.repeat(30);
+    md.write(long);
+    assert.equal(output.join(''), 'The image shows ' + long);
+    md.write('and follows the steering request.');
+    const visible = output.join('');
+    md.flush(); md.flush();
+    assert.equal(output.join(''), visible);
+    assert.ok(!visible.includes('\n')); // ui.endTurn() owns the trailing newline
+  } finally {
+    ui.say = say;
+    ui.streamText = streamText;
+    ui.rewrite = rewrite;
+  }
+});
+
+test('chunked inline styles and fenced code remain styled while their content streams', async () => {
+  Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+  const { MarkdownStream } = await import('../src/markdown.ts');
+  const { ui, accent, bold, dim } = await import('../src/ui.ts');
+  const { stripVTControlCharacters: strip } = await import('node:util');
+  const output: string[] = [];
+  const say = ui.say, streamText = ui.streamText;
+  ui.say = (line) => { output.push(line + '\n'); };
+  ui.streamText = (text) => { output.push(text); };
+  try {
+    const md = new MarkdownStream();
+    md.write('Some *');
+    assert.equal(strip(output.join('')), 'Some ');
+    md.write('*bo');
+    assert.ok(output.join('').includes(bold('bo')));
+    md.write('ld*'); md.write('* and `co');
+    assert.ok(output.join('').includes(accent('co')));
+    md.write('de` and [a li'); md.write('nk](https://x.example'); md.write('/path).\n');
+    assert.equal(strip(output.join('')), 'Some bold and code and a link.\n');
+    assert.ok(!output.join('').includes('https://'));
+    assert.ok(output.join('').includes(accent('a link')));
+
+    output.length = 0;
+    const code = new MarkdownStream();
+    code.write('`'); code.write('`'); code.write('`ts\nconst ');
+    assert.equal(strip(output.join('')), '```ts\nconst ');
+    assert.ok(output.join('').includes(accent('const ')));
+    code.write('x = **literal**;\n\n  \n# literal\n`'); code.write('``');
+    code.write('\nAfter **bo'); code.write('ld**'); code.flush();
+    assert.equal(strip(output.join('')), '```ts\nconst x = **literal**;\n\n  \n# literal\n```\nAfter bold');
+    assert.ok(output.join('').includes(accent('x = **literal**;')));
+    assert.ok(output.join('').includes(accent('# literal')));
+    assert.ok(output.join('').includes(dim('```')));
+    assert.ok(output.join('').includes(bold('bo'))); // normal Markdown resumes after code
+
+    output.length = 0;
+    const fallback = new MarkdownStream();
+    const bracket = '[' + 'ordinary bracketed prose '.repeat(20);
+    fallback.write(bracket);
+    assert.equal(strip(output.join('')), bracket); // lookahead cannot swallow a long reply
+    fallback.write(' **still'); fallback.write(' styled**\nUnclosed **bold\nNormal `code`');
+    fallback.flush();
+    assert.equal(strip(output.join('')), bracket + ' still styled\nUnclosed bold\nNormal code');
+    assert.ok(output.join('').includes(bold('still')));
+    assert.ok(output.join('').includes(accent('code'))); // fallback and line end reset styles
+  } finally {
+    ui.say = say;
+    ui.streamText = streamText;
+  }
+});
+
+test('chunked line prefixes retain headings, list markers and task checkboxes', async () => {
+  const { MarkdownStream } = await import('../src/markdown.ts');
+  const { ui, accent, violet, bold, green, dim } = await import('../src/ui.ts');
+  const { stripVTControlCharacters: strip } = await import('node:util');
+  const output: string[] = [];
+  const say = ui.say, streamText = ui.streamText;
+  ui.say = (line) => { output.push(line + '\n'); };
+  ui.streamText = (text) => { output.push(text); };
+  try {
+    const md = new MarkdownStream();
+    for (const chunk of ['#', ' Title\n-', ' item\n1', '. first\n- [', 'x', '] done\n>', ' quote']) md.write(chunk);
+    md.flush();
+    const out = output.join('');
+    assert.equal(strip(out), '# Title\n- item\n1. first\n☒ done\n> quote');
+    assert.ok(out.includes(violet(bold('# Title'))));
+    assert.ok(out.includes(accent('- ')));
+    assert.ok(out.includes(accent('1. ')));
+    assert.ok(out.includes(green('☒ ')));
+    assert.ok(out.includes(dim(' quote')));
+  } finally {
+    ui.say = say;
+    ui.streamText = streamText;
+  }
+});
+
+test('partial prose defers blank gaps until content and drops whitespace-only tails', async () => {
+  const { MarkdownStream } = await import('../src/markdown.ts');
+  const { ui } = await import('../src/ui.ts');
+  const output: string[] = [];
+  const say = ui.say, streamText = ui.streamText;
+  ui.say = (line) => { output.push(line + '\n'); };
+  ui.streamText = (text) => { output.push(text); };
+  try {
+    const md = new MarkdownStream();
+    md.write(' \n\t\n  ');
+    assert.equal(output.join(''), '');
+    md.write('Hello');
+    assert.equal(output.join(''), '  Hello');
+    md.write('\n\n \n\t\n ');
+    assert.equal(output.join(''), '  Hello\n');
+    md.write('Next');
+    assert.equal(output.join(''), '  Hello\n\n Next');
+    md.write('\n\n\n   '); md.flush();
+    assert.equal(output.join(''), '  Hello\n\n Next\n');
+  } finally {
+    ui.say = say;
+    ui.streamText = streamText;
+  }
+});
+
+test('code fences protect their content from heading/list parsing', async () => {
+  Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+  const { renderMarkdown } = await import('../src/markdown.ts');
+
+  const out = renderMarkdown('```\n# not a heading\n- not a list\n```');
+  // Inner lines use the code accent, not heading/bullet styles.
+  assert.ok(!/\x1b\[1m# not a heading/.test(out));
+  assert.ok(!out.includes('\x1b[38;2;166;116;255m'));
+  assert.match(out, /\x1b\[38;2;143;167;255m# not a heading\x1b\[0m/);
+});

package/test/repl-ui.test.ts

@@ -0,0 +1,293 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+import { stripVTControlCharacters } from 'node:util';
+
+test('REPL panel follows model/provider, hides reasoning and restores the terminal', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-repl-ui-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', `
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    const { startRepl } = await import('./src/repl.ts');
+    const client = {
+      listModels: async () => [
+        { id: 'openai/first', contextLength: 32000 },
+        { id: 'deepseek/second', contextLength: 64000 },
+      ],
+      usage: async () => ({ user: { rpm_limit: 60, today_tokens: 1000, daily_token_limit: 1000000, week_usd: 2, weekly_usd_limit: 10 }, pools: [
+        { provider: 'openai', window: '5h', used_percent: 30 },
+        { provider: 'deepseek', window: '5h', used_percent: 80 },
+      ] }),
+      chat: async (req, onEvent) => {
+        onEvent({ kind: 'reasoning', text: 'PRIVATE_REASONING_SHOULD_NOT_APPEAR' });
+        onEvent({ kind: 'text', text: 'Hello **world**.\\n' });
+        return {
+          message: { role: 'assistant', content: 'Hello **world**.\\n' },
+          stopReason: 'stop', usage: { inputTokens: 12, outputTokens: 7 },
+        };
+      },
+    };
+    startRepl({ client, model: 'openai/first', config: {
+      maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false,
+    } });
+    const settle = async () => {
+      await new Promise(setImmediate);
+      await new Promise(setImmediate);
+    };
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    await settle();
+    key('/model\\r');
+    await settle();
+    key('\\x1b[B\\r');
+    await settle();
+    key('hello\\r');
+    await settle();
+    key('/exit\\r');
+    await settle();
+  `], {
+    cwd: new URL('..', import.meta.url),
+    encoding: 'utf8', timeout: 10000,
+    env: { ...process.env, HOME: home, NO_COLOR: '' },
+  });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  const output = stripVTControlCharacters(child.stdout.replace(/\x1b[78]/g, ''));
+  assert.match(output, /model set to deepseek\/second/);
+  assert.match(output, /deepseek: 5h 20% available/);
+  assert.match(output, /12 in \/ 7 out · deepseek/);
+  assert.ok(!output.includes('PRIVATE_REASONING_SHOULD_NOT_APPEAR'));
+  assert.match(output, /Hello /);
+  assert.match(output, /account: 60 rpm · day 1K\/1M tokens · week \$2\/\$10/);
+  assert.ok(child.stdout.includes('\x1b[1;18r'));
+  assert.ok(child.stdout.includes('\x1b[r'));
+  assert.match(output, /bye/);
+  const config = JSON.parse(fs.readFileSync(path.join(home, '.config/subrouter-cli/config.json'), 'utf8'));
+  assert.equal(config.default_model, 'deepseek/second');
+});
+
+test('palette executes commands and live usage refreshes below input without printing into chat', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-command-ui-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    const { ui } = await import('./src/ui.ts');
+    const { startRepl } = await import('./src/repl.ts');
+    const chat = [];
+    let panel = [];
+    const say = ui.say.bind(ui);
+    ui.say = (text) => { chat.push(text); say(text); };
+    const showPanel = ui.panel.bind(ui);
+    ui.panel = (lines, ...rest) => { panel = lines; return showPanel(lines, ...rest); };
+    let usageCalls = 0;
+    const client = {
+      listModels: async () => [{ id: 'openai/first' }, { id: 'anthropic/second' }],
+      usage: async () => {
+        usageCalls++;
+        return { user: { rpm_limit: 60, today_tokens: 100, daily_token_limit: 1000 }, pools: [
+          { provider: 'openai', window: '5h', used_percent: 90 },
+          { provider: 'anthropic', window: '5h', used_percent: usageCalls * 10 },
+        ] };
+      },
+      chat: async () => { throw new Error('commands must never reach the agent'); },
+    };
+    startRepl({ client, model: 'openai/first', config: {
+      maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false,
+    } });
+    const settle = async () => { await new Promise(setImmediate); await new Promise(setImmediate); };
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    await settle();
+    key('/\r'); await settle(); // palette -> model picker
+    key('\x1b[B\r'); await settle();
+    key('/'); key('\x1b[B\x1b[B\r'); await settle(); // palette -> usage
+    assert.match(panel.join('\n'), /anthropic: 5h 90% available/);
+    assert.ok(!panel.join('\n').includes('openai'));
+    key('r'); await settle();
+    assert.equal(usageCalls, 2);
+    assert.match(panel.join('\n'), /anthropic: 5h 80% available/);
+    key('\r'); await settle();
+    key('/unknown\r'); await settle();
+    key('/clear\r'); await settle();
+    assert.ok(!chat.some((line) => /model set|quota:|account:|unknown command|conversation cleared/.test(line)));
+    key('/exit\r'); await settle();
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8', timeout: 10000,
+    env: { ...process.env, HOME: home, NO_COLOR: '' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.match(child.stdout, /bye/);
+  assert.ok(child.stdout.includes('\x1b[r'));
+});
+
+test('effort picker persists selection and file-write chunks update one live preview', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-live-code-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    import fs from 'node:fs';
+    import path from 'node:path';
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    const { ui } = await import('./src/ui.ts');
+    const { startRepl } = await import('./src/repl.ts');
+    const previews = [];
+    const chat = [];
+    const preview = ui.preview.bind(ui);
+    ui.preview = (title, lines) => { previews.push({ title, lines }); preview(title, lines); };
+    const say = ui.say.bind(ui);
+    ui.say = (line) => { chat.push(line); say(line); };
+    process.chdir(process.env.HOME);
+    let calls = 0;
+    let completed = false;
+    const client = {
+      listModels: async () => [{ id: 'openai/first' }], usage: async () => ({}),
+      chat: async (req, emit) => {
+        assert.equal(req.effort, 'high');
+        if (++calls === 1) {
+          emit({ kind: 'tool_call_start', index: 0, id: 'write1', name: 'write_file' });
+          emit({ kind: 'tool_call_args', index: 0, delta: '{"path":"preview.ts","content":"const first = 1;' });
+          await new Promise((resolve) => setTimeout(resolve, 45));
+          emit({ kind: 'tool_call_args', index: 0, delta: '\\nconst second = 2;"}' });
+          await new Promise((resolve) => setTimeout(resolve, 45));
+          const args = { path: 'preview.ts', content: 'const first = 1;\nconst second = 2;' };
+          return { message: { role: 'assistant', content: '', toolCalls: [{ id: 'write1', name: 'write_file', arguments: args, argumentsJson: JSON.stringify(args) }] }, stopReason: 'tool_calls' };
+        }
+        emit({ kind: 'text', text: 'Done.\n' });
+        completed = true;
+        return { message: { role: 'assistant', content: 'Done.\n' }, stopReason: 'stop' };
+      },
+    };
+    startRepl({ client, model: 'openai/first', config: { maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: true } });
+    const settle = async () => { await new Promise(setImmediate); await new Promise(setImmediate); };
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    await settle(); key('/effort\r'); await settle();
+    key('\x1b[B\x1b[B\x1b[B\r'); await settle();
+    key('/effort invalid\r'); await settle();
+    key('write the file\r');
+    const deadline = Date.now() + 3000;
+    while (!completed && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 20));
+    await settle();
+    assert.equal(completed, true);
+    assert.ok(previews.some((p) => p.lines.length === 1 && p.lines[0].includes('first')));
+    assert.ok(previews.some((p) => p.lines.some((line) => line.includes('second'))));
+    assert.equal(fs.readFileSync('preview.ts', 'utf8'), 'const first = 1;\nconst second = 2;');
+    assert.ok(!chat.some((line) => /write_file|const first|const second/.test(line)));
+    const config = JSON.parse(fs.readFileSync(path.join(process.env.HOME, '.config/subrouter-cli/config.json'), 'utf8'));
+    assert.equal(config.reasoning_effort, 'high');
+    key('/exit\r'); await settle();
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8', timeout: 10000,
+    env: { ...process.env, HOME: home, NO_COLOR: '' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+});
+
+test('parallel disk tools leave no spinner timers repainting after completion', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-parallel-tools-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    import fs from 'node:fs';
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    delete process.env.NO_COLOR;
+    process.chdir(process.env.HOME);
+    fs.writeFileSync('fixture.txt', 'hello world\n');
+    const { ui } = await import('./src/ui.ts');
+    const { startRepl } = await import('./src/repl.ts');
+    const lateActivity = [];
+    let completed = false;
+    const activity = ui.activity.bind(ui);
+    ui.activity = (label, text) => {
+      if (completed) lateActivity.push({ label, text });
+      return activity(label, text);
+    };
+    let rounds = 0;
+    const client = {
+      listModels: async () => [{ id: 'openai/test' }],
+      usage: async () => ({}),
+      chat: async (_req, emit) => {
+        if (++rounds === 1) {
+          const calls = [
+            { id: 'g1', name: 'grep', arguments: { pattern: 'hello', path: '.' } },
+            { id: 'g2', name: 'grep', arguments: { pattern: 'world', path: '.' } },
+            { id: 'r1', name: 'read_file', arguments: { path: 'fixture.txt' } },
+          ].map((call) => ({ ...call, argumentsJson: JSON.stringify(call.arguments) }));
+          calls.forEach((call, index) => emit({ kind: 'tool_call_start', index, id: call.id, name: call.name }));
+          return { message: { role: 'assistant', content: '', toolCalls: calls }, stopReason: 'tool_calls' };
+        }
+        emit({ kind: 'text', text: 'Done.\n' });
+        completed = true;
+        return { message: { role: 'assistant', content: 'Done.\n' }, stopReason: 'stop' };
+      },
+    };
+    startRepl({ client, model: 'openai/test', config: {
+      maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false,
+    } });
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    await new Promise(setImmediate);
+    key('search and read\r');
+    const deadline = Date.now() + 3000;
+    while (!completed && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(completed, true);
+    await new Promise((resolve) => setTimeout(resolve, 650));
+    assert.deepEqual(lateActivity, [], 'completed tools must not repaint the live card');
+    key('/exit\r');
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8', timeout: 10000,
+    env: { ...process.env, HOME: home, NO_COLOR: '' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  const output = stripVTControlCharacters(child.stdout.replace(/\x1b[78]/g, ''));
+  assert.match(output, /3 tools · ✓ read_file/);
+  assert.match(output, /bye/);
+});
+
+test('Ctrl+C still cancels a streaming turn while the anchored input is paused', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-repl-abort-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', `
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 80 });
+    process.stdin.setRawMode = () => {};
+    const { startRepl } = await import('./src/repl.ts');
+    const client = {
+      listModels: async () => [{ id: 'openai/test' }],
+      usage: async () => ({}),
+      chat: async (_req, _onEvent, signal) => new Promise((_resolve, reject) => {
+        signal.addEventListener('abort', () => reject(new DOMException('stopped', 'AbortError')), { once: true });
+      }),
+    };
+    startRepl({ client, model: 'openai/test', config: {
+      maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false,
+    } });
+    const settle = async () => {
+      await new Promise(setImmediate);
+      await new Promise(setImmediate);
+    };
+    await settle();
+    process.stdin.emit('data', Buffer.from('hello\\r'));
+    await settle();
+    process.stdin.emit('data', Buffer.from('\\x03'));
+    await settle();
+    process.stdin.emit('data', Buffer.from('/exit\\r'));
+    await settle();
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8', timeout: 10000,
+    env: { ...process.env, HOME: home, NO_COLOR: '' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.match(child.stdout, /\*\[stopped\]\*/);
+  assert.match(child.stdout, /bye/);
+  assert.ok(child.stdout.includes('\x1b[r'));
+});

package/test/sse.test.ts

@@ -0,0 +1,74 @@
+// SSE frame parser tests — all offline, chunked at various boundaries.
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { sseFrames, type SseFrame } from '../src/sse.ts';
+
+function streamFrom(text: string, chunkSize?: number): ReadableStream<Uint8Array> {
+  const bytes = new TextEncoder().encode(text);
+  return new ReadableStream({
+    start(controller) {
+      if (!chunkSize) {
+        controller.enqueue(bytes);
+      } else {
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+          controller.enqueue(bytes.slice(i, i + chunkSize));
+        }
+      }
+      controller.close();
+    },
+  });
+}
+
+async function frames(text: string, chunkSize?: number): Promise<SseFrame[]> {
+  const result: SseFrame[] = [];
+  for await (const frame of sseFrames(streamFrom(text, chunkSize))) {
+    result.push(frame);
+  }
+  return result;
+}
+
+describe('sseFrames', () => {
+  it('parses simple frames', async () => {
+    assert.deepEqual(await frames('data: a\n\ndata: b\n\n'), [{ data: 'a' }, { data: 'b' }]);
+  });
+
+  it('passes [DONE] through for the caller', async () => {
+    assert.deepEqual(await frames('data: [DONE]\n\n'), [{ data: '[DONE]' }]);
+  });
+
+  it('handles byte-by-byte chunking identically', async () => {
+    const text = 'data: {"a":1}\n\ndata: {"b":2}\n\n';
+    assert.deepEqual(await frames(text, 1), await frames(text));
+  });
+
+  it('splits a frame across reads', async () => {
+    assert.deepEqual(await frames('data: hello\n\n', 3), [{ data: 'hello' }]);
+  });
+
+  it('handles CRLF endings', async () => {
+    assert.deepEqual(await frames('data: x\r\n\r\ndata: y\r\n\r\n'), [{ data: 'x' }, { data: 'y' }]);
+  });
+
+  it('joins multi-line data with newlines', async () => {
+    assert.deepEqual(await frames('data: line1\ndata: line2\n\n'), [{ data: 'line1\nline2' }]);
+  });
+
+  it('ignores comments and captures event names', async () => {
+    assert.deepEqual(await frames(': keepalive\nevent: message_start\ndata: {}\n\n'), [
+      { data: '{}', event: 'message_start' },
+    ]);
+  });
+
+  it('ignores id:/retry: fields without ending the frame', async () => {
+    assert.deepEqual(await frames('id: 1\nretry: 100\ndata: z\n\n'), [{ data: 'z' }]);
+  });
+
+  it('skips empty data payloads (heartbeats)', async () => {
+    assert.deepEqual(await frames('data: \n\ndata: real\n\n'), [{ data: 'real' }]);
+  });
+
+  it('emits a trailing frame without a blank line at EOF', async () => {
+    assert.deepEqual(await frames('data: tail'), [{ data: 'tail' }]);
+  });
+});