repoburg 1.3.201 → 1.3.204

package/agent-pane/backend/src/repoburg/turn-projector.test.ts

@@ -1,475 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Capture broadcasts.
-const captured: Array<{ event: string; data: unknown }> = [];
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      captured.push({ event, data });
-    }),
-  };
-});
-
-import { TurnProjector, RESULT_TIMEOUT_MS, MAX_RESULT_EXTENSIONS } from './turn-projector.ts';
-import type { AgentRuntimeActionInfo, AgentRuntimeMessage } from './agent-runtime-client.ts';
-import { initDb } from '../db/index.ts';
-import type Database from 'better-sqlite3';
-import type { RepoburgRuntimeClient } from './repoburg-client.ts';
-
-const SESSION_ID = 's1';
-const TURN_ID = 't1';
-const RUNTIME_SESSION_ID = 'rs-1';
-
-/** Standard action info block for tool_result messages. */
-function actionInfo(overrides: Partial<AgentRuntimeActionInfo> = {}): AgentRuntimeActionInfo {
-  return {
-    id: 'a1',
-    action_type: 'create_file',
-    file_path: 'src/a.ts',
-    command_string: null,
-    status: 'CONFIRMED_KEPT',
-    server_name: null,
-    tool_name: null,
-    arguments: null,
-    plain: null,
-    order_of_execution: 0,
-    ...overrides,
-  };
-}
-
-describe('TurnProjector', () => {
-  let db: Database.Database;
-  let projector: TurnProjector | null = null;
-  const client = {
-    getSessionInputs: vi.fn(),
-    getSession: vi.fn(),
-  } as unknown as RepoburgRuntimeClient;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    captured.length = 0;
-    db = initDb(':memory:');
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, created_at, updated_at)
-       VALUES (?, NULL, 'repoburg', 'running', 1, 'working', ?, ?)`,
-    ).run(SESSION_ID, now, now);
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
-       VALUES (?, ?, 'hello', 'running', ?, ?)`,
-    ).run(TURN_ID, SESSION_ID, now, now);
-  });
-
-  afterEach(() => {
-    projector?.close();
-    projector = null;
-    db.close();
-    vi.useRealTimers();
-  });
-
-  function makeProjector(): TurnProjector {
-    projector = new TurnProjector({
-      agentPaneSessionId: SESSION_ID,
-      turnId: TURN_ID,
-      repoburgSessionId: RUNTIME_SESSION_ID,
-      client,
-    });
-    return projector;
-  }
-
-  function items(): Array<{ external_item_id: string; type: string; status: string; data: string }> {
-    return db
-      .prepare('SELECT external_item_id, type, status, data FROM items WHERE turn_id = ? ORDER BY rowid')
-      .all(TURN_ID) as never;
-  }
-
-  function turnRow(): { status: string; agent_response: string | null; token_usage: string | null; error: string | null } {
-    return db.prepare('SELECT status, agent_response, token_usage, error FROM turns WHERE id = ?').get(TURN_ID) as never;
-  }
-
-  describe('stream_event + assistant', () => {
-    it('starts items on first delta and streams further deltas', () => {
-      const p = makeProjector();
-
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        delta: { type: 'text', text: 'Hel' },
-      });
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        delta: { type: 'text', text: 'lo' },
-      });
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].type).toBe('agent_message');
-      expect(rows[0].status).toBe('in_progress');
-      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hel' }); // item data from FIRST insert
-
-      const delta = captured.find((b) => b.event === 'item:delta');
-      expect(delta).toBeDefined();
-      expect(delta!.data).toMatchObject({ turnId: TURN_ID, itemId: 'in-1-text', delta: 'lo' });
-    });
-
-    it('completes streamed items when the assistant message arrives', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        delta: { type: 'text', text: 'Hel' },
-      });
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [
-          { type: 'thinking', thinking: 'hmm' },
-          { type: 'text', text: 'Hello world' },
-        ],
-      });
-
-      const rows = items();
-      expect(rows.map((r) => r.type)).toEqual(['agent_message', 'reasoning']);
-      expect(rows.every((r) => r.status === 'completed')).toBe(true);
-      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hello world' });
-      expect(JSON.parse(rows[1].data)).toEqual({ text: 'hmm' });
-    });
-
-    it('creates completed items from assistant alone (deltas off/missed)', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'Hello' }],
-      });
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].status).toBe('completed');
-      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hello' });
-    });
-  });
-
-  describe('user tool_result', () => {
-    it('maps actions to items and skips final/html_final (part of the response)', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'user',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'a1',
-            content: 'created',
-            is_error: false,
-            action: actionInfo({ id: 'a1', action_type: 'create_file' }),
-          },
-          {
-            type: 'tool_result',
-            tool_use_id: 'a2',
-            content: 'ls output',
-            is_error: false,
-            action: actionInfo({ id: 'a2', action_type: 'run_command', file_path: null, command_string: 'ls' }),
-          },
-          {
-            type: 'tool_result',
-            tool_use_id: 'a3',
-            content: 'final text',
-            is_error: false,
-            action: actionInfo({ id: 'a3', action_type: 'final', plain: 'Final text' }),
-          },
-        ],
-      });
-
-      const rows = items();
-      expect(rows.map((r) => r.external_item_id)).toEqual(['in-1-action-a1', 'in-1-action-a2']);
-      expect(rows[0].type).toBe('file_change');
-      expect(rows[1].type).toBe('command_execution');
-      expect(JSON.parse(rows[1].data).aggregated_output).toBe('ls output');
-    });
-
-    it('maps failed actions to failed items with the error text', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'user',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'a1',
-            content: 'command crashed',
-            is_error: true,
-            action: actionInfo({
-              id: 'a1',
-              action_type: 'run_command',
-              file_path: null,
-              command_string: 'boom',
-              status: 'EXECUTION_FAILED',
-            }),
-          },
-        ],
-      });
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].status).toBe('failed');
-      expect(JSON.parse(rows[0].data).status).toBe('failed');
-    });
-
-    it('is idempotent — replayed messages do not duplicate items', () => {
-      const p = makeProjector();
-      const assistant: AgentRuntimeMessage = {
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'Hello' }],
-      };
-      const user: AgentRuntimeMessage = {
-        type: 'user',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'a1',
-            content: 'created',
-            is_error: false,
-            action: actionInfo(),
-          },
-        ],
-      };
-
-      p.handle(assistant);
-      p.handle(user);
-      p.handle(assistant); // replay (reconnect)
-      p.handle(user);
-
-      expect(items().map((r) => r.external_item_id).sort()).toEqual(['in-1-action-a1', 'in-1-text']);
-    });
-  });
-
-  describe('result', () => {
-    it('success completes the turn with result text, usage, and title sync', async () => {
-      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
-        id: RUNTIME_SESSION_ID,
-        session_title: 'Synced Title',
-        is_running: false,
-      });
-      const p = makeProjector();
-
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'working' }],
-      });
-      p.handle({
-        type: 'result',
-        subtype: 'success',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: false,
-        result: 'All done',
-        usage: { input_tokens: 10, output_tokens: 5, cache_read_input_tokens: 2, cache_creation_input_tokens: 0 },
-        num_rounds: 2,
-      });
-
-      const row = turnRow();
-      expect(row.status).toBe('completed');
-      expect(row.agent_response).toBe('All done');
-      expect(JSON.parse(row.token_usage!)).toMatchObject({
-        input_tokens: 10,
-        output_tokens: 5,
-        cached_input_tokens: 2,
-      });
-      expect(captured.find((b) => b.event === 'turn:completed')).toBeDefined();
-
-      // Session marked not-running with unreviewed actions.
-      const session = db.prepare('SELECT is_running, status, has_unreviewed FROM sessions WHERE id = ?').get(SESSION_ID) as never;
-      expect(session).toMatchObject({ is_running: 0, status: 'active', has_unreviewed: 1 });
-
-      // Title sync (async, fire-and-forget).
-      await vi.waitFor(() => {
-        const s = db.prepare('SELECT title FROM sessions WHERE id = ?').get(SESSION_ID) as { title: string | null };
-        expect(s.title).toBe('Synced Title');
-      });
-      expect(captured.find((b) => b.event === 'session:title')).toBeDefined();
-
-      // Projector done — later messages ignored.
-      p.handle({
-        type: 'result',
-        subtype: 'success',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: false,
-        result: 'late',
-        num_rounds: 0,
-      } as never);
-      expect(turnRow().agent_response).toBe('All done');
-    });
-
-    it('success falls back to the last round text when result text is empty', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'Fallback text' }],
-      });
-      p.handle({
-        type: 'result',
-        subtype: 'success',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: false,
-        result: '',
-        num_rounds: 1,
-      });
-
-      expect(turnRow().agent_response).toBe('Fallback text');
-    });
-
-    it('error fails the turn and closes open items as failed', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        delta: { type: 'text', text: 'partial' },
-      });
-      p.handle({
-        type: 'result',
-        subtype: 'error_during_execution',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: true,
-        result: '',
-        num_rounds: 1,
-        errors: ['boom', 'bang'],
-      });
-
-      const row = turnRow();
-      expect(row.status).toBe('failed');
-      expect(row.error).toBe('boom; bang');
-      expect(items()[0].status).toBe('failed');
-      expect(captured.find((b) => b.event === 'turn:failed')).toBeDefined();
-    });
-
-    it('aborted aborts the turn and closes open items as completed', () => {
-      const p = makeProjector();
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        delta: { type: 'text', text: 'partial' },
-      });
-      p.handle({
-        type: 'result',
-        subtype: 'aborted',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: true,
-        result: '',
-        num_rounds: 0,
-      });
-
-      expect(turnRow().status).toBe('aborted');
-      expect(items()[0].status).toBe('completed');
-      expect(captured.find((b) => b.event === 'turn:cancelled')).toBeDefined();
-    });
-  });
-
-  describe('watch-dog + snapshot reconcile', () => {
-    it('completes the turn from the snapshot when the result never arrives', async () => {
-      vi.useFakeTimers();
-      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([
-        {
-          id: 'in-1',
-          role: 'model',
-          raw_llm_response: 'Snapshot reply',
-          thoughts: null,
-          input_token_count: 12,
-          output_token_count: 6,
-          cached_token_count: 3,
-          aiActions: [
-            {
-              id: 'a1',
-              action_type: 'create_file',
-              file_path: 'src/x.ts',
-              status: 'CONFIRMED_KEPT',
-              order_of_execution: 0,
-              executionLogs: [{ output: 'created', error_message: null }],
-            },
-          ],
-        },
-      ]);
-      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
-        id: RUNTIME_SESSION_ID,
-        session_title: null,
-        is_running: false,
-      });
-
-      const p = makeProjector();
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'Snapshot reply' }],
-      });
-
-      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS + 1000);
-
-      // Snapshot projected (action item) and turn completed.
-      const ids = items().map((r) => r.external_item_id);
-      expect(ids).toContain('in-1-action-a1');
-      const row = turnRow();
-      expect(row.status).toBe('completed');
-      expect(row.agent_response).toBe('Snapshot reply');
-      expect(JSON.parse(row.token_usage!)).toMatchObject({ input_tokens: 12, output_tokens: 6, cached_input_tokens: 3 });
-      expect(client.getSessionInputs).toHaveBeenCalledWith(RUNTIME_SESSION_ID);
-    });
-
-    it('re-arms while the runtime session is still running, then fails after max extensions', async () => {
-      vi.useFakeTimers();
-      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
-        id: RUNTIME_SESSION_ID,
-        session_title: null,
-        is_running: true,
-      });
-
-      makeProjector();
-
-      const firings = MAX_RESULT_EXTENSIONS + 1;
-      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS * firings + 1000 * firings);
-
-      const row = turnRow();
-      expect(row.status).toBe('failed');
-      expect(row.error).toMatch(/still running/);
-    });
-
-    it('a live result cancels the watchdog', async () => {
-      vi.useFakeTimers();
-      const p = makeProjector();
-      p.handle({
-        type: 'result',
-        subtype: 'success',
-        sessionId: RUNTIME_SESSION_ID,
-        is_error: false,
-        result: 'done',
-        num_rounds: 1,
-      });
-      expect(turnRow().status).toBe('completed');
-
-      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS * 5);
-      expect(client.getSessionInputs).not.toHaveBeenCalled();
-      expect(p.isDone).toBe(true);
-    });
-  });
-});