repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/claude/claude-message-mapper.test.ts

@@ -1,271 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mapAssistantContent, mapPartialDelta, mapUsage, applyToolResult, deriveFileChangeData, extractToolResultText } from './claude-message-mapper.ts';
-
-describe('claude-message-mapper', () => {
-  describe('mapAssistantContent', () => {
-    it('maps a text block to agent_message', () => {
-      const content = [{ type: 'text', text: 'Hello world', citations: null }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('agent_message');
-      expect(result[0].data).toEqual({ text: 'Hello world' });
-    });
-
-    it('maps a thinking block to reasoning', () => {
-      const content = [{ type: 'thinking', thinking: 'I should respond', signature: 'sig' }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('reasoning');
-      expect(result[0].data).toEqual({ text: 'I should respond' });
-    });
-
-    it('uses thinkingTexts fallback when thinking block is empty (signed-empty)', () => {
-      const content = [{ type: 'thinking', thinking: '', signature: 'sig' }] as never;
-      const thinkingTexts = new Map([[0, 'Accumulated thinking text']]);
-      const result = mapAssistantContent(content, 'msg-1', thinkingTexts);
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('reasoning');
-      expect(result[0].data).toEqual({ text: 'Accumulated thinking text' });
-    });
-
-    it('keeps empty text when thinkingTexts is not provided', () => {
-      const content = [{ type: 'thinking', thinking: '', signature: 'sig' }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].data).toEqual({ text: '' });
-    });
-
-    it('maps a Bash tool_use to command_execution', () => {
-      const content = [{ type: 'tool_use', id: 'tu-1', name: 'Bash', input: { command: 'ls -la' } }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('command_execution');
-      expect(result[0].data).toEqual({
-        command: 'ls -la',
-        aggregated_output: null,
-        exit_code: null,
-        status: 'in_progress',
-      });
-      expect(result[0].externalId).toBe('tu-1');
-    });
-
-    it('maps an Edit tool_use to file_change with canonical changes array', () => {
-      const content = [{ type: 'tool_use', id: 'tu-2', name: 'Edit', input: { file_path: 'foo.ts', old_string: 'a', new_string: 'b' } }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('file_change');
-      expect(result[0].data).toEqual({
-        changes: [{ path: 'foo.ts', kind: 'modify' }],
-        status: 'in_progress',
-      });
-    });
-
-    it('maps a Write tool_use to file_change with kind "add"', () => {
-      const content = [{ type: 'tool_use', id: 'tu-3', name: 'Write', input: { file_path: 'bar.ts', content: 'x' } }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('file_change');
-      expect(result[0].data).toEqual({
-        changes: [{ path: 'bar.ts', kind: 'add' }],
-        status: 'in_progress',
-      });
-    });
-
-    it('maps an unknown tool_use to mcp_tool_call', () => {
-      const content = [{ type: 'tool_use', id: 'tu-4', name: 'CustomTool', input: { x: 1 } }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe('mcp_tool_call');
-      expect(result[0].data).toEqual({
-        server: null,
-        tool: 'CustomTool',
-        arguments: { x: 1 },
-        result: null,
-        error: null,
-        status: 'in_progress',
-      });
-    });
-
-    it('skips redacted_thinking blocks', () => {
-      const content = [{ type: 'redacted_thinking', data: 'encrypted' }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(0);
-    });
-
-    it('skips unknown block types', () => {
-      const content = [{ type: 'server_tool_use', id: 'x', name: 'y', input: {} }] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(0);
-    });
-
-    it('maps multiple blocks in one message', () => {
-      const content = [
-        { type: 'thinking', thinking: 'Let me think', signature: 's' },
-        { type: 'text', text: 'Here is my answer', citations: null },
-        { type: 'tool_use', id: 'tu-5', name: 'Bash', input: { command: 'echo hi' } },
-      ] as never;
-      const result = mapAssistantContent(content, 'msg-1');
-      expect(result).toHaveLength(3);
-      expect(result[0].type).toBe('reasoning');
-      expect(result[1].type).toBe('agent_message');
-      expect(result[2].type).toBe('command_execution');
-    });
-  });
-
-  describe('deriveFileChangeData', () => {
-    it('maps an Edit input to a single modify change', () => {
-      expect(deriveFileChangeData({ file_path: 'a.ts', old_string: 'x', new_string: 'y' }, 'Edit')).toEqual({
-        changes: [{ path: 'a.ts', kind: 'modify' }],
-        status: 'in_progress',
-      });
-    });
-
-    it('maps a Write input to an add change', () => {
-      expect(deriveFileChangeData({ file_path: 'b.ts', content: 'x' }, 'Write')).toEqual({
-        changes: [{ path: 'b.ts', kind: 'add' }],
-        status: 'in_progress',
-      });
-    });
-
-    it('falls back to notebook_path and defaults kind to modify', () => {
-      expect(deriveFileChangeData({ notebook_path: 'nb.ipynb' }, 'NotebookEdit')).toEqual({
-        changes: [{ path: 'nb.ipynb', kind: 'modify' }],
-        status: 'in_progress',
-      });
-    });
-
-    it('uses empty string when no path field present', () => {
-      expect(deriveFileChangeData({}, 'MultiEdit')).toEqual({
-        changes: [{ path: '', kind: 'modify' }],
-        status: 'in_progress',
-      });
-    });
-  });
-
-  describe('extractToolResultText', () => {
-    it('returns a string content as-is', () => {
-      expect(extractToolResultText('hello')).toBe('hello');
-    });
-    it('joins text blocks in an array', () => {
-      expect(extractToolResultText([{ type: 'text', text: 'a' }, { type: 'text', text: 'b' }])).toBe('a\nb');
-    });
-    it('ignores non-text blocks', () => {
-      expect(extractToolResultText([{ type: 'tool_reference', tool_name: 'x' }, { type: 'text', text: 'a' }])).toBe('a');
-    });
-    it('returns empty for null/undefined', () => {
-      expect(extractToolResultText(null)).toBe('');
-      expect(extractToolResultText(undefined)).toBe('');
-    });
-  });
-
-  describe('applyToolResult', () => {
-    it('command_execution: fills aggregated_output from structured stdout+stderr and exit_code from is_error', () => {
-      const existing = { command: 'ls', aggregated_output: null, exit_code: null, status: 'in_progress' };
-      const out = applyToolResult('command_execution', existing, { tool_use_id: 't1', content: 'file1\nfile2' }, { stdout: 'file1\nfile2', stderr: 'warn', interrupted: false, isImage: false, noOutputExpected: false }, false);
-      expect(out).toEqual({ command: 'ls', aggregated_output: 'file1\nfile2\nwarn', exit_code: 0, status: 'completed' });
-    });
-
-    it('command_execution: marks failed and exit_code 1 on error', () => {
-      const existing = { command: 'bad', aggregated_output: null, exit_code: null, status: 'in_progress' };
-      const out = applyToolResult('command_execution', existing, { tool_use_id: 't2', is_error: true, content: 'boom' }, { stdout: 'boom', stderr: '' }, true);
-      expect(out.exit_code).toBe(1);
-      expect(out.status).toBe('failed');
-      expect(out.aggregated_output).toBe('boom');
-    });
-
-    it('mcp_tool_call: fills result text and no error on success', () => {
-      const existing = { server: null, tool: 'Linear.get', arguments: { id: 'PAR-1' }, result: null, error: null, status: 'in_progress' };
-      const out = applyToolResult('mcp_tool_call', existing, { tool_use_id: 't3', content: [{ type: 'text', text: '{"id":"PAR-1"}' }] }, null, false);
-      expect(out.result).toEqual([{ type: 'text', text: '{"id":"PAR-1"}' }]);
-      expect(out.error).toBeNull();
-      expect(out.status).toBe('completed');
-    });
-
-    it('mcp_tool_call: sets error on is_error', () => {
-      const existing = { server: null, tool: 'X', arguments: {}, result: null, error: null, status: 'in_progress' };
-      const out = applyToolResult('mcp_tool_call', existing, { tool_use_id: 't4', is_error: true, content: 'denied' }, null, true);
-      expect(out.error).toBe('denied');
-      expect(out.status).toBe('failed');
-    });
-
-    it('file_change: keeps existing changes and flips status to completed', () => {
-      const existing = { changes: [{ path: 'a.ts', kind: 'modify' }], status: 'in_progress' };
-      const out = applyToolResult('file_change', existing, { tool_use_id: 't5', content: 'ok' }, null, false);
-      expect(out).toEqual({ changes: [{ path: 'a.ts', kind: 'modify' }], status: 'completed' });
-    });
-
-    it('unknown type: returns existing data unchanged', () => {
-      const existing = { foo: 1 };
-      expect(applyToolResult('agent_message', existing, null, null, false)).toEqual({ foo: 1 });
-    });
-  });
-
-  describe('mapPartialDelta', () => {
-    it('maps a text_delta event', () => {
-      const event = {
-        type: 'content_block_delta',
-        delta: { type: 'text_delta', text: 'Hello' },
-        index: 0,
-      };
-      const result = mapPartialDelta(event);
-      expect(result).toEqual({ kind: 'text', text: 'Hello', index: 0 });
-    });
-
-    it('maps a thinking_delta event', () => {
-      const event = {
-        type: 'content_block_delta',
-        delta: { type: 'thinking_delta', thinking: 'Hmm', estimated_tokens: null },
-        index: 0,
-      };
-      const result = mapPartialDelta(event);
-      expect(result).toEqual({ kind: 'thinking', text: 'Hmm', index: 0 });
-    });
-
-    it('returns null for non-delta events', () => {
-      const event = { type: 'content_block_start', index: 0, content_block: {} };
-      const result = mapPartialDelta(event);
-      expect(result).toBeNull();
-    });
-
-    it('returns null for unknown delta types', () => {
-      const event = {
-        type: 'content_block_delta',
-        delta: { type: 'input_json_delta', partial_json: '{}' },
-        index: 0,
-      };
-      const result = mapPartialDelta(event);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('mapUsage', () => {
-    it('maps camelCase usage fields to snake_case TokenUsage', () => {
-      const usage = {
-        input_tokens: 100,
-        output_tokens: 50,
-        cache_read_input_tokens: 30,
-        cache_creation_input_tokens: 20,
-      };
-      const result = mapUsage(usage);
-      expect(result).toEqual({
-        input_tokens: 100,
-        cached_input_tokens: 30,
-        cache_write_input_tokens: 20,
-        output_tokens: 50,
-        reasoning_output_tokens: 0,
-      });
-    });
-
-    it('handles null cache values with fallback to 0', () => {
-      const usage = {
-        input_tokens: 200,
-        output_tokens: 80,
-        cache_read_input_tokens: 0,
-        cache_creation_input_tokens: 0,
-      };
-      const result = mapUsage(usage);
-      expect(result.cached_input_tokens).toBe(0);
-      expect(result.cache_write_input_tokens).toBe(0);
-    });
-  });
-});

package/agent-pane/backend/src/claude/claude-message-mapper.ts

@@ -1,259 +0,0 @@
-/**
- * Map Claude SDK messages to AgentPane item descriptors.
- *
- * Three mapping functions:
- * - `mapAssistantContent` — BetaContentBlock[] → item descriptors
- * - `mapPartialDelta` — BetaRawMessageStreamEvent → text/thinking delta
- * - `mapUsage` — NonNullableUsage → TokenUsage (snake_case)
- */
-
-import type { TokenUsage } from '@agentpane/shared';
-import type {
-  BetaContentBlock,
-  BetaRawContentBlockDeltaEvent,
-  BetaTextBlock,
-  BetaThinkingBlock,
-  BetaToolUseBlock,
-} from '@anthropic-ai/sdk/resources/beta/messages/messages';
-
-/** Item descriptor — output of mapping a content block to a DB-ready item. */
-export interface ItemDescriptor {
-  type: string;              // DB item type (snake_case)
-  data: Record<string, unknown>;
-  externalId: string;       // Claude content block ID (or UUID)
-}
-
-/** Map assistant content blocks to item descriptors.
- *  @param thinkingTexts — Optional map of content-block index → accumulated thinking_delta text.
- *    When a `thinking` block has empty `thinking` (signed-empty), the mapper falls back to
- *    the accumulated text from stream events.  */
-export function mapAssistantContent(
-  content: BetaContentBlock[],
-  messageId: string,
-  thinkingTexts?: Map<number, string>,
-): ItemDescriptor[] {
-  const descriptors: ItemDescriptor[] = [];
-
-  for (let i = 0; i < content.length; i++) {
-    const block = content[i];
-    switch (block.type) {
-      case 'text': {
-        const tb = block as BetaTextBlock;
-        descriptors.push({
-          type: 'agent_message',
-          data: { text: tb.text },
-          externalId: messageId,
-        });
-        break;
-      }
-
-      case 'thinking': {
-        const tb = block as BetaThinkingBlock;
-        let text = tb.thinking;
-        if (!text && thinkingTexts) {
-          text = thinkingTexts.get(i) ?? '';
-        }
-        descriptors.push({
-          type: 'reasoning',
-          data: { text },
-          externalId: messageId,
-        });
-        break;
-      }
-
-      case 'tool_use': {
-        const tu = block as BetaToolUseBlock;
-        const desc = mapToolUse(tu);
-        descriptors.push(desc);
-        break;
-      }
-
-      case 'redacted_thinking':
-        // Skip — redacted content has no displayable text.
-        break;
-
-      default:
-        // Skip unknown block types.
-        break;
-    }
-  }
-
-  return descriptors;
-}
-
-/** Map a tool_use block to the correct item type based on tool name. */
-function mapToolUse(block: BetaToolUseBlock): ItemDescriptor {
-  const input = block.input as Record<string, unknown>;
-
-  if (block.name === 'Bash') {
-    return {
-      type: 'command_execution',
-      data: {
-        command: input.command ?? '',
-        aggregated_output: null,
-        exit_code: null,
-        status: 'in_progress',
-      },
-      externalId: block.id,
-    };
-  }
-
-  if (block.name === 'Edit' || block.name === 'Write' || block.name === 'MultiEdit' || block.name === 'NotebookEdit') {
-    return {
-      type: 'file_change',
-      data: deriveFileChangeData(input, block.name),
-      externalId: block.id,
-    };
-  }
-
-  // All other tools → mcp_tool_call.
-  return {
-    type: 'mcp_tool_call',
-    data: {
-      server: null,
-      tool: block.name,
-      arguments: input,
-      result: null,
-      error: null,
-      status: 'in_progress',
-    },
-    externalId: block.id,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tool-result mapping — pure functions shared by the live provider and the
-// JSONL backfill script. Kept free of DB / SDK-specific types so both callers
-// (which hold different shapes: typed SDK blocks vs parsed JSON) can use them.
-// ---------------------------------------------------------------------------
-
-/** Derive the canonical file_change data from a Claude file-edit tool_use input.
- *  Each Edit/Write/MultiEdit/NotebookEdit touches a single file → one change.
- *  Frontend expects `changes: Array<{ path, kind }>` (matches Codex app-server). */
-export function deriveFileChangeData(
-  input: Record<string, unknown>,
-  toolName: string,
-): { changes: Array<{ path: string; kind: string }>; status: string } {
-  const path = (input.file_path ?? input.notebook_path ?? '') as string;
-  const kind = toolName === 'Write' ? 'add' : 'modify';
-  return { changes: [{ path, kind }], status: 'in_progress' };
-}
-
-/** Loose shape of a `tool_result` content block — works for SDK blocks and parsed JSONL. */
-export interface ToolResultLike {
-  tool_use_id?: string;
-  is_error?: boolean;
-  content?: unknown;
-}
-
-/** Extract concatenated text from a tool_result `content` (string or array of text blocks). */
-export function extractToolResultText(content: unknown): string {
-  if (!content) return '';
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((b) => {
-        if (b && typeof b === 'object' && (b as { type?: string }).type === 'text') {
-          return String((b as { text?: unknown }).text ?? '');
-        }
-        return '';
-      })
-      .filter(Boolean)
-      .join('\n');
-  }
-  return '';
-}
-
-/** Build the updated item `data` after a tool_result arrives. Pure; no DB access.
- *
- *  - `command_execution`: aggregated_output from the result text (Bash stdout) plus
- *    structured stderr when present; exit_code heuristically from is_error (the Claude
- *    SDK does not expose a real exit code for Bash).
- *  - `mcp_tool_call`: result text from the tool_result content; error when is_error.
- *  - `file_change`: the `changes` array was set at tool_use time — just mark status.
- *  @param itemType — DB item type ('command_execution' | 'file_change' | 'mcp_tool_call').
- *  @param existingData — current `data` object stored on the item.
- *  @param toolResult — the tool_result content block (may be null if only structured output exists).
- *  @param toolUseResult — the SDK `tool_use_result` structured object (per-tool shape; Bash → {stdout, stderr}).
- *  @param isError — whether the tool_result flagged an error. */
-export function applyToolResult(
-  itemType: string,
-  existingData: Record<string, unknown>,
-  toolResult: ToolResultLike | null,
-  toolUseResult: unknown,
-  isError: boolean,
-): Record<string, unknown> {
-  switch (itemType) {
-    case 'command_execution': {
-      const text = extractToolResultText(toolResult?.content);
-      const tur = (toolUseResult && typeof toolUseResult === 'object' ? toolUseResult : {}) as Record<string, unknown>;
-      const stdout = typeof tur.stdout === 'string' ? tur.stdout : '';
-      const stderr = typeof tur.stderr === 'string' ? tur.stderr : '';
-      let aggregated = text || stdout;
-      if (stderr) aggregated = aggregated ? `${aggregated}\n${stderr}` : stderr;
-      return {
-        ...existingData,
-        aggregated_output: aggregated,
-        exit_code: isError ? 1 : 0,
-        status: isError ? 'failed' : 'completed',
-      };
-    }
-
-    case 'mcp_tool_call': {
-      const text = extractToolResultText(toolResult?.content);
-      return {
-        ...existingData,
-        result: text ? [{ type: 'text', text }] : (toolUseResult ?? null),
-        error: isError ? (text || 'Tool error') : null,
-        status: isError ? 'failed' : 'completed',
-      };
-    }
-
-    case 'file_change': {
-      // `changes` was derived at tool_use time; only flip the inner status.
-      return { ...existingData, status: isError ? 'failed' : 'completed' };
-    }
-
-    default:
-      return existingData;
-  }
-}
-
-/** Result of mapping a partial (streaming) delta event. */
-export interface DeltaResult {
-  kind: 'text' | 'thinking';
-  text: string;
-  index: number;
-}
-
-/** Map a streaming delta event to a text or thinking fragment. Returns null for non-delta events. */
-export function mapPartialDelta(event: unknown): DeltaResult | null {
-  const e = event as BetaRawContentBlockDeltaEvent;
-  if (e.type !== 'content_block_delta') return null;
-
-  const delta = e.delta as unknown as Record<string, unknown>;
-  if (delta.type === 'text_delta') {
-    return { kind: 'text', text: delta.text as string, index: e.index };
-  }
-  if (delta.type === 'thinking_delta') {
-    return { kind: 'thinking', text: delta.thinking as string, index: e.index };
-  }
-
-  return null;
-}
-
-/** Map Claude SDK NonNullableUsage (camelCase) to AgentPane TokenUsage (snake_case). */
-export function mapUsage(usage: {
-  input_tokens: number;
-  output_tokens: number;
-  cache_read_input_tokens: number;
-  cache_creation_input_tokens: number;
-}): TokenUsage {
-  return {
-    input_tokens: usage.input_tokens,
-    cached_input_tokens: usage.cache_read_input_tokens ?? 0,
-    cache_write_input_tokens: usage.cache_creation_input_tokens ?? 0,
-    output_tokens: usage.output_tokens,
-    reasoning_output_tokens: 0,  // Claude SDK does not provide this separately.
-  };
-}