mcp-rubber-duck 1.1.0

package/tests/conversation.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { ConversationManager } from '../src/services/conversation.js';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../src/utils/logger');
+
+describe('ConversationManager', () => {
+  let conversationManager: ConversationManager;
+
+  beforeEach(() => {
+    conversationManager = new ConversationManager();
+  });
+
+  describe('conversation creation and retrieval', () => {
+    it('should create a new conversation', () => {
+      const conversation = conversationManager.createConversation('test-1', 'openai');
+      
+      expect(conversation.id).toBe('test-1');
+      expect(conversation.provider).toBe('openai');
+      expect(conversation.messages).toHaveLength(0);
+      expect(conversation.createdAt).toBeInstanceOf(Date);
+      expect(conversation.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('should retrieve an existing conversation', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      const retrieved = conversationManager.getConversation('test-1');
+      
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.id).toBe('test-1');
+    });
+
+    it('should return undefined for non-existent conversation', () => {
+      const retrieved = conversationManager.getConversation('nonexistent');
+      expect(retrieved).toBeUndefined();
+    });
+  });
+
+  describe('message handling', () => {
+    beforeEach(() => {
+      conversationManager.createConversation('test-1', 'openai');
+    });
+
+    it('should add messages to conversation', () => {
+      const message = {
+        role: 'user' as const,
+        content: 'Hello duck',
+        timestamp: new Date(),
+      };
+
+      const conversation = conversationManager.addMessage('test-1', message);
+      
+      expect(conversation.messages).toHaveLength(1);
+      expect(conversation.messages[0]).toEqual(message);
+      expect(conversation.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('should throw error for non-existent conversation when adding message', () => {
+      const message = {
+        role: 'user' as const,
+        content: 'Hello duck',
+        timestamp: new Date(),
+      };
+
+      expect(() => {
+        conversationManager.addMessage('nonexistent', message);
+      }).toThrow('Conversation nonexistent not found');
+    });
+
+    it('should trim conversations that exceed max size', () => {
+      // Add 55 messages (exceeds max of 50)
+      for (let i = 0; i < 55; i++) {
+        conversationManager.addMessage('test-1', {
+          role: 'user' as const,
+          content: `Message ${i}`,
+          timestamp: new Date(),
+        });
+      }
+
+      const conversation = conversationManager.getConversation('test-1');
+      
+      // Should be trimmed to 50 messages
+      expect(conversation!.messages).toHaveLength(50);
+      // Should keep the latest messages
+      expect(conversation!.messages[0].content).toBe('Message 5');
+      expect(conversation!.messages[49].content).toBe('Message 54');
+    });
+  });
+
+  describe('provider switching', () => {
+    beforeEach(() => {
+      conversationManager.createConversation('test-1', 'openai');
+    });
+
+    it('should switch provider and add system message', () => {
+      const conversation = conversationManager.switchProvider('test-1', 'groq');
+      
+      expect(conversation.provider).toBe('groq');
+      expect(conversation.messages).toHaveLength(1);
+      expect(conversation.messages[0].role).toBe('system');
+      expect(conversation.messages[0].content).toBe('Switched to groq duck');
+      expect(conversation.messages[0].provider).toBe('groq');
+    });
+
+    it('should throw error for non-existent conversation when switching provider', () => {
+      expect(() => {
+        conversationManager.switchProvider('nonexistent', 'groq');
+      }).toThrow('Conversation nonexistent not found');
+    });
+  });
+
+  describe('conversation context', () => {
+    beforeEach(() => {
+      conversationManager.createConversation('test-1', 'openai');
+      
+      // Add some messages
+      for (let i = 0; i < 5; i++) {
+        conversationManager.addMessage('test-1', {
+          role: 'user' as const,
+          content: `Message ${i}`,
+          timestamp: new Date(),
+        });
+      }
+    });
+
+    it('should return all messages when no limit specified', () => {
+      const context = conversationManager.getConversationContext('test-1');
+      expect(context).toHaveLength(5);
+    });
+
+    it('should return limited messages when maxMessages specified', () => {
+      const context = conversationManager.getConversationContext('test-1', 3);
+      expect(context).toHaveLength(3);
+      // Should return the last 3 messages
+      expect(context[0].content).toBe('Message 2');
+      expect(context[2].content).toBe('Message 4');
+    });
+
+    it('should return empty array for non-existent conversation', () => {
+      const context = conversationManager.getConversationContext('nonexistent');
+      expect(context).toEqual([]);
+    });
+  });
+
+  describe('conversation management', () => {
+    it('should list all conversations', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.createConversation('test-2', 'groq');
+      
+      const list = conversationManager.listConversations();
+      expect(list).toHaveLength(2);
+      expect(list[0].id).toBe('test-1');
+      expect(list[1].id).toBe('test-2');
+      expect(list[0].messageCount).toBe(0);
+    });
+
+    it('should delete conversation', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      
+      const deleted = conversationManager.deleteConversation('test-1');
+      expect(deleted).toBe(true);
+      
+      const retrieved = conversationManager.getConversation('test-1');
+      expect(retrieved).toBeUndefined();
+    });
+
+    it('should return false when deleting non-existent conversation', () => {
+      const deleted = conversationManager.deleteConversation('nonexistent');
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe('clearAll functionality', () => {
+    it('should clear empty conversation list', () => {
+      const result = conversationManager.clearAll();
+      
+      expect(result.conversationsCleared).toBe(0);
+      expect(result.messagesCleared).toBe(0);
+    });
+
+    it('should clear single conversation', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'Hello',
+        timestamp: new Date(),
+      });
+
+      const result = conversationManager.clearAll();
+      
+      expect(result.conversationsCleared).toBe(1);
+      expect(result.messagesCleared).toBe(1);
+      
+      // Verify conversations are actually cleared
+      const retrieved = conversationManager.getConversation('test-1');
+      expect(retrieved).toBeUndefined();
+    });
+
+    it('should clear multiple conversations with correct counts', () => {
+      // Create first conversation with 2 messages
+      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(),
+      });
+
+      // Create second conversation with 3 messages
+      conversationManager.createConversation('test-2', 'groq');
+      conversationManager.addMessage('test-2', {
+        role: 'user' as const,
+        content: 'Hello 2',
+        timestamp: new Date(),
+      });
+      conversationManager.addMessage('test-2', {
+        role: 'assistant' as const,
+        content: 'Hi 2',
+        timestamp: new Date(),
+      });
+      conversationManager.addMessage('test-2', {
+        role: 'user' as const,
+        content: 'Follow up',
+        timestamp: new Date(),
+      });
+
+      const result = conversationManager.clearAll();
+      
+      expect(result.conversationsCleared).toBe(2);
+      expect(result.messagesCleared).toBe(5);
+      
+      // Verify all conversations are cleared
+      expect(conversationManager.getConversation('test-1')).toBeUndefined();
+      expect(conversationManager.getConversation('test-2')).toBeUndefined();
+      expect(conversationManager.listConversations()).toHaveLength(0);
+    });
+
+    it('should allow new conversations after clear', () => {
+      // Create and clear
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.clearAll();
+      
+      // Create new conversation after clear
+      const newConversation = conversationManager.createConversation('test-2', 'groq');
+      
+      expect(newConversation.id).toBe('test-2');
+      expect(newConversation.provider).toBe('groq');
+      expect(conversationManager.listConversations()).toHaveLength(1);
+    });
+  });
+
+  describe('conversation persistence', () => {
+    it('should maintain conversation between message additions', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      
+      // Add first message
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'First message',
+        timestamp: new Date(),
+      });
+      
+      // Add second message
+      conversationManager.addMessage('test-1', {
+        role: 'assistant' as const,
+        content: 'First response',
+        timestamp: new Date(),
+      });
+      
+      const conversation = conversationManager.getConversation('test-1');
+      expect(conversation!.messages).toHaveLength(2);
+      expect(conversation!.messages[0].content).toBe('First message');
+      expect(conversation!.messages[1].content).toBe('First response');
+    });
+
+    it('should handle provider switching without losing messages', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      
+      // Add initial message
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'Before switch',
+        timestamp: new Date(),
+      });
+      
+      // Switch provider
+      conversationManager.switchProvider('test-1', 'groq');
+      
+      // Add message after switch
+      conversationManager.addMessage('test-1', {
+        role: 'user' as const,
+        content: 'After switch',
+        timestamp: new Date(),
+      });
+      
+      const conversation = conversationManager.getConversation('test-1');
+      expect(conversation!.messages).toHaveLength(3);
+      expect(conversation!.messages[0].content).toBe('Before switch');
+      expect(conversation!.messages[1].content).toBe('Switched to groq duck');
+      expect(conversation!.messages[2].content).toBe('After switch');
+      expect(conversation!.provider).toBe('groq');
+    });
+  });
+});

package/tests/mcp-bridge.test.ts

@@ -0,0 +1,291 @@
+import { jest } from '@jest/globals';
+import { ApprovalService } from '../src/services/approval';
+import { FunctionBridge } from '../src/services/function-bridge';
+import { MCPClientManager } from '../src/services/mcp-client-manager';
+
+describe('MCP Bridge', () => {
+  let approvalService: ApprovalService;
+  let mcpManager: MCPClientManager;
+  let functionBridge: FunctionBridge;
+
+  beforeEach(() => {
+    approvalService = new ApprovalService(300); // 5 minutes
+    mcpManager = new MCPClientManager([]); // Empty config for testing
+    functionBridge = new FunctionBridge(mcpManager, approvalService, []);
+  });
+
+  afterEach(() => {
+    approvalService.shutdown();
+  });
+
+  describe('ApprovalService', () => {
+    it('should create approval requests', () => {
+      const request = approvalService.createApprovalRequest(
+        'TestDuck',
+        'filesystem',
+        'read_file',
+        { path: '/test.txt' }
+      );
+
+      expect(request).toBeDefined();
+      expect(request.duckName).toBe('TestDuck');
+      expect(request.mcpServer).toBe('filesystem');
+      expect(request.toolName).toBe('read_file');
+      expect(request.status).toBe('pending');
+    });
+
+    it('should approve pending requests', () => {
+      const request = approvalService.createApprovalRequest(
+        'TestDuck',
+        'filesystem',
+        'read_file',
+        { path: '/test.txt' }
+      );
+
+      const approved = approvalService.approveRequest(request.id);
+      expect(approved).toBe(true);
+
+      const status = approvalService.getApprovalStatus(request.id);
+      expect(status).toBe('approved');
+    });
+
+    it('should deny requests', () => {
+      const request = approvalService.createApprovalRequest(
+        'TestDuck',
+        'filesystem',
+        'read_file',
+        { path: '/test.txt' }
+      );
+
+      const denied = approvalService.denyRequest(request.id, 'Security concern');
+      expect(denied).toBe(true);
+
+      const status = approvalService.getApprovalStatus(request.id);
+      expect(status).toBe('denied');
+    });
+
+    it('should handle non-existent requests', () => {
+      const status = approvalService.getApprovalStatus('non-existent');
+      expect(status).toBeUndefined();
+
+      const approved = approvalService.approveRequest('non-existent');
+      expect(approved).toBe(false);
+    });
+
+    it('should get pending approvals', () => {
+      approvalService.createApprovalRequest('Duck1', 'server1', 'tool1', {});
+      approvalService.createApprovalRequest('Duck2', 'server2', 'tool2', {});
+
+      const pending = approvalService.getPendingApprovals();
+      expect(pending).toHaveLength(2);
+      expect(pending.every(req => req.status === 'pending')).toBe(true);
+    });
+  });
+
+  describe('FunctionBridge', () => {
+    it('should generate function definitions for empty MCP tools', async () => {
+      const functions = await functionBridge.getFunctionDefinitions();
+      expect(Array.isArray(functions)).toBe(true);
+      // Should be empty since we have no MCP servers configured
+      expect(functions).toHaveLength(0);
+    });
+
+    it('should handle function calls requiring approval', async () => {
+      const result = await functionBridge.handleFunctionCall(
+        'TestDuck',
+        'mcp__filesystem__read_file',
+        { path: '/test.txt', _mcp_server: 'filesystem', _mcp_tool: 'read_file' }
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.needsApproval).toBe(true);
+      expect(result.approvalId).toBeDefined();
+    });
+
+    it('should handle invalid function names', async () => {
+      const result = await functionBridge.handleFunctionCall(
+        'TestDuck',
+        'invalid_function',
+        {}
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid function name');
+    });
+
+    it('should validate tool arguments', async () => {
+      // Mock a tool with schema in the functionBridge
+      const mockTool = {
+        serverName: 'test_server',
+        name: 'test_tool',
+        description: 'Test tool',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            required_param: { type: 'string' }
+          },
+          required: ['required_param']
+        }
+      };
+
+      // Add the tool schema manually for testing
+      (functionBridge as any).toolSchemas.set('test_server:test_tool', mockTool.inputSchema);
+
+      const result = await functionBridge.handleFunctionCall(
+        'TestDuck',
+        'mcp__test_server__test_tool',
+        { 
+          _mcp_server: 'test_server', 
+          _mcp_tool: 'test_tool',
+          // Missing required_param
+        }
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid arguments');
+    });
+
+    it('should handle underscored tool names correctly', async () => {
+      // Test that tool names with underscores are extracted correctly
+      const serverName = (functionBridge as any).extractServerFromFunctionName('mcp__file_system__read_file');
+      const toolName = (functionBridge as any).extractToolFromFunctionName('mcp__file_system__read_file');
+      
+      expect(serverName).toBe('file_system');
+      expect(toolName).toBe('read_file');
+    });
+
+    it('should handle complex server and tool names', async () => {
+      // Test more complex names
+      const serverName = (functionBridge as any).extractServerFromFunctionName('mcp__complex_server_name__complex_tool_name');
+      const toolName = (functionBridge as any).extractToolFromFunctionName('mcp__complex_server_name__complex_tool_name');
+      
+      expect(serverName).toBe('complex_server_name');
+      expect(toolName).toBe('complex_tool_name');
+    });
+  });
+
+  describe('MCPClientManager', () => {
+    it('should initialize with empty config', async () => {
+      expect(mcpManager.getConnectedServers()).toEqual([]);
+      expect(mcpManager.getConnectionStatus('nonexistent')).toBe('unknown');
+    });
+
+    it('should handle health check with no servers', async () => {
+      const health = await mcpManager.healthCheck();
+      expect(health).toEqual({});
+    });
+
+    it('should get status of all servers', () => {
+      const status = mcpManager.getStatus();
+      expect(typeof status).toBe('object');
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should handle complete approval workflow', async () => {
+      // Create approval request
+      const request = approvalService.createApprovalRequest(
+        'TestDuck',
+        'filesystem',
+        'read_file',
+        { path: '/test.txt' }
+      );
+
+      expect(request.status).toBe('pending');
+
+      // Try function call without approval
+      const result1 = await functionBridge.handleFunctionCall(
+        'TestDuck',
+        'mcp__filesystem__read_file',
+        { 
+          path: '/test.txt',
+          _mcp_server: 'filesystem', 
+          _mcp_tool: 'read_file'
+        }
+      );
+
+      expect(result1.success).toBe(false);
+      expect(result1.needsApproval).toBe(true);
+
+      // Approve the request
+      const approved = approvalService.approveRequest(request.id);
+      expect(approved).toBe(true);
+
+      // Try function call with approval (would still fail due to no MCP server, but approval logic works)
+      const result2 = await functionBridge.handleFunctionCall(
+        'TestDuck',
+        'mcp__filesystem__read_file',
+        { 
+          path: '/test.txt',
+          _mcp_server: 'filesystem', 
+          _mcp_tool: 'read_file',
+          _approval_id: request.id
+        }
+      );
+
+      // Should pass approval but fail on MCP execution
+      expect(result2.error).toContain('MCP server filesystem not connected');
+    });
+
+    it('should handle expired approvals', (done) => {
+      // Create approval service with very short timeout
+      const shortApprovalService = new ApprovalService(1); // 1 second
+      
+      const request = shortApprovalService.createApprovalRequest(
+        'TestDuck',
+        'filesystem',
+        'read_file',
+        { path: '/test.txt' }
+      );
+
+      // Wait for expiration
+      setTimeout(() => {
+        const status = shortApprovalService.getApprovalStatus(request.id);
+        expect(status).toBe('expired');
+        
+        // Try to approve expired request
+        const approved = shortApprovalService.approveRequest(request.id);
+        expect(approved).toBe(false);
+        
+        shortApprovalService.shutdown();
+        done();
+      }, 1100);
+    });
+
+    it('should handle function definition generation', async () => {
+      // Mock MCP tools
+      const mockTools = [
+        {
+          serverName: 'filesystem',
+          name: 'read_file',
+          description: 'Read a file',
+          inputSchema: {
+            type: 'object',
+            properties: { path: { type: 'string' } },
+            required: ['path']
+          }
+        },
+        {
+          serverName: 'web',
+          name: 'fetch_url',
+          description: 'Fetch URL content',
+          inputSchema: {
+            type: 'object',
+            properties: { url: { type: 'string' } },
+            required: ['url']
+          }
+        }
+      ];
+
+      // Mock the listAllTools method
+      jest.spyOn(mcpManager, 'listAllTools').mockResolvedValue(mockTools);
+
+      const functions = await functionBridge.getFunctionDefinitions();
+      
+      expect(functions).toHaveLength(2);
+      expect(functions[0].name).toBe('mcp__filesystem__read_file');
+      expect(functions[1].name).toBe('mcp__web__fetch_url');
+      expect(functions[0].description).toBe('[filesystem] Read a file');
+    });
+  });
+});