mcp-rubber-duck 1.9.4 → 1.10.0

package/tests/tools/duck-debate-ui.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock OpenAI BEFORE importing
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+  const MockOpenAI = jest.fn().mockImplementation(() => ({
+    chat: { completions: { create: mockCreate } },
+  }));
+  return { __esModule: true, default: MockOpenAI };
+});
+
+jest.mock('../../src/config/config');
+jest.mock('../../src/utils/logger');
+
+import { duckDebateTool } from '../../src/tools/duck-debate';
+import { ProviderManager } from '../../src/providers/manager';
+import { ConfigManager } from '../../src/config/config';
+
+describe('duckDebateTool structured JSON', () => {
+  let mockProviderManager: ProviderManager;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    const mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          openai: {
+            api_key: 'key1',
+            base_url: 'https://api.openai.com/v1',
+            default_model: 'gpt-4',
+            nickname: 'GPT-4',
+            models: ['gpt-4'],
+          },
+          gemini: {
+            api_key: 'key2',
+            base_url: 'https://api.gemini.com/v1',
+            default_model: 'gemini-pro',
+            nickname: 'Gemini',
+            models: ['gemini-pro'],
+          },
+        },
+        default_provider: 'openai',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as unknown as jest.Mocked<ConfigManager>;
+
+    mockProviderManager = new ProviderManager(mockConfigManager);
+
+    const provider1 = mockProviderManager.getProvider('openai');
+    const provider2 = mockProviderManager.getProvider('gemini');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should return two content items: text and JSON', async () => {
+    // 1 round, 2 participants + synthesis = 3 calls
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Test topic',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+  });
+
+  it('should include debate structure in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Microservices vs monolith',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      topic: string;
+      format: string;
+      totalRounds: number;
+      participants: { provider: string; nickname: string; position: string }[];
+      rounds: { round: number; provider: string; nickname: string; position: string; content: string }[][];
+      synthesis: string;
+      synthesizer: string;
+    };
+
+    expect(data.topic).toBe('Microservices vs monolith');
+    expect(data.format).toBe('oxford');
+    expect(data.totalRounds).toBe(1);
+    expect(data.participants).toHaveLength(2);
+    expect(data.participants[0].position).toBe('pro');
+    expect(data.participants[1].position).toBe('con');
+    expect(data.rounds).toHaveLength(1);
+    expect(data.rounds[0]).toHaveLength(2);
+    expect(data.rounds[0][0].content).toBe('Pro argument');
+    expect(data.rounds[0][1].content).toBe('Con argument');
+    expect(data.synthesis).toBe('Final synthesis');
+    expect(data.synthesizer).toBe('openai');
+  });
+
+  it('should assign adversarial positions correctly in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Defense' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Attack' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Is AI dangerous?',
+      format: 'adversarial',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      format: string;
+      participants: { position: string }[];
+    };
+
+    expect(data.format).toBe('adversarial');
+    // First participant defends (pro), rest challenge (con)
+    expect(data.participants[0].position).toBe('pro');
+    expect(data.participants[1].position).toBe('con');
+  });
+
+  it('should preserve text content alongside JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Test topic',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    expect(result.content[0].text).toContain('Oxford Debate');
+    expect(result.content[0].text).toContain('Test topic');
+    expect(result.content[0].text).toContain('Synthesis');
+    expect(result.content[0].text).toContain('ROUND 1');
+  });
+
+  it('should assign socratic positions correctly in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Question 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Response 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'What is truth?',
+      format: 'socratic',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      format: string;
+      participants: { position: string }[];
+    };
+
+    expect(data.format).toBe('socratic');
+    expect(data.participants[0].position).toBe('neutral');
+    expect(data.participants[1].position).toBe('neutral');
+  });
+});

package/tests/tools/duck-vote-ui.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock OpenAI BEFORE importing
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+  const MockOpenAI = jest.fn().mockImplementation(() => ({
+    chat: { completions: { create: mockCreate } },
+  }));
+  return { __esModule: true, default: MockOpenAI };
+});
+
+jest.mock('../../src/config/config');
+jest.mock('../../src/utils/logger');
+
+import { duckVoteTool } from '../../src/tools/duck-vote';
+import { ProviderManager } from '../../src/providers/manager';
+import { ConfigManager } from '../../src/config/config';
+
+describe('duckVoteTool structured JSON', () => {
+  let mockProviderManager: ProviderManager;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    const mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          openai: {
+            api_key: 'key1',
+            base_url: 'https://api.openai.com/v1',
+            default_model: 'gpt-4',
+            nickname: 'GPT-4',
+            models: ['gpt-4'],
+          },
+          gemini: {
+            api_key: 'key2',
+            base_url: 'https://api.gemini.com/v1',
+            default_model: 'gemini-pro',
+            nickname: 'Gemini',
+            models: ['gemini-pro'],
+          },
+        },
+        default_provider: 'openai',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as unknown as jest.Mocked<ConfigManager>;
+
+    mockProviderManager = new ProviderManager(mockConfigManager);
+
+    const provider1 = mockProviderManager.getProvider('openai');
+    const provider2 = mockProviderManager.getProvider('gemini');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should return two content items: text and JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 85, "reasoning": "Solid"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 75, "reasoning": "Good"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Best?',
+      options: ['A', 'B'],
+    });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+  });
+
+  it('should include vote data in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 85, "reasoning": "Best"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 75, "reasoning": "Good"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['A', 'B'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      question: string;
+      options: string[];
+      winner: string | null;
+      isTie: boolean;
+      tally: Record<string, number>;
+      confidenceByOption: Record<string, number>;
+      votes: { voter: string; nickname: string; choice: string; confidence: number; reasoning: string }[];
+      totalVoters: number;
+      validVotes: number;
+      consensusLevel: string;
+    };
+
+    expect(data.question).toBe('Best approach?');
+    expect(data.options).toEqual(['A', 'B']);
+    expect(data.winner).toBe('A');
+    expect(data.consensusLevel).toBe('unanimous');
+    expect(data.tally['A']).toBe(2);
+    expect(data.tally['B']).toBe(0);
+    expect(data.votes).toHaveLength(2);
+    expect(data.votes[0].confidence).toBe(85);
+  });
+
+  it('should reflect tie in JSON data', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 60}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "B", "confidence": 90}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Which?',
+      options: ['A', 'B'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      isTie: boolean;
+      winner: string | null;
+      consensusLevel: string;
+    };
+
+    expect(data.isTie).toBe(true);
+    expect(data.consensusLevel).toBe('split');
+    // Tie-break by confidence: B has 90 vs A has 60
+    expect(data.winner).toBe('B');
+  });
+
+  it('should not include rawResponse in JSON votes', async () => {
+    mockCreate.mockResolvedValueOnce({
+      choices: [{ message: { content: '{"choice": "A", "confidence": 80}' }, finish_reason: 'stop' }],
+      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+      model: 'gpt-4',
+    });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Test?',
+      options: ['A', 'B'],
+      voters: ['openai'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      votes: Record<string, unknown>[];
+    };
+
+    // rawResponse should not be in the structured output
+    expect(data.votes[0]).not.toHaveProperty('rawResponse');
+  });
+});

package/tests/tools/get-usage-stats.test.ts

@@ -62,9 +62,11 @@ describe('getUsageStatsTool', () => {
       const result = getUsageStatsTool(usageService, { period: 'today' });
 
       expect(result.content).toBeDefined();
-      expect(result.content).toHaveLength(1);
+      expect(result.content).toHaveLength(2);
       expect(result.content[0].type).toBe('text');
       expect(typeof result.content[0].text).toBe('string');
+      expect(result.content[1].type).toBe('text');
+      expect(() => JSON.parse(result.content[1].text)).not.toThrow();
     });
 
     it('should include period label in output', () => {

package/tests/tools/usage-stats-ui.test.ts

@@ -0,0 +1,130 @@
+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';
+
+jest.mock('../../src/utils/logger');
+
+describe('getUsageStatsTool structured JSON', () => {
+  let tempDir: string;
+  let pricingService: PricingService;
+  let usageService: UsageService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'usage-ui-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 });
+    }
+  });
+
+  it('should return two content items: text and JSON', () => {
+    const result = getUsageStatsTool(usageService, { period: 'today' });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+    expect(() => JSON.parse(result.content[1].text)).not.toThrow();
+  });
+
+  it('should include period and date range in JSON', () => {
+    const result = getUsageStatsTool(usageService, { period: '7d' });
+    const data = JSON.parse(result.content[1].text) as {
+      period: string;
+      startDate: string;
+      endDate: string;
+    };
+
+    expect(data.period).toBe('7d');
+    expect(data.startDate).toMatch(/\d{4}-\d{2}-\d{2}/);
+    expect(data.endDate).toMatch(/\d{4}-\d{2}-\d{2}/);
+  });
+
+  it('should include totals in JSON', () => {
+    usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+    const result = getUsageStatsTool(usageService, { period: 'today' });
+    const data = JSON.parse(result.content[1].text) as {
+      totals: {
+        requests: number;
+        promptTokens: number;
+        completionTokens: number;
+        cacheHits: number;
+        errors: number;
+      };
+    };
+
+    expect(data.totals.requests).toBe(1);
+    expect(data.totals.promptTokens).toBe(100);
+    expect(data.totals.completionTokens).toBe(50);
+    expect(data.totals.cacheHits).toBe(0);
+    expect(data.totals.errors).toBe(0);
+  });
+
+  it('should include per-provider usage 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 data = JSON.parse(result.content[1].text) as {
+      usage: Record<string, Record<string, { requests: number }>>;
+    };
+
+    expect(data.usage).toHaveProperty('openai');
+    expect(data.usage).toHaveProperty('anthropic');
+    expect(data.usage['openai']['gpt-4o'].requests).toBe(1);
+    expect(data.usage['anthropic']['claude-3'].requests).toBe(1);
+  });
+
+  it('should include cost data when pricing is configured', () => {
+    usageService.recordUsage('testprovider', 'test-model', 1000, 500, false, false);
+
+    const result = getUsageStatsTool(usageService, { period: 'today' });
+    const data = JSON.parse(result.content[1].text) as {
+      totals: { estimatedCostUSD?: number };
+      costByProvider?: Record<string, number>;
+    };
+
+    expect(data.totals.estimatedCostUSD).toBeDefined();
+    expect(typeof data.totals.estimatedCostUSD).toBe('number');
+    expect(data.costByProvider).toBeDefined();
+    expect(data.costByProvider!['testprovider']).toBeDefined();
+  });
+
+  it('should handle empty usage data in JSON', () => {
+    // No usage recorded — should still return valid JSON with empty usage
+    const result = getUsageStatsTool(usageService, { period: 'today' });
+    const data = JSON.parse(result.content[1].text) as {
+      totals: { requests: number };
+      usage: Record<string, unknown>;
+    };
+
+    expect(data.totals.requests).toBe(0);
+    expect(Object.keys(data.usage)).toHaveLength(0);
+  });
+
+  it('should preserve text content identical to before', () => {
+    usageService.recordUsage('openai', 'gpt-4o', 100, 50, false, false);
+
+    const result = getUsageStatsTool(usageService, { period: 'today' });
+
+    expect(result.content[0].text).toContain('Usage Statistics');
+    expect(result.content[0].text).toContain('TOTALS');
+    expect(result.content[0].text).toContain('openai');
+  });
+});

package/tests/ui-build.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from '@jest/globals';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const UI_DIR = join(currentDir, '..', 'dist', 'ui');
+
+const UI_ENTRIES = [
+  'compare-ducks',
+  'duck-vote',
+  'duck-debate',
+  'usage-stats',
+];
+
+describe('UI build output', () => {
+  for (const entry of UI_ENTRIES) {
+    describe(entry, () => {
+      const htmlPath = join(UI_DIR, entry, 'mcp-app.html');
+
+      it(`should have built ${entry}/mcp-app.html`, () => {
+        expect(existsSync(htmlPath)).toBe(true);
+      });
+
+      it('should be a valid single-file HTML bundle', () => {
+        if (!existsSync(htmlPath)) return;
+
+        const html = readFileSync(htmlPath, 'utf-8');
+
+        // Must be valid HTML
+        expect(html).toContain('<!DOCTYPE html>');
+        expect(html).toContain('<html');
+        expect(html).toContain('</html>');
+
+        // Must contain inlined script (no external src references for JS)
+        expect(html).toContain('<script');
+
+        // Must NOT have external script references (single-file)
+        expect(html).not.toMatch(/<script[^>]+src="[^"]+\.js"/);
+      });
+
+      it('should contain ext-apps App class usage', () => {
+        if (!existsSync(htmlPath)) return;
+
+        const html = readFileSync(htmlPath, 'utf-8');
+
+        // The bundled JS should contain App class instantiation
+        // (from @modelcontextprotocol/ext-apps)
+        expect(html).toContain('ontoolresult');
+      });
+    });
+  }
+});

package/tsconfig.json

@@ -22,5 +22,5 @@
     "isolatedModules": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
+  "exclude": ["node_modules", "dist", "tests", "src/ui"]
 }

package/vite.config.ts

@@ -0,0 +1,19 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import { viteSingleFile } from 'vite-plugin-singlefile';
+
+// Build a single entry at a time. The build:ui script iterates over entries.
+// Entry name is passed via VITE_UI_ENTRY env var.
+const entry = process.env.VITE_UI_ENTRY || 'compare-ducks';
+
+export default defineConfig({
+  root: resolve(__dirname, `src/ui/${entry}`),
+  plugins: [viteSingleFile()],
+  build: {
+    rollupOptions: {
+      input: resolve(__dirname, `src/ui/${entry}/mcp-app.html`),
+    },
+    outDir: resolve(__dirname, `dist/ui/${entry}`),
+    emptyOutDir: true,
+  },
+});