mcp-rubber-duck 1.1.0

package/test-mcp-interface.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+// Test script for MCP interface (simulates Claude Desktop communication)
+import 'dotenv/config';
+import { spawn } from 'child_process';
+import { Readable, Writable } from 'stream';
+
+console.log('🦆 Testing MCP Rubber Duck via MCP Interface\n');
+
+class MCPClient {
+  constructor() {
+    this.messageId = 0;
+    this.responses = new Map();
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      // Spawn the MCP server as Claude Desktop would
+      this.process = spawn('node', ['dist/index.js'], {
+        env: {
+          ...process.env,
+          MCP_SERVER: 'true',
+          LOG_LEVEL: 'error'
+        }
+      });
+
+      this.process.stderr.on('data', (data) => {
+        console.error(`Server error: ${data}`);
+      });
+
+      this.process.on('error', reject);
+      this.process.on('exit', (code) => {
+        console.log(`Server exited with code ${code}`);
+      });
+
+      // Set up JSON-RPC communication
+      this.setupCommunication();
+      
+      // Initialize the connection
+      setTimeout(() => {
+        this.sendRequest('initialize', {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: {
+            name: 'test-client',
+            version: '1.0.0'
+          }
+        }).then(resolve).catch(reject);
+      }, 100);
+    });
+  }
+
+  setupCommunication() {
+    let buffer = '';
+    
+    this.process.stdout.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            this.handleMessage(message);
+          } catch (e) {
+            console.error('Failed to parse message:', line);
+          }
+        }
+      }
+    });
+  }
+
+  handleMessage(message) {
+    if (message.id && this.responses.has(message.id)) {
+      const { resolve, reject } = this.responses.get(message.id);
+      this.responses.delete(message.id);
+      
+      if (message.error) {
+        reject(new Error(message.error.message));
+      } else {
+        resolve(message.result);
+      }
+    }
+  }
+
+  sendRequest(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const id = `msg_${++this.messageId}`;
+      const request = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      };
+      
+      this.responses.set(id, { resolve, reject });
+      this.process.stdin.write(JSON.stringify(request) + '\n');
+      
+      // Timeout after 10 seconds
+      setTimeout(() => {
+        if (this.responses.has(id)) {
+          this.responses.delete(id);
+          reject(new Error('Request timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  async callTool(toolName, args) {
+    return this.sendRequest('tools/call', {
+      name: toolName,
+      arguments: args
+    });
+  }
+
+  async listTools() {
+    return this.sendRequest('tools/list');
+  }
+
+  stop() {
+    if (this.process) {
+      this.process.kill();
+    }
+  }
+}
+
+async function runMCPTests() {
+  const client = new MCPClient();
+  
+  try {
+    // Initialize connection
+    console.log('📡 Initializing MCP connection...');
+    const initResult = await client.start();
+    console.log('✅ Connected to MCP server');
+    console.log(`   Protocol version: ${initResult.protocolVersion}`);
+    console.log(`   Server: ${initResult.serverInfo?.name || 'Unknown'} v${initResult.serverInfo?.version || 'Unknown'}\n`);
+
+    // Test 1: List available tools
+    console.log('📋 Test 1: List available tools');
+    const toolsResult = await client.listTools();
+    console.log(`Found ${toolsResult.tools.length} tools:`);
+    for (const tool of toolsResult.tools) {
+      console.log(`  - ${tool.name}: ${tool.description}`);
+    }
+    console.log();
+
+    // Test 2: List ducks
+    console.log('🦆 Test 2: List ducks via MCP');
+    const ducksResult = await client.callTool('list_ducks', {
+      check_health: false
+    });
+    console.log('Response received (truncated):', 
+      ducksResult.content[0].text.substring(0, 200) + '...\n');
+
+    // Test 3: Ask a duck
+    console.log('💬 Test 3: Ask OpenAI via MCP');
+    const askResult = await client.callTool('ask_duck', {
+      prompt: 'What is MCP? Answer in one sentence.',
+      provider: 'openai'
+    });
+    console.log('Response:', askResult.content[0].text.split('\n')[0] + '\n');
+
+    // Test 4: List models
+    console.log('📚 Test 4: List models via MCP');
+    const modelsResult = await client.callTool('list_models', {
+      provider: 'openai'
+    });
+    const modelLines = modelsResult.content[0].text.split('\n').slice(0, 10);
+    console.log('First few models:', modelLines.join('\n') + '...\n');
+
+    // Test 5: Compare ducks
+    console.log('🔍 Test 5: Compare ducks via MCP');
+    const compareResult = await client.callTool('compare_ducks', {
+      prompt: 'Is water wet? Answer yes or no.'
+    });
+    console.log('Comparison started (truncated):', 
+      compareResult.content[0].text.substring(0, 300) + '...\n');
+
+    // Test 6: Error handling
+    console.log('❌ Test 6: Error handling');
+    try {
+      await client.callTool('nonexistent_tool', {});
+      console.log('ERROR: Should have thrown an error!');
+    } catch (error) {
+      console.log('✅ Correctly handled invalid tool error:', error.message);
+    }
+    console.log();
+
+    // Test 7: Chat with context
+    console.log('💬 Test 7: Stateful conversation via MCP');
+    await client.callTool('chat_with_duck', {
+      conversation_id: 'mcp-test',
+      message: 'Remember this number: 42',
+      provider: 'openai'
+    });
+    
+    const chatResult = await client.callTool('chat_with_duck', {
+      conversation_id: 'mcp-test',
+      message: 'What number did I ask you to remember?'
+    });
+    console.log('Context test:', chatResult.content[0].text.split('\n')[0] + '\n');
+
+    console.log('✅ All MCP interface tests completed successfully!');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+  } finally {
+    client.stop();
+    process.exit(0);
+  }
+}
+
+// Add timeout to prevent hanging
+setTimeout(() => {
+  console.error('Test timeout - forcefully exiting');
+  process.exit(1);
+}, 30000);
+
+// Run the tests
+runMCPTests().catch(console.error);

package/tests/ascii-art.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from '@jest/globals';
+import { formatDuckResponse, getRandomDuckMessage, duckMessages } from '../src/utils/ascii-art';
+
+describe('formatDuckResponse', () => {
+  it('should format response without model', () => {
+    const result = formatDuckResponse('GPT Duck', 'Hello world');
+    expect(result).toBe('🦆 [GPT Duck]: Hello world');
+  });
+
+  it('should format response with model', () => {
+    const result = formatDuckResponse('GPT Duck', 'Hello world', 'gpt-4o-mini');
+    expect(result).toBe('🦆 [GPT Duck | gpt-4o-mini]: Hello world');
+  });
+
+  it('should handle undefined model', () => {
+    const result = formatDuckResponse('GPT Duck', 'Hello world', undefined);
+    expect(result).toBe('🦆 [GPT Duck]: Hello world');
+  });
+});
+
+describe('getRandomDuckMessage', () => {
+  it('should return a message from startup messages', () => {
+    const result = getRandomDuckMessage('startup');
+    expect(duckMessages.startup).toContain(result);
+  });
+
+  it('should return a message from error messages', () => {
+    const result = getRandomDuckMessage('error');
+    expect(duckMessages.error).toContain(result);
+  });
+
+  it('should return a message from success messages', () => {
+    const result = getRandomDuckMessage('success');
+    expect(duckMessages.success).toContain(result);
+  });
+});

package/tests/config.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { ConfigManager } from '../src/config/config';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../src/utils/logger');
+
+describe('ConfigManager - Custom Providers', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    // Save original environment
+    originalEnv = { ...process.env };
+    
+    // Clear custom provider environment variables
+    Object.keys(process.env).forEach(key => {
+      if (key.startsWith('CUSTOM_')) {
+        delete process.env[key];
+      }
+    });
+    
+    // Clear other provider keys that might interfere
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    delete process.env.GROQ_API_KEY;
+    delete process.env.TOGETHER_API_KEY;
+    delete process.env.PERPLEXITY_API_KEY;
+  });
+
+  afterEach(() => {
+    // Restore original environment
+    process.env = originalEnv;
+  });
+
+  describe('getCustomProvidersFromEnv', () => {
+    it('should parse single custom provider from environment', () => {
+      // Set up environment variables
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_MYAPI_API_KEY = 'test-key-123';
+      process.env.CUSTOM_MYAPI_BASE_URL = 'https://my-api.com/v1';
+      process.env.CUSTOM_MYAPI_MODELS = 'model1,model2,model3';
+      process.env.CUSTOM_MYAPI_DEFAULT_MODEL = 'model1';
+      process.env.CUSTOM_MYAPI_NICKNAME = 'My Custom Duck';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.myapi).toBeDefined();
+      expect(providers.myapi).toEqual({
+        api_key: 'test-key-123',
+        base_url: 'https://my-api.com/v1',
+        models: ['model1', 'model2', 'model3'],
+        default_model: 'model1',
+        nickname: 'My Custom Duck',
+      });
+    });
+
+    it('should parse multiple custom providers from environment', () => {
+      // Set up multiple providers
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_API1_API_KEY = 'key1';
+      process.env.CUSTOM_API1_BASE_URL = 'https://api1.com/v1';
+      process.env.CUSTOM_API1_NICKNAME = 'API 1 Duck';
+
+      process.env.CUSTOM_API2_API_KEY = 'key2';
+      process.env.CUSTOM_API2_BASE_URL = 'https://api2.com/v1';
+      process.env.CUSTOM_API2_MODELS = 'model-a,model-b';
+      process.env.CUSTOM_API2_DEFAULT_MODEL = 'model-a';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      // Check first provider
+      expect(providers.api1).toBeDefined();
+      expect(providers.api1.api_key).toBe('key1');
+      expect(providers.api1.base_url).toBe('https://api1.com/v1');
+      expect(providers.api1.nickname).toBe('API 1 Duck');
+      expect(providers.api1.models).toEqual(['custom-model']); // default
+      expect(providers.api1.default_model).toBe('custom-model'); // default
+
+      // Check second provider
+      expect(providers.api2).toBeDefined();
+      expect(providers.api2.api_key).toBe('key2');
+      expect(providers.api2.base_url).toBe('https://api2.com/v1');
+      expect(providers.api2.models).toEqual(['model-a', 'model-b']);
+      expect(providers.api2.default_model).toBe('model-a');
+      expect(providers.api2.nickname).toBe('API2 Duck'); // auto-generated
+    });
+
+    it('should convert provider names to lowercase', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_MYUPPERAPI_API_KEY = 'test-key';
+      process.env.CUSTOM_MYUPPERAPI_BASE_URL = 'https://upper.com/v1';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.myupperapi).toBeDefined();
+      expect(providers.MYUPPERAPI).toBeUndefined();
+      expect(providers.myupperapi.nickname).toBe('MYUPPERAPI Duck');
+    });
+
+    it('should require both API_KEY and BASE_URL', () => {
+      // Only API_KEY, missing BASE_URL
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_INCOMPLETE1_API_KEY = 'test-key';
+      
+      // Only BASE_URL, missing API_KEY
+      process.env.CUSTOM_INCOMPLETE2_BASE_URL = 'https://test.com/v1';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      // Neither should be created
+      expect(providers.incomplete1).toBeUndefined();
+      expect(providers.incomplete2).toBeUndefined();
+    });
+
+    it('should handle comma-separated models list', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_TESTMODELS_API_KEY = 'test-key';
+      process.env.CUSTOM_TESTMODELS_BASE_URL = 'https://test.com/v1';
+      process.env.CUSTOM_TESTMODELS_MODELS = ' model1 , model2 , model3 ';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.testmodels.models).toEqual(['model1', 'model2', 'model3']);
+    });
+
+    it('should use default values for optional fields', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_MINIMAL_API_KEY = 'test-key';
+      process.env.CUSTOM_MINIMAL_BASE_URL = 'https://minimal.com/v1';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.minimal).toBeDefined();
+      expect(providers.minimal).toEqual({
+        api_key: 'test-key',
+        base_url: 'https://minimal.com/v1',
+        models: ['custom-model'], // default
+        default_model: 'custom-model', // default
+        nickname: 'MINIMAL Duck', // auto-generated
+      });
+    });
+
+    it('should handle custom nicknames', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_NICKNAMED_API_KEY = 'test-key';
+      process.env.CUSTOM_NICKNAMED_BASE_URL = 'https://test.com/v1';
+      process.env.CUSTOM_NICKNAMED_NICKNAME = 'My Special Test Duck 🦆';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.nicknamed.nickname).toBe('My Special Test Duck 🦆');
+    });
+
+    it('should handle empty models string', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_EMPTYMODELS_API_KEY = 'test-key';
+      process.env.CUSTOM_EMPTYMODELS_BASE_URL = 'https://test.com/v1';
+      process.env.CUSTOM_EMPTYMODELS_MODELS = '';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      // Empty models should fall back to default
+      expect(providers.emptymodels.models).toEqual(['custom-model']);
+    });
+
+    it('should integrate with existing providers without conflicts', () => {
+      // Set up API keys for built-in providers
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.GEMINI_API_KEY = 'gemini-key';
+      
+      // Add custom provider
+      process.env.CUSTOM_INTEGRATION_API_KEY = 'custom-key';
+      process.env.CUSTOM_INTEGRATION_BASE_URL = 'https://custom.com/v1';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      // Should have built-in providers
+      expect(providers.openai).toBeDefined();
+      expect(providers.gemini).toBeDefined();
+      
+      // Should have custom provider
+      expect(providers.integration).toBeDefined();
+      
+      // Custom provider shouldn't override built-ins
+      expect(providers.openai.base_url).toBe('https://api.openai.com/v1');
+      expect(providers.integration.base_url).toBe('https://custom.com/v1');
+    });
+
+    it('should handle local LLM configuration via custom providers', () => {
+      // Test common local LLM setups
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_OLLAMA_API_KEY = 'not-needed';
+      process.env.CUSTOM_OLLAMA_BASE_URL = 'http://localhost:11434/v1';
+      process.env.CUSTOM_OLLAMA_MODELS = 'llama3.2,mistral,codellama';
+      process.env.CUSTOM_OLLAMA_NICKNAME = 'Local Ollama Duck';
+
+      process.env.CUSTOM_LMSTUDIO_API_KEY = 'not-needed';
+      process.env.CUSTOM_LMSTUDIO_BASE_URL = 'http://localhost:1234/v1';
+      process.env.CUSTOM_LMSTUDIO_NICKNAME = 'LM Studio Duck';
+
+      const configManager = new ConfigManager();
+      const providers = configManager.getAllProviders();
+
+      expect(providers.ollama).toBeDefined();
+      expect(providers.ollama.api_key).toBe('not-needed');
+      expect(providers.ollama.base_url).toBe('http://localhost:11434/v1');
+      expect(providers.ollama.models).toEqual(['llama3.2', 'mistral', 'codellama']);
+
+      expect(providers.lmstudio).toBeDefined();
+      expect(providers.lmstudio.api_key).toBe('not-needed');
+      expect(providers.lmstudio.base_url).toBe('http://localhost:1234/v1');
+    });
+  });
+
+  describe('Integration with ProviderManager', () => {
+    it('should allow custom providers to be used by ProviderManager', () => {
+      process.env.OPENAI_API_KEY = 'dummy-key'; // Ensure getDefaultProviders is called
+      process.env.CUSTOM_TESTPROVIDER_API_KEY = 'test-key';
+      process.env.CUSTOM_TESTPROVIDER_BASE_URL = 'https://test.com/v1';
+      process.env.CUSTOM_TESTPROVIDER_NICKNAME = 'Test Provider Duck';
+
+      const configManager = new ConfigManager();
+      const config = configManager.getConfig();
+
+      expect(config.providers.testprovider).toBeDefined();
+      expect(config.providers.testprovider.nickname).toBe('Test Provider Duck');
+      expect(config.providers.testprovider.api_key).toBe('test-key');
+      expect(config.providers.testprovider.base_url).toBe('https://test.com/v1');
+    });
+  });
+});