mcp-rubber-duck 1.5.1 → 1.5.2

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

@@ -0,0 +1,219 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { duckCouncilTool } from '../../src/tools/duck-council.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+
+describe('duckCouncilTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+
+  const mockResponses = [
+    {
+      provider: 'openai',
+      nickname: 'OpenAI Duck',
+      content: 'I think TypeScript is great for large projects.',
+      model: 'gpt-4',
+      latency: 150,
+      usage: { prompt_tokens: 10, completion_tokens: 25, total_tokens: 35 },
+    },
+    {
+      provider: 'groq',
+      nickname: 'Groq Duck',
+      content: 'TypeScript adds type safety which prevents many bugs.',
+      model: 'llama-3.1-70b',
+      latency: 80,
+      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+    },
+  ];
+
+  beforeEach(() => {
+    mockProviderManager = {
+      getProviderNames: jest.fn().mockReturnValue(['openai', 'groq']),
+      duckCouncil: jest.fn().mockResolvedValue(mockResponses),
+    } as unknown as jest.Mocked<ProviderManager>;
+  });
+
+  it('should throw error when prompt is missing', async () => {
+    await expect(duckCouncilTool(mockProviderManager, {})).rejects.toThrow(
+      'Prompt is required for the duck council'
+    );
+  });
+
+  it('should throw error when no providers available', async () => {
+    mockProviderManager.getProviderNames.mockReturnValue([]);
+
+    await expect(
+      duckCouncilTool(mockProviderManager, { prompt: 'Test' })
+    ).rejects.toThrow('No ducks available for the council!');
+  });
+
+  it('should convene duck council with prompt', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'What is TypeScript?',
+    });
+
+    expect(mockProviderManager.duckCouncil).toHaveBeenCalledWith('What is TypeScript?', {
+      model: undefined,
+    });
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+  });
+
+  it('should display council topic', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'What is TypeScript?',
+    });
+
+    expect(result.content[0].text).toContain('Duck Council Topic');
+    expect(result.content[0].text).toContain('What is TypeScript?');
+  });
+
+  it('should display number of ducks in attendance', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('2 ducks in attendance');
+  });
+
+  it('should display each duck response with number', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('Duck #1: OpenAI Duck');
+    expect(result.content[0].text).toContain('Duck #2: Groq Duck');
+    expect(result.content[0].text).toContain('TypeScript is great');
+    expect(result.content[0].text).toContain('type safety');
+  });
+
+  it('should display model and latency metadata', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('gpt-4');
+    expect(result.content[0].text).toContain('150ms');
+    expect(result.content[0].text).toContain('35 tokens');
+  });
+
+  it('should handle error responses from ducks', async () => {
+    mockProviderManager.duckCouncil.mockResolvedValue([
+      mockResponses[0],
+      {
+        provider: 'groq',
+        nickname: 'Groq Duck',
+        content: 'Error: API key invalid',
+        model: '',
+        latency: 0,
+      },
+    ]);
+
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('Duck had to leave early');
+    expect(result.content[0].text).toContain('API key invalid');
+  });
+
+  it('should show council summary with success count', async () => {
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('Council Summary');
+    expect(result.content[0].text).toContain('2/2 ducks provided their wisdom');
+  });
+
+  it('should show partial council message when some fail', async () => {
+    mockProviderManager.duckCouncil.mockResolvedValue([
+      mockResponses[0],
+      {
+        provider: 'groq',
+        nickname: 'Groq Duck',
+        content: 'Error: Timeout',
+        model: '',
+        latency: 0,
+      },
+    ]);
+
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('1/2 ducks provided their wisdom');
+    expect(result.content[0].text).toContain('Partial council');
+  });
+
+  it('should pass model option', async () => {
+    await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+      model: 'gpt-3.5-turbo',
+    });
+
+    expect(mockProviderManager.duckCouncil).toHaveBeenCalledWith('Test', {
+      model: 'gpt-3.5-turbo',
+    });
+  });
+
+  it('should not show latency when zero', async () => {
+    mockProviderManager.duckCouncil.mockResolvedValue([
+      {
+        ...mockResponses[0],
+        latency: 0,
+      },
+    ]);
+
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    // Should not show "0ms" in output
+    expect(result.content[0].text).not.toContain('0ms');
+  });
+
+  it('should not show tokens when usage missing', async () => {
+    mockProviderManager.duckCouncil.mockResolvedValue([
+      {
+        ...mockResponses[0],
+        usage: undefined,
+      },
+    ]);
+
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).not.toContain('tokens');
+  });
+
+  it('should show error message when all ducks fail', async () => {
+    mockProviderManager.duckCouncil.mockResolvedValue([
+      {
+        provider: 'openai',
+        nickname: 'OpenAI Duck',
+        content: 'Error: Connection timeout',
+        model: '',
+        latency: 0,
+      },
+      {
+        provider: 'groq',
+        nickname: 'Groq Duck',
+        content: 'Error: API error',
+        model: '',
+        latency: 0,
+      },
+    ]);
+
+    const result = await duckCouncilTool(mockProviderManager, {
+      prompt: 'Test',
+    });
+
+    expect(result.content[0].text).toContain('0/2 ducks provided their wisdom');
+    // Should not show partial council message
+    expect(result.content[0].text).not.toContain('Partial council');
+  });
+});

package/tests/tools/get-pending-approvals.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { getPendingApprovalsTool } from '../../src/tools/get-pending-approvals.js';
+import { ApprovalService } from '../../src/services/approval.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/services/approval.js');
+
+describe('getPendingApprovalsTool', () => {
+  let mockApprovalService: jest.Mocked<ApprovalService>;
+
+  const now = Date.now();
+  const mockApprovals = [
+    {
+      id: 'approval-1',
+      duckName: 'OpenAI Duck',
+      mcpServer: 'filesystem',
+      toolName: 'read_file',
+      arguments: { path: '/tmp/test.txt' },
+      status: 'pending' as const,
+      timestamp: now - 30000, // 30 seconds ago
+      expiresAt: now + 30000, // expires in 30 seconds
+    },
+    {
+      id: 'approval-2',
+      duckName: 'Groq Duck',
+      mcpServer: 'database',
+      toolName: 'query',
+      arguments: { sql: 'SELECT * FROM users' },
+      status: 'pending' as const,
+      timestamp: now - 10000, // 10 seconds ago
+      expiresAt: now + 50000, // expires in 50 seconds
+    },
+  ];
+
+  beforeEach(() => {
+    mockApprovalService = {
+      getPendingApprovals: jest.fn(),
+    } as unknown as jest.Mocked<ApprovalService>;
+  });
+
+  describe('no pending approvals', () => {
+    it('should return success message when no approvals exist', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('No pending MCP tool approvals');
+      expect(result.isError).toBeUndefined();
+    });
+  });
+
+  describe('with pending approvals', () => {
+    beforeEach(() => {
+      mockApprovalService.getPendingApprovals.mockReturnValue(mockApprovals);
+    });
+
+    it('should list all pending approvals', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('2 pending MCP approvals');
+      expect(result.content[0].text).toContain('OpenAI Duck');
+      expect(result.content[0].text).toContain('Groq Duck');
+      expect(result.content[0].text).toContain('filesystem:read_file');
+      expect(result.content[0].text).toContain('database:query');
+    });
+
+    it('should display approval IDs', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('approval-1');
+      expect(result.content[0].text).toContain('approval-2');
+    });
+
+    it('should display arguments for small payloads', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('/tmp/test.txt');
+      expect(result.content[0].text).toContain('SELECT * FROM users');
+    });
+
+    it('should show parameter count for large arguments', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([
+        {
+          ...mockApprovals[0],
+          arguments: {
+            param1: 'a'.repeat(50),
+            param2: 'b'.repeat(50),
+            param3: 'c'.repeat(50),
+          },
+        },
+      ]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('3 parameters');
+    });
+
+    it('should include usage hint', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('approve_mcp_request');
+    });
+
+    it('should handle singular approval text', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([mockApprovals[0]]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('1 pending MCP approval:');
+      expect(result.content[0].text).not.toContain('approvals:');
+    });
+  });
+
+  describe('filtering by duck', () => {
+    beforeEach(() => {
+      mockApprovalService.getPendingApprovals.mockReturnValue(mockApprovals);
+    });
+
+    it('should filter approvals by duck name', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {
+        duck: 'OpenAI Duck',
+      });
+
+      expect(result.content[0].text).toContain('OpenAI Duck');
+      expect(result.content[0].text).not.toContain('Groq Duck');
+      expect(result.content[0].text).toContain('1 pending MCP approval');
+    });
+
+    it('should return no approvals when duck filter has no matches', () => {
+      const result = getPendingApprovalsTool(mockApprovalService, {
+        duck: 'NonexistentDuck',
+      });
+
+      expect(result.content[0].text).toContain('No pending MCP tool approvals');
+    });
+  });
+
+  describe('time formatting', () => {
+    it('should show time since request', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([mockApprovals[0]]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      // Approval was 30 seconds ago
+      expect(result.content[0].text).toMatch(/Requested: \d+s ago/);
+    });
+
+    it('should show expiration time', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([mockApprovals[0]]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toMatch(/Expires: \d+s/);
+    });
+
+    it('should show expired status for expired approvals', () => {
+      mockApprovalService.getPendingApprovals.mockReturnValue([
+        {
+          ...mockApprovals[0],
+          expiresAt: now - 1000, // Already expired
+        },
+      ]);
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.content[0].text).toContain('Expires: expired');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle exceptions gracefully', () => {
+      mockApprovalService.getPendingApprovals.mockImplementation(() => {
+        throw new Error('Service unavailable');
+      });
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Failed to get pending approvals');
+      expect(result.content[0].text).toContain('Service unavailable');
+    });
+
+    it('should handle non-Error exceptions', () => {
+      mockApprovalService.getPendingApprovals.mockImplementation(() => {
+        throw 'Unknown error';
+      });
+
+      const result = getPendingApprovalsTool(mockApprovalService, {});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Unknown error');
+    });
+  });
+});

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

@@ -0,0 +1,144 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { listDucksTool } from '../../src/tools/list-ducks.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+import { HealthMonitor } from '../../src/services/health.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+jest.mock('../../src/services/health.js');
+
+describe('listDucksTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+  let mockHealthMonitor: jest.Mocked<HealthMonitor>;
+
+  const mockProviders = [
+    {
+      name: 'openai',
+      info: {
+        nickname: 'OpenAI Duck',
+        model: 'gpt-4',
+        baseURL: 'https://api.openai.com/v1',
+        hasApiKey: true,
+      },
+    },
+    {
+      name: 'groq',
+      info: {
+        nickname: 'Groq Duck',
+        model: 'llama-3.1-70b',
+        baseURL: 'https://api.groq.com/openai/v1',
+        hasApiKey: true,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    mockProviderManager = {
+      getAllProviders: jest.fn().mockReturnValue(mockProviders),
+    } as unknown as jest.Mocked<ProviderManager>;
+
+    mockHealthMonitor = {
+      performHealthChecks: jest.fn(),
+    } as unknown as jest.Mocked<HealthMonitor>;
+  });
+
+  it('should list all ducks without health check', async () => {
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(mockProviderManager.getAllProviders).toHaveBeenCalled();
+    expect(mockHealthMonitor.performHealthChecks).not.toHaveBeenCalled();
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('Found 2 duck(s)');
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Groq Duck');
+  });
+
+  it('should list ducks with health check when requested', async () => {
+    mockHealthMonitor.performHealthChecks.mockResolvedValue([
+      {
+        provider: 'openai',
+        healthy: true,
+        latency: 150,
+        lastCheck: new Date(),
+      },
+      {
+        provider: 'groq',
+        healthy: false,
+        lastCheck: new Date(),
+        error: 'Connection failed',
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: true,
+    });
+
+    expect(mockHealthMonitor.performHealthChecks).toHaveBeenCalled();
+    expect(result.content[0].text).toContain('Healthy');
+    expect(result.content[0].text).toContain('Unhealthy');
+    expect(result.content[0].text).toContain('150ms');
+    expect(result.content[0].text).toContain('Connection failed');
+  });
+
+  it('should show unknown status emoji for unchecked providers', async () => {
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: false,
+    });
+
+    // Without health check, status should be unknown (❓)
+    expect(result.content[0].text).toContain('❓');
+  });
+
+  it('should show healthy count in summary', async () => {
+    mockHealthMonitor.performHealthChecks.mockResolvedValue([
+      {
+        provider: 'openai',
+        healthy: true,
+        latency: 150,
+        lastCheck: new Date(),
+      },
+      {
+        provider: 'groq',
+        healthy: true,
+        latency: 80,
+        lastCheck: new Date(),
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: true,
+    });
+
+    expect(result.content[0].text).toContain('2/2 ducks are healthy');
+  });
+
+  it('should handle empty provider list', async () => {
+    mockProviderManager.getAllProviders.mockReturnValue([]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(result.content[0].text).toContain('Found 0 duck(s)');
+    expect(result.content[0].text).toContain('0/0 ducks are healthy');
+  });
+
+  it('should display provider without API key correctly', async () => {
+    mockProviderManager.getAllProviders.mockReturnValue([
+      {
+        name: 'ollama',
+        info: {
+          nickname: 'Ollama Duck',
+          model: 'llama3',
+          baseURL: 'http://localhost:11434/v1',
+          hasApiKey: false,
+        },
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(result.content[0].text).toContain('Not required');
+  });
+});