mcp-rubber-duck 1.5.1 → 1.6.0

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/get-usage-stats.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { getUsageStatsTool } from '../../src/tools/get-usage-stats.js';
+import { UsageService } from '../../src/services/usage.js';
+import { PricingService } from '../../src/services/pricing.js';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../../src/utils/logger');
+
+describe('getUsageStatsTool', () => {
+  let tempDir: string;
+  let pricingService: PricingService;
+  let usageService: UsageService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'usage-tool-test-'));
+
+    pricingService = new PricingService({
+      testprovider: {
+        'test-model': { inputPricePerMillion: 5, outputPricePerMillion: 15 },
+      },
+    });
+
+    usageService = new UsageService(pricingService, {
+      dataDir: tempDir,
+      debounceMs: 0,
+    });
+  });
+
+  afterEach(() => {
+    usageService.shutdown();
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  describe('input validation', () => {
+    it('should throw error for invalid period', () => {
+      expect(() => {
+        getUsageStatsTool(usageService, { period: 'invalid' });
+      }).toThrow('Invalid period "invalid"');
+    });
+
+    it('should accept valid periods', () => {
+      expect(() => getUsageStatsTool(usageService, { period: 'today' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: '7d' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: '30d' })).not.toThrow();
+      expect(() => getUsageStatsTool(usageService, { period: 'all' })).not.toThrow();
+    });
+
+    it('should default to today when period not specified', () => {
+      const result = getUsageStatsTool(usageService, {});
+
+      expect(result.content[0].text).toContain('Today');
+    });
+  });
+
+  describe('output format', () => {
+    it('should return MCP-compliant response', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+
+      expect(result.content).toBeDefined();
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0].type).toBe('text');
+      expect(typeof result.content[0].text).toBe('string');
+    });
+
+    it('should include period label in output', () => {
+      const result = getUsageStatsTool(usageService, { period: '7d' });
+      expect(result.content[0].text).toContain('Last 7 Days');
+    });
+
+    it('should include date range', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      // Should contain dates in YYYY-MM-DD format
+      expect(result.content[0].text).toMatch(/\d{4}-\d{2}-\d{2}/);
+    });
+
+    it('should include totals section', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('TOTALS');
+      expect(text).toContain('Requests:');
+      expect(text).toContain('Prompt Tokens:');
+      expect(text).toContain('Completion Tokens:');
+    });
+
+    it('should include per-provider breakdown', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+      usageService.recordUsage('anthropic', 'claude-3', 200, 100, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('BY PROVIDER');
+      expect(text).toContain('openai');
+      expect(text).toContain('anthropic');
+      expect(text).toContain('gpt-4o');
+      expect(text).toContain('claude-3');
+    });
+
+    it('should show cost when pricing available', () => {
+      usageService.recordUsage('testprovider', 'test-model', 1000, 500, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Estimated Cost:');
+      expect(text).toContain('$');
+      expect(text).toContain('USD');
+    });
+
+    it('should show hint when cost unavailable', () => {
+      usageService.recordUsage('unknown-provider', 'unknown-model', 1000, 500, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Cost estimates not available');
+    });
+
+    it('should handle empty usage gracefully', () => {
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('No usage data');
+    });
+
+    it('should show cache hits when present', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, true, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Cache Hits:');
+    });
+
+    it('should show errors when present', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 0, 0, false, true);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      expect(text).toContain('Errors:');
+    });
+  });
+
+  describe('period filtering', () => {
+    it('should filter data by period', () => {
+      // Record some usage for today
+      usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+      // Today should have data
+      const todayResult = getUsageStatsTool(usageService, { period: 'today' });
+      expect(todayResult.content[0].text).toContain('Requests: 1');
+
+      // All should also have data
+      const allResult = getUsageStatsTool(usageService, { period: 'all' });
+      expect(allResult.content[0].text).toContain('Requests: 1');
+    });
+  });
+
+  describe('formatting', () => {
+    it('should format large numbers with commas', () => {
+      usageService.recordUsage('openai', 'gpt-4o', 1000000, 500000, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should have formatted numbers
+      expect(text).toContain('1,000,000');
+    });
+
+    it('should format cost with appropriate precision', () => {
+      // Small cost
+      usageService.recordUsage('testprovider', 'test-model', 100, 50, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show cost with decimal places
+      expect(text).toMatch(/\$\d+\.\d+/);
+    });
+
+    it('should format very small costs with 6 decimal places', () => {
+      // Very small cost (10 tokens at $5/M = $0.00005)
+      usageService.recordUsage('testprovider', 'test-model', 10, 0, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show 6 decimal places for very small amounts
+      expect(text).toMatch(/\$0\.0000\d+/);
+    });
+
+    it('should format large costs with 2 decimal places', () => {
+      // Large cost (10M tokens at $5/M = $50)
+      usageService.recordUsage('testprovider', 'test-model', 10000000, 0, false, false);
+
+      const result = getUsageStatsTool(usageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show 2 decimal places for larger amounts
+      expect(text).toMatch(/\$\d+\.\d{2}\s*USD/);
+    });
+
+    it('should show $0 cost for free models', () => {
+      // Create service with free pricing
+      const freePricingService = new PricingService({
+        freeprovider: {
+          'free-model': { inputPricePerMillion: 0, outputPricePerMillion: 0 },
+        },
+      });
+      const freeUsageService = new UsageService(freePricingService, {
+        dataDir: tempDir,
+        debounceMs: 0,
+      });
+
+      freeUsageService.recordUsage('freeprovider', 'free-model', 1000000, 500000, false, false);
+
+      const result = getUsageStatsTool(freeUsageService, { period: 'today' });
+      const text = result.content[0].text;
+
+      // Should show $0 cost
+      expect(text).toContain('$0');
+      expect(text).toContain('Estimated Cost:');
+
+      freeUsageService.shutdown();
+    });
+  });
+});