libs/utils/tests/conversation-utils.test.ts

import { describe, it, expect } from 'vitest';
import type { ConversationMessage } from '@automaker/types';
import {
  extractTextFromContent,
  normalizeContentBlocks,
  formatHistoryAsText,
  convertHistoryToMessages,
} from '../src/conversation-utils';

describe('conversation-utils.ts', () => {
  describe('extractTextFromContent', () => {
    it('should extract text from string content', () => {
      const content = 'Hello, world!';
      const result = extractTextFromContent(content);
      expect(result).toBe('Hello, world!');
    });

    it('should extract text from array content with text blocks', () => {
      const content = [
        { type: 'text', text: 'First block' },
        { type: 'text', text: 'Second block' },
      ];
      const result = extractTextFromContent(content);
      expect(result).toBe('First block\nSecond block');
    });

    it('should filter out non-text blocks', () => {
      const content = [
        { type: 'text', text: 'Text block' },
        { type: 'image', source: { data: '...' } },
        { type: 'text', text: 'Another text' },
      ];
      const result = extractTextFromContent(content);
      expect(result).toBe('Text block\nAnother text');
    });

    it('should handle empty text blocks', () => {
      const content = [
        { type: 'text', text: 'First' },
        { type: 'text' },
        { type: 'text', text: 'Third' },
      ];
      const result = extractTextFromContent(content);
      expect(result).toBe('First\n\nThird');
    });

    it('should return empty string for array with only non-text blocks', () => {
      const content = [
        { type: 'image', source: {} },
        { type: 'tool_use', source: {} },
      ];
      const result = extractTextFromContent(content);
      expect(result).toBe('');
    });

    it('should return empty string for empty array', () => {
      const content: Array<{ type: string; text?: string }> = [];
      const result = extractTextFromContent(content);
      expect(result).toBe('');
    });
  });

  describe('normalizeContentBlocks', () => {
    it('should convert string to array of text blocks', () => {
      const content = 'Simple text';
      const result = normalizeContentBlocks(content);
      expect(result).toEqual([{ type: 'text', text: 'Simple text' }]);
    });

    it('should return array as-is', () => {
      const content = [
        { type: 'text', text: 'First' },
        { type: 'image', source: {} },
      ];
      const result = normalizeContentBlocks(content);
      expect(result).toBe(content);
      expect(result).toEqual(content);
    });

    it('should handle empty string', () => {
      const content = '';
      const result = normalizeContentBlocks(content);
      expect(result).toEqual([{ type: 'text', text: '' }]);
    });

    it('should handle multiline string', () => {
      const content = 'Line 1\nLine 2\nLine 3';
      const result = normalizeContentBlocks(content);
      expect(result).toEqual([{ type: 'text', text: 'Line 1\nLine 2\nLine 3' }]);
    });
  });

  describe('formatHistoryAsText', () => {
    it('should format empty history as empty string', () => {
      const history: ConversationMessage[] = [];
      const result = formatHistoryAsText(history);
      expect(result).toBe('');
    });

    it('should format single user message', () => {
      const history: ConversationMessage[] = [{ role: 'user', content: 'Hello!' }];
      const result = formatHistoryAsText(history);
      expect(result).toBe('Previous conversation:\n\nUser: Hello!\n\n---\n\n');
    });

    it('should format single assistant message', () => {
      const history: ConversationMessage[] = [{ role: 'assistant', content: 'Hi there!' }];
      const result = formatHistoryAsText(history);
      expect(result).toBe('Previous conversation:\n\nAssistant: Hi there!\n\n---\n\n');
    });

    it('should format conversation with multiple messages', () => {
      const history: ConversationMessage[] = [
        { role: 'user', content: "What's 2+2?" },
        { role: 'assistant', content: 'The answer is 4.' },
        { role: 'user', content: 'Thanks!' },
      ];
      const result = formatHistoryAsText(history);
      expect(result).toBe(
        'Previous conversation:\n\n' +
          "User: What's 2+2?\n\n" +
          'Assistant: The answer is 4.\n\n' +
          'User: Thanks!\n\n' +
          '---\n\n'
      );
    });

    it('should handle array content by extracting text', () => {
      const history: ConversationMessage[] = [
        {
          role: 'user',
          content: [
            { type: 'text', text: 'First part' },
            { type: 'text', text: 'Second part' },
          ],
        },
      ];
      const result = formatHistoryAsText(history);
      expect(result).toBe('Previous conversation:\n\nUser: First part\nSecond part\n\n---\n\n');
    });

    it('should handle mixed string and array content', () => {
      const history: ConversationMessage[] = [
        { role: 'user', content: 'String message' },
        {
          role: 'assistant',
          content: [{ type: 'text', text: 'Array message' }],
        },
      ];
      const result = formatHistoryAsText(history);
      expect(result).toContain('User: String message');
      expect(result).toContain('Assistant: Array message');
    });
  });

  describe('convertHistoryToMessages', () => {
    it('should convert empty history', () => {
      const history: ConversationMessage[] = [];
      const result = convertHistoryToMessages(history);
      expect(result).toEqual([]);
    });

    it('should convert single user message', () => {
      const history: ConversationMessage[] = [{ role: 'user', content: 'Hello!' }];
      const result = convertHistoryToMessages(history);

      expect(result).toHaveLength(1);
      expect(result[0]).toMatchObject({
        type: 'user',
        session_id: '',
        message: {
          role: 'user',
          content: [{ type: 'text', text: 'Hello!' }],
        },
        parent_tool_use_id: null,
      });
    });

    it('should convert single assistant message', () => {
      const history: ConversationMessage[] = [{ role: 'assistant', content: 'Hi there!' }];
      const result = convertHistoryToMessages(history);

      expect(result).toHaveLength(1);
      expect(result[0]).toMatchObject({
        type: 'assistant',
        session_id: '',
        message: {
          role: 'assistant',
          content: [{ type: 'text', text: 'Hi there!' }],
        },
        parent_tool_use_id: null,
      });
    });

    it('should preserve array content as-is', () => {
      const content = [
        { type: 'text', text: 'Text' },
        { type: 'image', source: { data: '...' } },
      ];
      const history: ConversationMessage[] = [{ role: 'user', content }];
      const result = convertHistoryToMessages(history);

      expect(result[0].message.content).toEqual(content);
    });

    it('should convert multiple messages', () => {
      const history: ConversationMessage[] = [
        { role: 'user', content: 'First' },
        { role: 'assistant', content: 'Second' },
        { role: 'user', content: 'Third' },
      ];
      const result = convertHistoryToMessages(history);

      expect(result).toHaveLength(3);
      expect(result[0].type).toBe('user');
      expect(result[1].type).toBe('assistant');
      expect(result[2].type).toBe('user');
    });

    it('should set session_id to empty string', () => {
      const history: ConversationMessage[] = [{ role: 'user', content: 'Test' }];
      const result = convertHistoryToMessages(history);

      expect(result[0].session_id).toBe('');
    });

    it('should set parent_tool_use_id to null', () => {
      const history: ConversationMessage[] = [{ role: 'user', content: 'Test' }];
      const result = convertHistoryToMessages(history);

      expect(result[0].parent_tool_use_id).toBeNull();
    });

    it('should normalize string content to blocks', () => {
      const history: ConversationMessage[] = [{ role: 'user', content: 'String content' }];
      const result = convertHistoryToMessages(history);

      expect(result[0].message.content).toEqual([{ type: 'text', text: 'String content' }]);
    });
  });
});