npm - mcp-rubber-duck - Versions diffs - 1.9.5 → 1.11.0 - Mend

mcp-rubber-duck 1.9.5 → 1.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (92) hide show

package/.eslintrc.json +3 -1
package/CHANGELOG.md +19 -0
package/README.md +62 -10
package/assets/ext-apps-compare.png +0 -0
package/assets/ext-apps-debate.png +0 -0
package/assets/ext-apps-usage-stats.png +0 -0
package/assets/ext-apps-vote.png +0 -0
package/audit-ci.json +2 -1
package/dist/providers/enhanced-manager.d.ts +7 -0
package/dist/providers/enhanced-manager.d.ts.map +1 -1
package/dist/providers/enhanced-manager.js +36 -0
package/dist/providers/enhanced-manager.js.map +1 -1
package/dist/providers/manager.d.ts +1 -0
package/dist/providers/manager.d.ts.map +1 -1
package/dist/providers/manager.js +33 -0
package/dist/providers/manager.js.map +1 -1
package/dist/server.d.ts +2 -0
package/dist/server.d.ts.map +1 -1
package/dist/server.js +154 -36
package/dist/server.js.map +1 -1
package/dist/services/progress.d.ts +27 -0
package/dist/services/progress.d.ts.map +1 -0
package/dist/services/progress.js +50 -0
package/dist/services/progress.js.map +1 -0
package/dist/services/task-manager.d.ts +56 -0
package/dist/services/task-manager.d.ts.map +1 -0
package/dist/services/task-manager.js +134 -0
package/dist/services/task-manager.js.map +1 -0
package/dist/tools/compare-ducks.d.ts +2 -1
package/dist/tools/compare-ducks.d.ts.map +1 -1
package/dist/tools/compare-ducks.js +26 -3
package/dist/tools/compare-ducks.js.map +1 -1
package/dist/tools/duck-council.d.ts +2 -1
package/dist/tools/duck-council.d.ts.map +1 -1
package/dist/tools/duck-council.js +7 -3
package/dist/tools/duck-council.js.map +1 -1
package/dist/tools/duck-debate.d.ts +2 -1
package/dist/tools/duck-debate.d.ts.map +1 -1
package/dist/tools/duck-debate.js +43 -1
package/dist/tools/duck-debate.js.map +1 -1
package/dist/tools/duck-iterate.d.ts +2 -1
package/dist/tools/duck-iterate.d.ts.map +1 -1
package/dist/tools/duck-iterate.js +13 -1
package/dist/tools/duck-iterate.js.map +1 -1
package/dist/tools/duck-vote.d.ts +2 -1
package/dist/tools/duck-vote.d.ts.map +1 -1
package/dist/tools/duck-vote.js +30 -3
package/dist/tools/duck-vote.js.map +1 -1
package/dist/tools/get-usage-stats.d.ts.map +1 -1
package/dist/tools/get-usage-stats.js +13 -0
package/dist/tools/get-usage-stats.js.map +1 -1
package/dist/ui/compare-ducks/mcp-app.html +187 -0
package/dist/ui/duck-debate/mcp-app.html +182 -0
package/dist/ui/duck-vote/mcp-app.html +168 -0
package/dist/ui/usage-stats/mcp-app.html +192 -0
package/jest.config.js +1 -0
package/package.json +7 -3
package/src/providers/enhanced-manager.ts +49 -0
package/src/providers/manager.ts +45 -0
package/src/server.ts +187 -34
package/src/services/progress.ts +59 -0
package/src/services/task-manager.ts +162 -0
package/src/tools/compare-ducks.ts +34 -3
package/src/tools/duck-council.ts +15 -4
package/src/tools/duck-debate.ts +58 -1
package/src/tools/duck-iterate.ts +20 -1
package/src/tools/duck-vote.ts +38 -3
package/src/tools/get-usage-stats.ts +14 -0
package/src/ui/compare-ducks/app.ts +88 -0
package/src/ui/compare-ducks/mcp-app.html +102 -0
package/src/ui/duck-debate/app.ts +111 -0
package/src/ui/duck-debate/mcp-app.html +97 -0
package/src/ui/duck-vote/app.ts +128 -0
package/src/ui/duck-vote/mcp-app.html +83 -0
package/src/ui/usage-stats/app.ts +156 -0
package/src/ui/usage-stats/mcp-app.html +107 -0
package/tests/duck-debate.test.ts +83 -1
package/tests/duck-iterate.test.ts +81 -0
package/tests/duck-vote.test.ts +73 -1
package/tests/providers.test.ts +121 -0
package/tests/services/progress.test.ts +137 -0
package/tests/services/task-manager.test.ts +344 -0
package/tests/tools/compare-ducks-ui.test.ts +135 -0
package/tests/tools/compare-ducks.test.ts +22 -1
package/tests/tools/duck-council.test.ts +19 -0
package/tests/tools/duck-debate-ui.test.ts +234 -0
package/tests/tools/duck-vote-ui.test.ts +172 -0
package/tests/tools/get-usage-stats.test.ts +3 -1
package/tests/tools/usage-stats-ui.test.ts +130 -0
package/tests/ui-build.test.ts +53 -0
package/tsconfig.json +1 -1
package/vite.config.ts +19 -0

package/src/ui/usage-stats/mcp-app.html ADDED Viewed

@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Usage Stats</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      line-height: 1.5;
+      color: #1a1a2e;
+      background: #f8f9fa;
+      padding: 16px;
+    }
+    .header { text-align: center; margin-bottom: 20px; }
+    .header h2 { margin-bottom: 4px; }
+    .period-badge {
+      display: inline-block;
+      background: #e3f2fd;
+      color: #1565c0;
+      padding: 2px 14px;
+      border-radius: 16px;
+      font-weight: 600;
+      font-size: 0.85em;
+      margin-bottom: 4px;
+    }
+    .date-range { font-size: 0.8em; opacity: 0.6; }
+    .summary-cards {
+      display: flex;
+      gap: 12px;
+      flex-wrap: wrap;
+      justify-content: center;
+      margin-bottom: 24px;
+    }
+    .card {
+      background: #fff;
+      border: 1px solid #e0e0e0;
+      border-radius: 12px;
+      padding: 12px 20px;
+      text-align: center;
+      min-width: 120px;
+      flex: 1;
+    }
+    .card-value { font-size: 1.4em; font-weight: 700; }
+    .card-label { font-size: 0.8em; opacity: 0.6; }
+    .card-req .card-value { color: #1565c0; }
+    .card-tok .card-value { color: #6a1b9a; }
+    .card-cache .card-value { color: #2e7d32; }
+    .card-err .card-value { color: #c62828; }
+    .card-ok .card-value { color: #2e7d32; }
+    .card-cost .card-value { color: #e65100; }
+    .section { margin-bottom: 20px; }
+    .section h3 { margin-bottom: 12px; font-size: 1em; }
+    .provider-row {
+      background: #fff;
+      border-radius: 10px;
+      margin-bottom: 8px;
+      overflow: hidden;
+    }
+    .provider-row summary {
+      padding: 10px 16px;
+      cursor: pointer;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      font-weight: 600;
+    }
+    .provider-stats { font-weight: 400; font-size: 0.85em; opacity: 0.7; }
+    .token-bar { height: 6px; background: #e0e0e0; margin: 0 16px 8px; border-radius: 3px; overflow: hidden; }
+    .token-fill { height: 100%; background: linear-gradient(90deg, #42a5f5, #7e57c2); border-radius: 3px; }
+    .model-table { width: 100%; border-collapse: collapse; font-size: 0.85em; margin: 0 0 8px; }
+    .model-table th {
+      text-align: left;
+      padding: 6px 12px;
+      background: #f5f5f5;
+      font-weight: 600;
+      font-size: 0.9em;
+    }
+    .model-table td { padding: 6px 12px; border-top: 1px solid #eee; }
+    .err-text { color: #c62828; font-weight: 600; }
+    .empty { text-align: center; padding: 24px; opacity: 0.5; }
+    .error-banner { background: #ffebee; color: #c62828; padding: 12px; border-radius: 8px; text-align: center; font-weight: 600; }
+    @media (prefers-color-scheme: dark) {
+      body { background: #1a1a2e; color: #e0e0e0; }
+      .card { background: #16213e; border-color: #0f3460; color: #e0e0e0; }
+      .card-req .card-value { color: #64b5f6; }
+      .card-tok .card-value { color: #ce93d8; }
+      .card-cache .card-value { color: #81c784; }
+      .card-err .card-value { color: #ef5350; }
+      .card-ok .card-value { color: #81c784; }
+      .card-cost .card-value { color: #ffb74d; }
+      .period-badge { background: #0f3460; color: #a0c4ff; }
+      .provider-row { background: #16213e; color: #e0e0e0; }
+      .model-table th { background: #0d1b2a; color: #b0b0b0; }
+      .model-table td { border-color: #0f3460; color: #d0d0d0; }
+      .token-bar { background: #0d1b2a; }
+      .err-text { color: #ef5350; }
+      .error-banner { background: #5c1a1a; color: #ff8a80; }
+    }
+  </style>
+</head>
+<body>
+  <div id="app"><p style="text-align:center;opacity:0.5">Waiting for results...</p></div>
+  <script type="module" src="./app.ts"></script>
+</body>
+</html>

package/tests/duck-debate.test.ts CHANGED Viewed

@@ -163,7 +163,9 @@ describe('duckDebateTool', () => {
       rounds: 2,
     });
-    expect(result.content).toHaveLength(1);
+    expect(result.content).toHaveLength(2);
+    expect(result.content[1].type).toBe('text');
+    expect(() => JSON.parse(result.content[1].text)).not.toThrow();
     const text = result.content[0].text;
     expect(text).toContain('Oxford Debate');
@@ -387,4 +389,84 @@ describe('duckDebateTool', () => {
     // Should not contain the full 900 A's
     expect(text).not.toContain('A'.repeat(900));
   });
+  it('should throw when signal is already aborted before starting', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    await expect(
+      duckDebateTool(mockProviderManager, {
+        prompt: 'Test',
+        format: 'oxford',
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+  });
+  it('should throw when signal is aborted between rounds', async () => {
+    const controller = new AbortController();
+    let callCount = 0;
+    // Use mockImplementation so we can abort after round 1 completes
+    mockCreate.mockImplementation(async () => {
+      callCount++;
+      // After both participants in round 1 finish (2 calls), abort
+      if (callCount === 2) {
+        controller.abort();
+      }
+      return {
+        choices: [{ message: { content: `Response ${callCount}` }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      };
+    });
+    await expect(
+      duckDebateTool(mockProviderManager, {
+        prompt: 'Test',
+        format: 'oxford',
+        rounds: 3,
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+    // Only round 1 calls (2 participants), round 2 was never started
+    expect(mockCreate).toHaveBeenCalledTimes(2);
+  });
+  it('should report progress when a ProgressReporter is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+    // 1 round, 2 participants + synthesis = 3 calls
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'PRO' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'CON' }, 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',
+      });
+    await duckDebateTool(mockProviderManager, {
+      prompt: 'Test',
+      format: 'oxford',
+      rounds: 1,
+    }, mockProgress);
+    // 2 participants + 1 synthesis = 3 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(3);
+    // Total steps = 1 round * 2 participants + 1 synthesis = 3
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 3, expect.stringContaining('Round 1/1'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 3, expect.stringContaining('Round 1/1'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(3, 3, 3, 'Synthesis complete');
+  });
 });

package/tests/duck-iterate.test.ts CHANGED Viewed

@@ -276,4 +276,85 @@ describe('duckIterateTool', () => {
     // Final response section should have the short refined response
     expect(text).toContain('Short refined response');
   });
+  it('should throw when signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    await expect(
+      duckIterateTool(mockProviderManager, {
+        prompt: 'Test',
+        providers: ['openai', 'gemini'],
+        mode: 'refine',
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+  });
+  it('should throw when signal is aborted between iterations', async () => {
+    const controller = new AbortController();
+    let callCount = 0;
+    // Use mockImplementation so we can abort after round 1 completes
+    mockCreate.mockImplementation(async () => {
+      callCount++;
+      // After round 1 (first call = initial generation), abort
+      if (callCount === 1) {
+        controller.abort();
+      }
+      return {
+        choices: [{ message: { content: `Response ${callCount}` }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      };
+    });
+    await expect(
+      duckIterateTool(mockProviderManager, {
+        prompt: 'Test',
+        providers: ['openai', 'gemini'],
+        mode: 'refine',
+        iterations: 3,
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+    // Only 1 call (initial generation), round 2 was never started
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+  });
+  it('should report progress when a ProgressReporter is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Initial response' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Refined response' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final refinement' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+    await duckIterateTool(mockProviderManager, {
+      prompt: 'Test prompt',
+      providers: ['openai', 'gemini'],
+      mode: 'refine',
+      iterations: 3,
+    }, mockProgress);
+    // 3 rounds = 3 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(3);
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 3, expect.stringContaining('Round 1/3'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 3, expect.stringContaining('Round 2/3'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(3, 3, 3, expect.stringContaining('Round 3/3'));
+  });
 });

package/tests/duck-vote.test.ts CHANGED Viewed

@@ -115,8 +115,10 @@ describe('duckVoteTool', () => {
       options: ['Option A', 'Option B'],
     });
-    expect(result.content).toHaveLength(1);
+    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();
     const text = result.content[0].text;
     expect(text).toContain('Vote Results');
@@ -264,6 +266,76 @@ describe('duckVoteTool', () => {
     mockProviderManager.getProviderNames = originalGetProviderNames;
   });
+  it('should use compareDucksWithProgress when progress is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 80, "reasoning": "Good"}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 75, "reasoning": "Also good"}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+    await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['Option A', 'Option B'],
+    }, mockProgress);
+    // 2 voters = 2 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(2);
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 2, expect.stringContaining('voted'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 2, expect.stringContaining('voted'));
+  });
+  it('should use compareDucks when no progress is provided', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 80}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 75}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+    // Spy on compareDucks to ensure it's called (not compareDucksWithProgress)
+    const compareDucksSpy = jest.spyOn(mockProviderManager, 'compareDucks');
+    const compareDucksWithProgressSpy = jest.spyOn(mockProviderManager, 'compareDucksWithProgress');
+    await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['Option A', 'Option B'],
+    });
+    expect(compareDucksSpy).toHaveBeenCalled();
+    expect(compareDucksWithProgressSpy).not.toHaveBeenCalled();
+    compareDucksSpy.mockRestore();
+    compareDucksWithProgressSpy.mockRestore();
+  });
   it('should handle case when no valid votes result in no winner', async () => {
     // Both responses don't mention any valid option
     mockCreate

package/tests/providers.test.ts CHANGED Viewed

@@ -371,6 +371,127 @@ describe('ProviderManager', () => {
   });
 });
+describe('ProviderManager compareDucksWithProgress', () => {
+  let manager: ProviderManager;
+  let mockConfigManager: jest.Mocked<ConfigManager>;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCreate.mockResolvedValue({
+      choices: [{
+        message: { content: 'Mocked response' },
+        finish_reason: 'stop',
+      }],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+      model: 'mock-model',
+    });
+    mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          test1: {
+            api_key: 'key1',
+            base_url: 'https://api1.test.com/v1',
+            default_model: 'model1',
+            nickname: 'Duck 1',
+            models: ['model1'],
+          },
+          test2: {
+            api_key: 'key2',
+            base_url: 'https://api2.test.com/v1',
+            default_model: 'model2',
+            nickname: 'Duck 2',
+            models: ['model2'],
+          },
+        },
+        default_provider: 'test1',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as any;
+    manager = new ProviderManager(mockConfigManager);
+    const provider1 = manager.getProvider('test1');
+    const provider2 = manager.getProvider('test2');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+  it('should call onProviderComplete for each provider', async () => {
+    const onComplete = jest.fn();
+    await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+    expect(onComplete).toHaveBeenCalledTimes(2);
+    // First call: completed=1, total=2
+    expect(onComplete).toHaveBeenNthCalledWith(1, expect.any(String), 1, 2);
+    // Second call: completed=2, total=2
+    expect(onComplete).toHaveBeenNthCalledWith(2, expect.any(String), 2, 2);
+  });
+  it('should return responses from all providers', async () => {
+    const onComplete = jest.fn();
+    const responses = await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+    expect(responses).toHaveLength(2);
+    expect(responses[0].provider).toBe('test1');
+    expect(responses[1].provider).toBe('test2');
+    expect(responses[0].content).toBe('Mocked response');
+  });
+  it('should use all providers when providerNames is undefined', async () => {
+    const onComplete = jest.fn();
+    const responses = await manager.compareDucksWithProgress('Hello', undefined, undefined, onComplete);
+    expect(responses).toHaveLength(2);
+    expect(onComplete).toHaveBeenCalledTimes(2);
+  });
+  it('should call onProviderComplete even when a provider errors', async () => {
+    const provider1 = manager.getProvider('test1');
+    provider1['client'].chat.completions.create = jest.fn().mockRejectedValue(new Error('API Error'));
+    const onComplete = jest.fn();
+    const responses = await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+    // Both callbacks should fire (error path included via .catch().then())
+    expect(onComplete).toHaveBeenCalledTimes(2);
+    expect(responses).toHaveLength(2);
+    expect(responses[0].content).toContain('Error');
+    expect(responses[1].content).toBe('Mocked response');
+  });
+  it('should throw when no valid providers specified', async () => {
+    const onComplete = jest.fn();
+    await expect(
+      manager.compareDucksWithProgress('Hello', ['nonexistent'], undefined, onComplete)
+    ).rejects.toThrow('No valid providers specified');
+    expect(onComplete).not.toHaveBeenCalled();
+  });
+  it('should pass options through to askDuck', async () => {
+    const onComplete = jest.fn();
+    const askDuckSpy = jest.spyOn(manager, 'askDuck');
+    await manager.compareDucksWithProgress('Hello', ['test1'], { model: 'custom-model' }, onComplete);
+    expect(askDuckSpy).toHaveBeenCalledWith('test1', 'Hello', { model: 'custom-model' });
+    askDuckSpy.mockRestore();
+  });
+});
 describe('ProviderManager Error Cases', () => {
   it('should throw error when no default provider and none specified', () => {
     const mockConfigManager = {

package/tests/services/progress.test.ts ADDED Viewed

@@ -0,0 +1,137 @@
+import { describe, it, expect, jest } from '@jest/globals';
+import { createProgressReporter } from '../../src/services/progress.js';
+import type { ProgressReporter } from '../../src/services/progress.js';
+describe('createProgressReporter', () => {
+  it('should return a disabled no-op reporter when progressToken is undefined', () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter(undefined, sendNotification);
+    expect(reporter.enabled).toBe(false);
+  });
+  it('should not call sendNotification when progressToken is undefined', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter(undefined, sendNotification);
+    await reporter.report(1, 10, 'test');
+    expect(sendNotification).not.toHaveBeenCalled();
+  });
+  it('should return an enabled reporter when progressToken is a string', () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter('token-123', sendNotification);
+    expect(reporter.enabled).toBe(true);
+  });
+  it('should return an enabled reporter when progressToken is a number', () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter(42, sendNotification);
+    expect(reporter.enabled).toBe(true);
+  });
+  it('should send a progress notification with correct method and params', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter('my-token', sendNotification);
+    await reporter.report(3, 10, 'Processing step 3');
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+    expect(sendNotification).toHaveBeenCalledWith({
+      method: 'notifications/progress',
+      params: {
+        progressToken: 'my-token',
+        progress: 3,
+        total: 10,
+        message: 'Processing step 3',
+      },
+    });
+  });
+  it('should omit message field when message is undefined', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter('tok', sendNotification);
+    await reporter.report(1, 5);
+    expect(sendNotification).toHaveBeenCalledWith({
+      method: 'notifications/progress',
+      params: {
+        progressToken: 'tok',
+        progress: 1,
+        total: 5,
+      },
+    });
+  });
+  it('should send multiple progress notifications for successive reports', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter('tok', sendNotification);
+    await reporter.report(1, 3, 'A done');
+    await reporter.report(2, 3, 'B done');
+    await reporter.report(3, 3, 'C done');
+    expect(sendNotification).toHaveBeenCalledTimes(3);
+    // Verify increasing progress values
+    const calls = sendNotification.mock.calls as unknown as Array<[{ params: { progress: number } }]>;
+    expect(calls[0][0].params.progress).toBe(1);
+    expect(calls[1][0].params.progress).toBe(2);
+    expect(calls[2][0].params.progress).toBe(3);
+  });
+  it('should use a numeric progressToken correctly', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockResolvedValue(undefined);
+    const reporter = createProgressReporter(99, sendNotification);
+    await reporter.report(1, 1);
+    expect(sendNotification).toHaveBeenCalledWith({
+      method: 'notifications/progress',
+      params: {
+        progressToken: 99,
+        progress: 1,
+        total: 1,
+      },
+    });
+  });
+  it('should swallow sendNotification errors without throwing', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>().mockRejectedValue(new Error('client disconnected'));
+    const reporter = createProgressReporter('tok', sendNotification);
+    // Should NOT throw — progress is best-effort
+    await expect(reporter.report(1, 5, 'step')).resolves.toBeUndefined();
+    expect(sendNotification).toHaveBeenCalledTimes(1);
+  });
+  it('should continue reporting after a notification error', async () => {
+    const sendNotification = jest.fn<() => Promise<void>>()
+      .mockRejectedValueOnce(new Error('transient error'))
+      .mockResolvedValueOnce(undefined);
+    const reporter = createProgressReporter('tok', sendNotification);
+    await reporter.report(1, 2, 'first');
+    await reporter.report(2, 2, 'second');
+    expect(sendNotification).toHaveBeenCalledTimes(2);
+  });
+});
+describe('ProgressReporter interface', () => {
+  it('should be easy to create a mock for testing tools', async () => {
+    // This tests the pattern tool tests will use
+    const mockReporter: ProgressReporter = {
+      enabled: true,
+      report: jest.fn<ProgressReporter['report']>().mockResolvedValue(undefined),
+    };
+    await mockReporter.report(1, 3, 'step 1');
+    expect(mockReporter.report).toHaveBeenCalledWith(1, 3, 'step 1');
+  });
+});