Add batch reads, @file completion, interruptible commands, tool sets

Tools, six built-in to fourteen: - read_many_files: up to 20 paths read concurrently, each with its own window. An unreadable path is reported in its own block instead of throwing. - multi_edit: several edits to one file, validated in memory first so a late failure cannot leave the file half-written. - list_dir: ignore-aware depth-limited tree. - git_status/diff/log/show/blame: read-only, spawned with a fixed argv rather than a shell string, which is what makes them safe to auto-approve. toolSets gates them. core is always on; edit-plus and git are optional. A disabled set reaches neither the wire nor the system prompt, since a prompt naming an absent tool teaches calls that cannot succeed. Interface: - Reasoning streams to a collapsed panel, ctrl-r expands, dropped when the turn ends: it is progress, not the answer. - The tool in flight is named from tool-input-start, before its arguments finish streaming, and cleared on its result. - Prompts typed mid-turn queue and drain in order. esc clears the queue as well as aborting. - @ opens a path picker fed by the ignore-aware walker. Prefix matches rank above substring matches, so @src/ means "under src/". The walk runs on the first @, not at startup. ctrl-c kills the command in flight and keeps the turn. The call throws rather than returning, so the model cannot read a killed command as one that ran and failed on its own terms. The kill takes the whole process tree: killing cmd /c alone left the real command holding both pipes open, so the read never returned and the interrupt did nothing for 19 seconds. Two pruning fixes: - A tool result whose tool call was pruned is now dropped with it. Pruning counts messages, so the cut landed between an assistant tool-call and the tool message answering it, producing 400 "No tool call found for function call output with call_id ...". The reverse pairing is left alone: a call awaiting its result is what a suspended approval looks like. - ignore.ts called statFs without importing it, so walk() crashed on the first symlink. 482 tests, up from 404. Docs synced across README, ROADMAP, TODO, and all of docs/: tool sets, the new tools, ctrl-c semantics, the tool-start event, and the two hand-maintained tool-name lists recorded as a known weakness.
2026-09-03 01:37:48 +07:00
parent a5ace7a23f
commit 2fa6ee247b
36 changed files with 2541 additions and 215 deletions
@@ -0,0 +1,222 @@
+import { expect, test } from 'bun:test';
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { MockLanguageModelV4, simulateReadableStream } from 'ai/test';
+import { Session } from '../src/session';
+import { App, createApprovalBridge } from '../src/ui/App';
+import { testHooks } from './helpers';
+
+const usage = { inputTokens: { total: 3, noCache: 3, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1 } } as any;
+
+const model = new MockLanguageModelV4({
+  doStream: async () =>
+    ({
+      stream: simulateReadableStream({
+        chunks: [
+          { type: 'text-start', id: '0' },
+          { type: 'text-delta', id: '0', delta: 'reply' },
+          { type: 'text-end', id: '0' },
+          { type: 'finish', finishReason: { unified: 'stop', raw: 'stop' }, usage },
+        ],
+        chunkDelayInMs: null,
+        initialDelayInMs: null,
+      }),
+    }) as any,
+});
+
+const paths = ['README.md', 'src/app.ts', 'src/session.ts', 'src/ui/App.tsx', 'test/session.test.ts'];
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const DOWN = '\u001B[B';
+const TAB = '\t';
+
+function mount(listPaths = async () => paths) {
+  const sent: string[] = [];
+  const bridge = createApprovalBridge();
+  const session = new Session({ model, askApproval: bridge.ask });
+  const app = render(
+    <App
+      session={session}
+      bridge={bridge}
+      header="hdr"
+      hooks={testHooks({ listPaths, recordPrompt: (t) => sent.push(t) })}
+    />,
+  );
+  return { app, sent };
+}
+
+async function type(app: ReturnType<typeof render>, s: string) {
+  for (const ch of s) {
+    app.stdin.write(ch);
+    await wait(30);
+  }
+}
+
+test('@ opens the file picker and typing narrows it', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, '@');
+  await wait(200);
+  expect(app.lastFrame()).toContain('README.md');
+
+  await type(app, 'src/ui/');
+  await wait(200);
+
+  const frame = app.lastFrame() ?? '';
+  expect(frame).toContain('src/ui/App.tsx');
+  expect(frame).not.toContain('README.md');
+  expect(frame).not.toContain('test/session.test.ts');
+
+  app.unmount();
+}, 25_000);
+
+test('tab inserts the highlighted path with no @', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, 'explain @src/ses');
+  await wait(200);
+  expect(app.lastFrame()).toContain('src/session.ts');
+
+  app.stdin.write(TAB);
+  await wait(250);
+
+  const frame = app.lastFrame() ?? '';
+  expect(frame).toContain('explain src/session.ts');
+  expect(frame).not.toContain('@src');
+  expect(frame).not.toContain('up/down move | tab or enter insert');
+
+  app.unmount();
+}, 25_000);
+
+test('down then tab inserts the second match', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, '@src/');
+  await wait(200);
+  app.stdin.write(DOWN);
+  await wait(150);
+  app.stdin.write(TAB);
+  await wait(250);
+
+  expect(app.lastFrame()).toContain('src/session.ts');
+
+  app.unmount();
+}, 25_000);
+
+test('a completed prompt submits as a plain path', async () => {
+  const { app, sent } = mount();
+  await wait(150);
+
+  await type(app, '@src/app');
+  await wait(200);
+  app.stdin.write(TAB);
+  await wait(250);
+  app.stdin.write('\r');
+  await wait(400);
+
+  expect(sent).toHaveLength(1);
+  expect(sent[0]).toBe('src/app.ts');
+
+  app.unmount();
+}, 25_000);
+
+test('esc dismisses the picker and leaves the text alone', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, '@src/');
+  await wait(200);
+  expect(app.lastFrame()).toContain('src/app.ts');
+
+  app.stdin.write('\u001B');
+  await wait(250);
+
+  const frame = app.lastFrame() ?? '';
+  expect(frame).not.toContain('tab or enter insert');
+  expect(frame).toContain('@src/');
+
+  app.unmount();
+}, 25_000);
+
+test('a query matching nothing says so instead of showing a stale list', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, '@zzzz');
+  await wait(250);
+
+  expect(app.lastFrame()).toContain('no file matches zzzz');
+
+  app.unmount();
+}, 25_000);
+
+test('an @ inside a word is not a completion', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, 'mail me@example');
+  await wait(250);
+
+  const frame = app.lastFrame() ?? '';
+  expect(frame).not.toContain('tab or enter insert');
+  expect(frame).not.toContain('no file matches');
+
+  app.unmount();
+}, 25_000);
+
+test('the walk is reported as loading and only runs once', async () => {
+  let calls = 0;
+  const { app } = mount(async () => {
+    calls++;
+    await wait(400);
+    return paths;
+  });
+  await wait(150);
+
+  await type(app, '@');
+  await wait(80);
+  expect(app.lastFrame()).toContain('indexing files');
+
+  await wait(600);
+  expect(app.lastFrame()).toContain('README.md');
+
+  // Dismiss, reopen: the list is cached rather than walked again.
+  app.stdin.write('\u001B');
+  await wait(150);
+  await type(app, ' @src/');
+  await wait(300);
+
+  expect(app.lastFrame()).toContain('src/app.ts');
+  expect(calls).toBe(1);
+
+  app.unmount();
+}, 25_000);
+
+test('the command menu still works and does not fight the file picker', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  await type(app, '/mo');
+  await wait(200);
+
+  const frame = app.lastFrame() ?? '';
+  expect(frame).toContain('models');
+  expect(frame).not.toContain('tab or enter insert');
+
+  app.unmount();
+}, 25_000);
+
+test('ctrl-c with nothing running does not kill a command that is not there', async () => {
+  const { app } = mount();
+  await wait(150);
+
+  app.stdin.write('\u0003');
+  await wait(250);
+
+  expect(app.lastFrame() ?? '').not.toContain('interrupted:');
+
+  app.unmount();
+}, 25_000);