repoburg 1.3.202 → 1.3.209

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

@@ -1,621 +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,
-    selections: 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('records runtime input ids into turns.runtime_input_ids (rewind anchor mapping)', () => {
-      const p = makeProjector();
-
-      // Round 1
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [{ type: 'text', text: 'Round one' }],
-      });
-      // Round 2 (multi-round turn)
-      p.handle({
-        type: 'assistant',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-2',
-        content: [{ type: 'text', text: 'Round two' }],
-      });
-      // Replay of an existing round must NOT duplicate the id
-      p.handle({
-        type: 'stream_event',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-2',
-        delta: { type: 'text', text: ' again' },
-      });
-
-      const row = db
-        .prepare('SELECT runtime_input_ids FROM turns WHERE id = ?')
-        .get(TURN_ID) as { runtime_input_ids: string | null };
-      expect(JSON.parse(row.runtime_input_ids!)).toEqual(['in-1', 'in-2']);
-    });
-
-    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();
-      // The completion broadcast carries the final text — the FE renders it
-      // for final-action turns that have no agent_message item.
-      const completed = captured.find((b) => b.event === 'turn:completed');
-      expect(completed!.data).toMatchObject({ response: 'All done' });
-
-      // 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/);
-    });
-
-    describe('subagent lifecycle → background_task', () => {
-    /** One registered sub-agent event message. */
-    function subagent(event: 'started' | 'progress' | 'completed' | 'failed', extra: Record<string, unknown> = {}): AgentRuntimeMessage {
-      return {
-        type: 'subagent',
-        sessionId: RUNTIME_SESSION_ID,
-        event,
-        task_id: 'child-1',
-        agent_name: 'explore-codebase',
-        description: 'Find auth files',
-        input_id: 'in-1',
-        action_id: 'act-1',
-        ...extra,
-      };
-    }
-
-    it('started/progress/completed converge on ONE background_task item', () => {
-      const p = makeProjector();
-
-      p.handle(subagent('started'));
-      let rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({
-        external_item_id: 'in-1-action-act-1',
-        type: 'background_task',
-        status: 'in_progress',
-      });
-      expect(JSON.parse(rows[0].data)).toMatchObject({
-        task_id: 'child-1',
-        description: 'Find auth files',
-        task_type: 'subagent',
-        subagent_type: 'explore-codebase',
-        status: 'running',
-      });
-
-      p.handle(subagent('progress', { description: 'create_file: src/auth.ts', last_tool_name: 'create_file', token_count: 120 }));
-      rows = items();
-      expect(rows).toHaveLength(1); // SAME item — no duplicates
-      expect(JSON.parse(rows[0].data)).toMatchObject({
-        description: 'create_file: src/auth.ts',
-        last_tool_name: 'create_file',
-        token_count: 120,
-        status: 'running',
-      });
-      const updated = captured.filter((b) => b.event === 'item:updated');
-      expect(updated).toHaveLength(1);
-
-      p.handle(subagent('completed', { summary: 'auth files found', usage: { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } }));
-      rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].status).toBe('completed');
-      expect(JSON.parse(rows[0].data)).toMatchObject({
-        status: 'completed',
-        summary: 'auth files found',
-      });
-    });
-
-    it('failed settlement marks the card failed', () => {
-      const p = makeProjector();
-
-      p.handle(subagent('started'));
-      p.handle(subagent('failed', { summary: 'boom' }));
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].status).toBe('failed');
-      expect(JSON.parse(rows[0].data)).toMatchObject({ status: 'failed', summary: 'boom' });
-    });
-
-    it('invoke_subagent tool_result with the same action id does NOT duplicate the live card', () => {
-      const p = makeProjector();
-
-      p.handle(subagent('started'));
-      p.handle({
-        type: 'user',
-        sessionId: RUNTIME_SESSION_ID,
-        inputId: 'in-1',
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'act-1',
-            content: 'child output',
-            is_error: false,
-            action: actionInfo({
-              id: 'act-1',
-              action_type: 'invoke_subagent',
-              arguments: JSON.stringify({ agent_name: 'explore-codebase', prompt: 'Find auth files' }),
-              file_path: null,
-            }),
-          },
-        ],
-      });
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].external_item_id).toBe('in-1-action-act-1');
-      expect(rows[0].type).toBe('background_task');
-    });
-
-    it('a completed card from subagent events survives a later completed event idempotently', () => {
-      const p = makeProjector();
-
-      p.handle(subagent('started'));
-      p.handle(subagent('completed', { summary: 'done' }));
-      p.handle(subagent('completed', { summary: 'done' })); // replay
-
-      const rows = items();
-      expect(rows).toHaveLength(1);
-      expect(rows[0].status).toBe('completed');
-    });
-  });
-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);
-    });
-  });
-});