repoburg 1.3.199 → 1.3.201

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

@@ -0,0 +1,475 @@
+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);
+    });
+  });
+});