mcp-rubber-duck 1.1.0

package/tests/providers.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock OpenAI BEFORE importing the provider
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+  const MockOpenAI = jest.fn().mockImplementation(() => ({
+    chat: {
+      completions: {
+        create: mockCreate,
+      },
+    },
+  }));
+  return {
+    __esModule: true,
+    default: MockOpenAI,
+  };
+});
+
+// Mock config manager and logger
+jest.mock('../src/config/config');
+jest.mock('../src/utils/logger');
+
+// NOW import the modules after setting up mocks
+import { DuckProvider } from '../src/providers/provider';
+import { ProviderManager } from '../src/providers/manager';
+import { ConfigManager } from '../src/config/config';
+
+describe('DuckProvider', () => {
+  let provider: DuckProvider;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Setup mock response
+    mockCreate.mockResolvedValue({
+      choices: [{
+        message: { content: 'Mocked response' },
+        finish_reason: 'stop',
+      }],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+      model: 'mock-model',
+    });
+    
+    provider = new DuckProvider('test', 'Test Duck', {
+      apiKey: 'test-key',
+      baseURL: 'https://api.test.com/v1',
+      model: 'test-model',
+      temperature: 0.7,
+    });
+    
+    // Override the method on the actual instance since Jest ESM mocking isn't working
+    provider['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should create a provider instance', () => {
+    expect(provider).toBeDefined();
+    expect(provider.name).toBe('test');
+    expect(provider.nickname).toBe('Test Duck');
+  });
+
+  it('should get provider info', () => {
+    const info = provider.getInfo();
+    expect(info).toEqual({
+      name: 'test',
+      nickname: 'Test Duck',
+      model: 'test-model',
+      baseURL: 'https://api.test.com/v1',
+      hasApiKey: true,
+    });
+  });
+
+  it('should send chat request', async () => {
+    console.log('Starting chat request test');
+    console.log('Mock create has been called:', mockCreate.mock.calls.length, 'times');
+    
+    const response = await provider.chat({
+      messages: [
+        { role: 'user', content: 'Hello', timestamp: new Date() },
+      ],
+    });
+
+    console.log('Chat response received:', response);
+    expect(response).toBeDefined();
+    expect(response.content).toBe('Mocked response');
+    expect(response.usage).toBeDefined();
+    expect(response.model).toBe('test-model');
+  });
+
+  it('should use correct parameters for o1 models', async () => {
+    mockCreate.mockClear();
+
+    const testProvider = new DuckProvider('test', 'Test Duck', {
+      apiKey: 'test-key',
+      baseURL: 'https://api.test.com/v1',
+      model: 'o1',
+    });
+
+    // Override the method on the actual instance since Jest ESM mocking isn't working
+    testProvider['client'].chat.completions.create = mockCreate;
+
+    await testProvider.chat({
+      messages: [{ role: 'user', content: 'Hello', timestamp: new Date() }],
+      model: 'o1',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const calls = (mockCreate as any).mock.calls;
+    expect(calls.length).toBeGreaterThan(0);
+    const callParams = calls[0][0];
+    
+    // o1 models should NOT have temperature or token limits
+    expect(callParams).not.toHaveProperty('temperature');
+  });
+
+  it('should use correct parameters for GPT-5 models', async () => {
+    mockCreate.mockClear();
+
+    const testProvider = new DuckProvider('test', 'Test Duck', {
+      apiKey: 'test-key',
+      baseURL: 'https://api.test.com/v1',
+      model: 'gpt-5',
+    });
+
+    // Override the method on the actual instance since Jest ESM mocking isn't working
+    testProvider['client'].chat.completions.create = mockCreate;
+
+    await testProvider.chat({
+      messages: [{ role: 'user', content: 'Hello', timestamp: new Date() }],
+      model: 'gpt-5',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const calls = (mockCreate as any).mock.calls;
+    expect(calls.length).toBeGreaterThan(0);
+    const callParams = calls[0][0];
+    
+    // GPT-5 models should NOT have temperature or token limits
+    expect(callParams).not.toHaveProperty('temperature');
+  });
+
+  it('should use correct parameters for non-o1 models', async () => {
+    mockCreate.mockClear();
+
+    const testProvider = new DuckProvider('test', 'Test Duck', {
+      apiKey: 'test-key',
+      baseURL: 'https://api.test.com/v1',
+      model: 'gpt-4',
+    });
+
+    // Override the method on the actual instance since Jest ESM mocking isn't working
+    testProvider['client'].chat.completions.create = mockCreate;
+
+    await testProvider.chat({
+      messages: [{ role: 'user', content: 'Hello', timestamp: new Date() }],
+      model: 'gpt-4',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const calls = (mockCreate as any).mock.calls;
+    expect(calls.length).toBeGreaterThan(0);
+    const callParams = calls[0][0];
+    
+    // non-o1 models should have temperature but no token limits
+    expect(callParams).toHaveProperty('temperature');
+  });
+});
+
+describe('ProviderManager', () => {
+  let manager: ProviderManager;
+  let mockConfigManager: jest.Mocked<ConfigManager>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Setup mock response
+    mockCreate.mockResolvedValue({
+      choices: [{
+        message: { content: 'Mocked response' },
+        finish_reason: 'stop',
+      }],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+      model: 'mock-model',
+    });
+    
+    mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          test1: {
+            api_key: 'key1',
+            base_url: 'https://api1.test.com/v1',
+            default_model: 'model1',
+            nickname: 'Duck 1',
+            models: ['model1'],
+          },
+          test2: {
+            api_key: 'key2',
+            base_url: 'https://api2.test.com/v1',
+            default_model: 'model2',
+            nickname: 'Duck 2',
+            models: ['model2'],
+          },
+        },
+        default_provider: 'test1',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as any;
+
+    manager = new ProviderManager(mockConfigManager);
+    
+    // Override the client method on all providers in the manager
+    const provider1 = manager.getProvider('test1');
+    const provider2 = manager.getProvider('test2');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should initialize providers from config', () => {
+    const providers = manager.getProviderNames();
+    expect(providers).toContain('test1');
+    expect(providers).toContain('test2');
+  });
+
+  it('should get a specific provider', () => {
+    const provider = manager.getProvider('test1');
+    expect(provider).toBeDefined();
+    expect(provider.name).toBe('test1');
+  });
+
+  it('should get default provider when no name specified', () => {
+    const provider = manager.getProvider();
+    expect(provider).toBeDefined();
+    expect(provider.name).toBe('test1');
+  });
+
+  it('should throw error for non-existent provider', () => {
+    expect(() => manager.getProvider('nonexistent')).toThrow(
+      'Duck "nonexistent" not found in the pond'
+    );
+  });
+
+  it('should ask a duck', async () => {
+    const response = await manager.askDuck('test1', 'Hello');
+    expect(response).toBeDefined();
+    expect(response.provider).toBe('test1');
+    expect(response.content).toBe('Mocked response');
+  });
+
+  it('should compare multiple ducks', async () => {
+    const responses = await manager.compareDucks('Hello', ['test1', 'test2']);
+    expect(responses).toHaveLength(2);
+    expect(responses[0].provider).toBe('test1');
+    expect(responses[1].provider).toBe('test2');
+  });
+
+  it('should run duck council', async () => {
+    const responses = await manager.duckCouncil('Hello');
+    expect(responses).toHaveLength(2);
+  });
+});

package/tests/tools/clear-conversations.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { clearConversationsTool } from '../../src/tools/clear-conversations.js';
+import { ConversationManager } from '../../src/services/conversation.js';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../../src/utils/logger');
+
+describe('clear_conversations tool', () => {
+  let conversationManager: ConversationManager;
+
+  beforeEach(() => {
+    conversationManager = new ConversationManager();
+  });
+
+  describe('tool execution', () => {
+    it('should call ConversationManager.clearAll and return proper response format', () => {
+      // Create some conversations first
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'Hello',
+        timestamp: new Date(),
+      });
+
+      const result = clearConversationsTool(conversationManager, {});
+      
+      expect(result).toHaveProperty('content');
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0]).toHaveProperty('type', 'text');
+      expect(result.content[0].text).toContain('🧹 Cleared 1 conversation (1 message)');
+      expect(result.content[0].text).toContain('🦆 All ducks now have a fresh start!');
+      
+      // Verify conversations were actually cleared
+      expect(conversationManager.getConversation('test-1')).toBeUndefined();
+    });
+
+    it('should handle empty state gracefully', () => {
+      const result = clearConversationsTool(conversationManager, {});
+      
+      expect(result.content[0].text).toContain('🧹 No conversations to clear - memory is already empty!');
+      expect(result.content[0].text).toContain('🦆 All ducks now have a fresh start!');
+    });
+
+    it('should handle multiple conversations correctly', () => {
+      // Create multiple conversations with different message counts
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'Hello 1',
+        timestamp: new Date(),
+      });
+      conversationManager.addMessage('test-1', {
+        role: 'assistant' as const,
+        content: 'Hi 1',
+        timestamp: new Date(),
+      });
+
+      conversationManager.createConversation('test-2', 'groq');
+      conversationManager.addMessage('test-2', {
+        role: 'user' as const,
+        content: 'Hello 2',
+        timestamp: new Date(),
+      });
+
+      conversationManager.createConversation('test-3', 'gemini');
+      // No messages in test-3
+
+      const result = clearConversationsTool(conversationManager, {});
+      
+      expect(result.content[0].text).toContain('🧹 Cleared 3 conversations (3 messages)');
+      expect(result.content[0].text).toContain('🦆 All ducks now have a fresh start!');
+      
+      // Verify all conversations were cleared
+      expect(conversationManager.listConversations()).toHaveLength(0);
+    });
+
+    it('should handle singular vs plural correctly', () => {
+      // Test single conversation with single message
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'Hello',
+        timestamp: new Date(),
+      });
+
+      const result = clearConversationsTool(conversationManager, {});
+      
+      // Should use singular form
+      expect(result.content[0].text).toContain('🧹 Cleared 1 conversation (1 message)');
+      expect(result.content[0].text).not.toContain('conversations');
+      expect(result.content[0].text).not.toContain('messages)');
+    });
+
+    it('should handle args parameter (even though unused)', () => {
+      const args = { unused: 'parameter' };
+      
+      conversationManager.createConversation('test-1', 'openai');
+      const result = clearConversationsTool(conversationManager, args);
+      
+      expect(result).toHaveProperty('content');
+      expect(result.content[0].text).toContain('🧹 Cleared 1 conversation');
+    });
+
+    it('should return consistent response structure', () => {
+      const result = clearConversationsTool(conversationManager, {});
+      
+      // Verify response structure matches MCP tool format
+      expect(result).toEqual({
+        content: [
+          {
+            type: 'text',
+            text: expect.stringContaining('🧹'),
+          },
+        ],
+      });
+      
+      expect(result.content[0].text).toContain('🦆 All ducks now have a fresh start!');
+    });
+  });
+
+  describe('integration with ConversationManager', () => {
+    it('should properly clear all conversation state', () => {
+      // Create complex scenario
+      conversationManager.createConversation('debug-session', 'openai');
+      conversationManager.addMessage('debug-session', {
+        role: 'user' as const,
+        content: 'Help with bug',
+        timestamp: new Date(),
+      });
+      conversationManager.addMessage('debug-session', {
+        role: 'assistant' as const,
+        content: 'Sure, what\'s the issue?',
+        timestamp: new Date(),
+      });
+
+      conversationManager.createConversation('code-review', 'groq');
+      conversationManager.addMessage('code-review', {
+        role: 'user' as const,
+        content: 'Review this code',
+        timestamp: new Date(),
+      });
+
+      // Switch provider in second conversation
+      conversationManager.switchProvider('code-review', 'gemini');
+
+      // Verify setup
+      expect(conversationManager.listConversations()).toHaveLength(2);
+      expect(conversationManager.getConversation('debug-session')!.messages).toHaveLength(2);
+      expect(conversationManager.getConversation('code-review')!.messages).toHaveLength(2); // 1 + 1 system message
+
+      // Clear all
+      const result = clearConversationsTool(conversationManager, {});
+
+      // Verify complete cleanup
+      expect(conversationManager.listConversations()).toHaveLength(0);
+      expect(conversationManager.getConversation('debug-session')).toBeUndefined();
+      expect(conversationManager.getConversation('code-review')).toBeUndefined();
+      
+      // Verify counts in response
+      expect(result.content[0].text).toContain('🧹 Cleared 2 conversations (4 messages)');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}