holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/ai/llm-service.test.js

@@ -1,390 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { LLMService } from '../../../src/ai/llm-service.js';
-
-// Mock OpenAI
-vi.mock('openai', () => ({
-  default: vi.fn().mockImplementation(() => ({
-    chat: {
-      completions: {
-        create: vi.fn()
-      }
-    }
-  }))
-}));
-
-describe('Unit: LLMService', () => {
-  let llm;
-  let mockOpenAI;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    llm = new LLMService('test-api-key');
-    mockOpenAI = llm.openai;
-  });
-
-  describe('Constructor', () => {
-    it('should throw error if API key is not provided', () => {
-      expect(() => new LLMService()).toThrow('OpenAI API key is required');
-      expect(() => new LLMService('')).toThrow('OpenAI API key is required');
-      expect(() => new LLMService(null)).toThrow('OpenAI API key is required');
-    });
-
-    it('should initialize with default options', () => {
-      const service = new LLMService('test-key');
-      expect(service.model).toBe('gpt-4o-mini');
-      expect(service.maxTokens).toBe(2000);
-      expect(service.temperature).toBe(0.7);
-    });
-
-    it('should accept custom options', () => {
-      const service = new LLMService('test-key', {
-        model: 'gpt-4',
-        maxTokens: 1000,
-        temperature: 0.5
-      });
-      expect(service.model).toBe('gpt-4');
-      expect(service.maxTokens).toBe(1000);
-      expect(service.temperature).toBe(0.5);
-    });
-  });
-
-  describe('sendMessage', () => {
-    it('should send message with system and user prompts', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Test response' } }]
-      });
-
-      const result = await llm.sendMessage('You are helpful', 'Hello');
-
-      expect(mockOpenAI.chat.completions.create).toHaveBeenCalledWith({
-        model: 'gpt-4o-mini',
-        messages: [
-          { role: 'system', content: 'You are helpful' },
-          { role: 'user', content: 'Hello' }
-        ],
-        max_tokens: 2000,
-        temperature: 0.7
-      });
-      expect(result).toBe('Test response');
-    });
-
-    it('should allow option overrides', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Response' } }]
-      });
-
-      await llm.sendMessage('System', 'User', {
-        model: 'gpt-4',
-        maxTokens: 500,
-        temperature: 0.3
-      });
-
-      expect(mockOpenAI.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          model: 'gpt-4',
-          max_tokens: 500,
-          temperature: 0.3
-        })
-      );
-    });
-
-    it('should handle empty response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: null } }]
-      });
-
-      const result = await llm.sendMessage('System', 'User');
-      expect(result).toBe('');
-    });
-
-    it('should throw error on API failure', async () => {
-      mockOpenAI.chat.completions.create.mockRejectedValue(new Error('API Error'));
-
-      await expect(llm.sendMessage('System', 'User'))
-        .rejects.toThrow('LLM request failed: API Error');
-    });
-
-    it('should trim whitespace from response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '  Response with spaces  ' } }]
-      });
-
-      const result = await llm.sendMessage('System', 'User');
-      expect(result).toBe('Response with spaces');
-    });
-  });
-
-  describe('chat', () => {
-    it('should send conversation messages', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Chat response' } }]
-      });
-
-      const messages = [
-        { role: 'system', content: 'You are helpful' },
-        { role: 'user', content: 'Hello' },
-        { role: 'assistant', content: 'Hi there!' },
-        { role: 'user', content: 'How are you?' }
-      ];
-
-      const result = await llm.chat(messages);
-
-      expect(mockOpenAI.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({ messages })
-      );
-      expect(result).toBe('Chat response');
-    });
-
-    it('should throw error on chat failure', async () => {
-      mockOpenAI.chat.completions.create.mockRejectedValue(new Error('Chat failed'));
-
-      await expect(llm.chat([]))
-        .rejects.toThrow('LLM chat failed: Chat failed');
-    });
-  });
-
-  describe('summarize', () => {
-    it('should summarize text', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Summary of text' } }]
-      });
-
-      const result = await llm.summarize('Long text to summarize');
-
-      expect(mockOpenAI.chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          temperature: 0.5
-        })
-      );
-      expect(result).toBe('Summary of text');
-    });
-
-    it('should include maxLength in prompt when specified', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Short summary' } }]
-      });
-
-      await llm.summarize('Text', { maxLength: 50 });
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('50 words');
-    });
-
-    it('should include style in prompt when specified', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Bullet summary' } }]
-      });
-
-      await llm.summarize('Text', { style: 'bullet points' });
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('bullet points');
-    });
-  });
-
-  describe('analyze', () => {
-    it('should analyze text from specified perspective', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Sentiment analysis result' } }]
-      });
-
-      const result = await llm.analyze('Happy text', 'sentiment');
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('sentiment');
-      expect(call.temperature).toBe(0.3);
-      expect(result).toBe('Sentiment analysis result');
-    });
-  });
-
-  describe('extractKeywords', () => {
-    it('should extract keywords as JSON array', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '["keyword1", "keyword2", "keyword3"]' } }]
-      });
-
-      const result = await llm.extractKeywords('Some text about keywords');
-
-      expect(result).toEqual(['keyword1', 'keyword2', 'keyword3']);
-    });
-
-    it('should handle non-JSON response by extracting array', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Here are keywords: ["a", "b"]' } }]
-      });
-
-      const result = await llm.extractKeywords('Text');
-      expect(result).toEqual(['a', 'b']);
-    });
-
-    it('should fall back to comma splitting if JSON fails', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'keyword1, keyword2, keyword3' } }]
-      });
-
-      const result = await llm.extractKeywords('Text');
-      expect(result).toEqual(['keyword1', 'keyword2', 'keyword3']);
-    });
-
-    it('should respect maxKeywords parameter', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '["a", "b", "c"]' } }]
-      });
-
-      await llm.extractKeywords('Text', 5);
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('5');
-    });
-  });
-
-  describe('categorize', () => {
-    it('should categorize text into one of the categories', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '{"category": "sports", "confidence": 0.9, "reasoning": "Text is about sports"}' } }]
-      });
-
-      const result = await llm.categorize('Football game', ['sports', 'politics', 'tech']);
-
-      expect(result).toEqual({
-        category: 'sports',
-        confidence: 0.9,
-        reasoning: 'Text is about sports'
-      });
-    });
-
-    it('should handle non-JSON response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'The category is {"category": "tech", "confidence": 0.8, "reasoning": "about tech"}' } }]
-      });
-
-      const result = await llm.categorize('AI text', ['tech']);
-      expect(result.category).toBe('tech');
-    });
-
-    it('should fall back to first category on parse failure', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Unable to parse' } }]
-      });
-
-      const result = await llm.categorize('Text', ['first', 'second']);
-      expect(result.category).toBe('first');
-      expect(result.confidence).toBe(0.5);
-    });
-  });
-
-  describe('translate', () => {
-    it('should translate text to target language', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Bonjour le monde' } }]
-      });
-
-      const result = await llm.translate('Hello world', 'French');
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('French');
-      expect(result).toBe('Bonjour le monde');
-    });
-  });
-
-  describe('generateQuestions', () => {
-    it('should generate questions as JSON array', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '["Question 1?", "Question 2?"]' } }]
-      });
-
-      const result = await llm.generateQuestions('Some content');
-      expect(result).toEqual(['Question 1?', 'Question 2?']);
-    });
-
-    it('should handle non-JSON by extracting array', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Questions: ["Q1?", "Q2?"]' } }]
-      });
-
-      const result = await llm.generateQuestions('Content');
-      expect(result).toEqual(['Q1?', 'Q2?']);
-    });
-
-    it('should fall back to line splitting for questions', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'What is this?\nWhy does it matter?' } }]
-      });
-
-      const result = await llm.generateQuestions('Content');
-      expect(result).toContain('What is this?');
-      expect(result).toContain('Why does it matter?');
-    });
-
-    it('should respect count parameter', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '["Q1?", "Q2?", "Q3?"]' } }]
-      });
-
-      await llm.generateQuestions('Content', 3);
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('3');
-    });
-  });
-
-  describe('getJSON', () => {
-    it('should return parsed JSON from response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '{"key": "value", "number": 42}' } }]
-      });
-
-      const result = await llm.getJSON('System prompt', 'User message');
-      expect(result).toEqual({ key: 'value', number: 42 });
-    });
-
-    it('should extract JSON from non-pure JSON response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Here is the result: {"data": [1, 2, 3]}' } }]
-      });
-
-      const result = await llm.getJSON('System', 'User');
-      expect(result).toEqual({ data: [1, 2, 3] });
-    });
-
-    it('should extract JSON array from response', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Result: [1, 2, 3]' } }]
-      });
-
-      const result = await llm.getJSON('System', 'User');
-      expect(result).toEqual([1, 2, 3]);
-    });
-
-    it('should throw error on invalid JSON', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: 'Not valid JSON at all' } }]
-      });
-
-      await expect(llm.getJSON('System', 'User'))
-        .rejects.toThrow('Failed to parse JSON response');
-    });
-
-    it('should use low temperature by default', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '{}' } }]
-      });
-
-      await llm.getJSON('System', 'User');
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.temperature).toBe(0.2);
-    });
-
-    it('should append JSON instruction to system prompt', async () => {
-      mockOpenAI.chat.completions.create.mockResolvedValue({
-        choices: [{ message: { content: '{}' } }]
-      });
-
-      await llm.getJSON('Original prompt', 'User');
-
-      const call = mockOpenAI.chat.completions.create.mock.calls[0][0];
-      expect(call.messages[0].content).toContain('Return ONLY valid JSON');
-    });
-  });
-});