mcp-rubber-duck 1.5.1 → 1.6.0

package/tests/tools/ask-duck.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { askDuckTool } from '../../src/tools/ask-duck.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+import { ResponseCache } from '../../src/services/cache.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+jest.mock('../../src/services/cache.js');
+
+describe('askDuckTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+  let mockCache: jest.Mocked<ResponseCache>;
+
+  const mockResponse = {
+    provider: 'openai',
+    nickname: 'OpenAI Duck',
+    content: 'This is a test response from the duck.',
+    model: 'gpt-4',
+    latency: 150,
+    usage: {
+      prompt_tokens: 10,
+      completion_tokens: 20,
+      total_tokens: 30,
+    },
+  };
+
+  beforeEach(() => {
+    mockProviderManager = {
+      askDuck: jest.fn().mockResolvedValue(mockResponse),
+      validateModel: jest.fn().mockReturnValue(true),
+    } as unknown as jest.Mocked<ProviderManager>;
+
+    mockCache = {
+      generateKey: jest.fn().mockReturnValue('test-cache-key'),
+      getOrSet: jest.fn().mockImplementation(async (_key, fetcher) => {
+        const value = await fetcher();
+        return { value, cached: false };
+      }),
+    } as unknown as jest.Mocked<ResponseCache>;
+  });
+
+  it('should throw error when prompt is missing', async () => {
+    await expect(askDuckTool(mockProviderManager, mockCache, {})).rejects.toThrow(
+      'Prompt is required'
+    );
+  });
+
+  it('should ask duck with basic prompt', async () => {
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'What is TypeScript?',
+    });
+
+    expect(mockCache.generateKey).toHaveBeenCalledWith('default', 'What is TypeScript?', {
+      model: undefined,
+      temperature: undefined,
+    });
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('test response');
+  });
+
+  it('should include usage info in response', async () => {
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test prompt',
+    });
+
+    expect(result.content[0].text).toContain('Tokens used: 30');
+    expect(result.content[0].text).toContain('10 prompt');
+    expect(result.content[0].text).toContain('20 completion');
+  });
+
+  it('should show latency and fresh status for non-cached response', async () => {
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test prompt',
+    });
+
+    expect(result.content[0].text).toContain('150ms');
+    expect(result.content[0].text).toContain('Fresh');
+  });
+
+  it('should show cached status for cached response', async () => {
+    mockCache.getOrSet.mockResolvedValue({ value: mockResponse, cached: true });
+
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test prompt',
+    });
+
+    expect(result.content[0].text).toContain('Cached');
+  });
+
+  it('should pass provider option', async () => {
+    await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+      provider: 'groq',
+    });
+
+    expect(mockCache.generateKey).toHaveBeenCalledWith('groq', 'Test', expect.any(Object));
+  });
+
+  it('should pass model and temperature options', async () => {
+    await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+      provider: 'openai',
+      model: 'gpt-3.5-turbo',
+      temperature: 0.5,
+    });
+
+    expect(mockCache.generateKey).toHaveBeenCalledWith('openai', 'Test', {
+      model: 'gpt-3.5-turbo',
+      temperature: 0.5,
+    });
+  });
+
+  it('should validate model when both provider and model are specified', async () => {
+    await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+      provider: 'openai',
+      model: 'gpt-4',
+    });
+
+    expect(mockProviderManager.validateModel).toHaveBeenCalledWith('openai', 'gpt-4');
+  });
+
+  it('should not validate model when provider is not specified', async () => {
+    await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+      model: 'gpt-4',
+    });
+
+    expect(mockProviderManager.validateModel).not.toHaveBeenCalled();
+  });
+
+  it('should handle response without usage info', async () => {
+    const responseWithoutUsage = { ...mockResponse, usage: undefined };
+    mockCache.getOrSet.mockResolvedValue({ value: responseWithoutUsage, cached: false });
+
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).not.toContain('Tokens used');
+  });
+
+  it('should warn when model is not valid for provider', async () => {
+    mockProviderManager.validateModel.mockReturnValue(false);
+
+    // Should still work, just log a warning
+    const result = await askDuckTool(mockProviderManager, mockCache, {
+      prompt: 'Test',
+      provider: 'openai',
+      model: 'invalid-model',
+    });
+
+    expect(mockProviderManager.validateModel).toHaveBeenCalledWith('openai', 'invalid-model');
+    expect(result.content[0].text).toContain('test response');
+  });
+});

package/tests/tools/chat-duck.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { chatDuckTool } from '../../src/tools/chat-duck.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+import { ConversationManager } from '../../src/services/conversation.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+jest.mock('../../src/services/conversation.js');
+
+describe('chatDuckTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+  let mockConversationManager: jest.Mocked<ConversationManager>;
+
+  const mockResponse = {
+    provider: 'openai',
+    nickname: 'OpenAI Duck',
+    content: 'This is a test response.',
+    model: 'gpt-4',
+    latency: 150,
+  };
+
+  const mockConversation = {
+    id: 'test-conv',
+    provider: 'openai',
+    messages: [],
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    mockProviderManager = {
+      askDuck: jest.fn().mockResolvedValue(mockResponse),
+      getProviderNames: jest.fn().mockReturnValue(['openai', 'groq']),
+    } as unknown as jest.Mocked<ProviderManager>;
+
+    mockConversationManager = {
+      getConversation: jest.fn().mockReturnValue(mockConversation),
+      createConversation: jest.fn().mockReturnValue(mockConversation),
+      switchProvider: jest.fn().mockReturnValue({ ...mockConversation, provider: 'groq' }),
+      addMessage: jest.fn().mockReturnValue(mockConversation),
+      getConversationContext: jest.fn().mockReturnValue([]),
+    } as unknown as jest.Mocked<ConversationManager>;
+  });
+
+  it('should throw error when conversation_id is missing', async () => {
+    await expect(
+      chatDuckTool(mockProviderManager, mockConversationManager, { message: 'Hello' })
+    ).rejects.toThrow('conversation_id and message are required');
+  });
+
+  it('should throw error when message is missing', async () => {
+    await expect(
+      chatDuckTool(mockProviderManager, mockConversationManager, { conversation_id: 'test' })
+    ).rejects.toThrow('conversation_id and message are required');
+  });
+
+  it('should create new conversation if not exists', async () => {
+    mockConversationManager.getConversation.mockReturnValue(undefined);
+
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'new-conv',
+      message: 'Hello',
+    });
+
+    expect(mockConversationManager.createConversation).toHaveBeenCalledWith('new-conv', 'openai');
+  });
+
+  it('should use existing conversation', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+    });
+
+    expect(mockConversationManager.createConversation).not.toHaveBeenCalled();
+  });
+
+  it('should switch provider when requested', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+      provider: 'groq',
+    });
+
+    expect(mockConversationManager.switchProvider).toHaveBeenCalledWith('test-conv', 'groq');
+  });
+
+  it('should not switch provider if same as current', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+      provider: 'openai', // Same as mockConversation.provider
+    });
+
+    expect(mockConversationManager.switchProvider).not.toHaveBeenCalled();
+  });
+
+  it('should add user message to conversation', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'What is TypeScript?',
+    });
+
+    expect(mockConversationManager.addMessage).toHaveBeenCalledWith(
+      'test-conv',
+      expect.objectContaining({
+        role: 'user',
+        content: 'What is TypeScript?',
+      })
+    );
+  });
+
+  it('should add assistant response to conversation', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+    });
+
+    expect(mockConversationManager.addMessage).toHaveBeenCalledWith(
+      'test-conv',
+      expect.objectContaining({
+        role: 'assistant',
+        content: 'This is a test response.',
+      })
+    );
+  });
+
+  it('should pass conversation context to provider', async () => {
+    const contextMessages = [
+      { role: 'user' as const, content: 'Previous', timestamp: new Date() },
+    ];
+    mockConversationManager.getConversationContext.mockReturnValue(contextMessages);
+
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+    });
+
+    expect(mockProviderManager.askDuck).toHaveBeenCalledWith(
+      'openai',
+      '',
+      expect.objectContaining({
+        messages: contextMessages,
+      })
+    );
+  });
+
+  it('should pass model option to provider', async () => {
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+      model: 'gpt-3.5-turbo',
+    });
+
+    expect(mockProviderManager.askDuck).toHaveBeenCalledWith(
+      'openai',
+      '',
+      expect.objectContaining({
+        model: 'gpt-3.5-turbo',
+      })
+    );
+  });
+
+  it('should format response with conversation info', async () => {
+    mockConversationManager.getConversationContext.mockReturnValue([
+      { role: 'user' as const, content: 'Hello', timestamp: new Date() },
+    ]);
+
+    const result = await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'test-conv',
+      message: 'Hello',
+    });
+
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('test-conv');
+    expect(result.content[0].text).toContain('Messages: 2'); // context (1) + 1 new
+    expect(result.content[0].text).toContain('150ms');
+  });
+
+  it('should use specified provider for new conversation', async () => {
+    mockConversationManager.getConversation.mockReturnValue(undefined);
+
+    await chatDuckTool(mockProviderManager, mockConversationManager, {
+      conversation_id: 'new-conv',
+      message: 'Hello',
+      provider: 'groq',
+    });
+
+    expect(mockConversationManager.createConversation).toHaveBeenCalledWith('new-conv', 'groq');
+  });
+});

package/tests/tools/compare-ducks.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { compareDucksTool } from '../../src/tools/compare-ducks.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+
+describe('compareDucksTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+
+  const mockResponses = [
+    {
+      provider: 'openai',
+      nickname: 'OpenAI Duck',
+      content: 'OpenAI says: TypeScript is great!',
+      model: 'gpt-4',
+      latency: 150,
+      cached: false,
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+    },
+    {
+      provider: 'groq',
+      nickname: 'Groq Duck',
+      content: 'Groq says: TypeScript rocks!',
+      model: 'llama-3.1-70b',
+      latency: 80,
+      cached: false,
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 15,
+        total_tokens: 25,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    mockProviderManager = {
+      compareDucks: jest.fn().mockResolvedValue(mockResponses),
+    } as unknown as jest.Mocked<ProviderManager>;
+  });
+
+  it('should throw error when prompt is missing', async () => {
+    await expect(compareDucksTool(mockProviderManager, {})).rejects.toThrow('Prompt is required');
+  });
+
+  it('should compare ducks with basic prompt', async () => {
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'What is TypeScript?',
+    });
+
+    expect(mockProviderManager.compareDucks).toHaveBeenCalledWith(
+      'What is TypeScript?',
+      undefined,
+      { model: undefined }
+    );
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('Asked:');
+    expect(result.content[0].text).toContain('What is TypeScript?');
+  });
+
+  it('should display all duck responses', async () => {
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Groq Duck');
+    expect(result.content[0].text).toContain('OpenAI says');
+    expect(result.content[0].text).toContain('Groq says');
+  });
+
+  it('should display model and token usage', async () => {
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('gpt-4');
+    expect(result.content[0].text).toContain('llama-3.1-70b');
+    expect(result.content[0].text).toContain('Tokens: 30');
+    expect(result.content[0].text).toContain('Tokens: 25');
+  });
+
+  it('should display latency info', async () => {
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('150ms');
+    expect(result.content[0].text).toContain('80ms');
+  });
+
+  it('should show cached indicator when response is cached', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([
+      {
+        ...mockResponses[0],
+        cached: true,
+      },
+    ]);
+
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('Cached');
+  });
+
+  it('should show success count in summary', async () => {
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('2/2 ducks responded successfully');
+  });
+
+  it('should handle error responses', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([
+      mockResponses[0],
+      {
+        provider: 'groq',
+        nickname: 'Groq Duck',
+        content: 'Error: API key invalid',
+        model: '',
+        latency: 0,
+        cached: false,
+      },
+    ]);
+
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('Error: API key invalid');
+    expect(result.content[0].text).toContain('1/2 ducks responded successfully');
+  });
+
+  it('should pass specific providers when provided', async () => {
+    await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+      providers: ['openai', 'groq'],
+    });
+
+    expect(mockProviderManager.compareDucks).toHaveBeenCalledWith('Test', ['openai', 'groq'], {
+      model: undefined,
+    });
+  });
+
+  it('should pass model option', async () => {
+    await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+      model: 'gpt-3.5-turbo',
+    });
+
+    expect(mockProviderManager.compareDucks).toHaveBeenCalledWith('Test', undefined, {
+      model: 'gpt-3.5-turbo',
+    });
+  });
+
+  it('should handle empty response list', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([]);
+
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('0/0 ducks responded successfully');
+  });
+
+  it('should not show latency when zero', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([
+      {
+        ...mockResponses[0],
+        latency: 0,
+      },
+    ]);
+
+    const result = await compareDucksTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    // When latency is 0, the ms indicator should not be shown for that response
+    // (the code checks latency > 0)
+    expect(result.content[0].text).not.toContain('0ms');
+  });
+});