mcp-rubber-duck 1.7.0 → 1.8.0

package/src/server.ts

@@ -3,6 +3,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
   Tool,
 } from '@modelcontextprotocol/sdk/types.js';
 
@@ -42,6 +44,9 @@ import { mcpStatusTool } from './tools/mcp-status.js';
 // Import usage stats tool
 import { getUsageStatsTool } from './tools/get-usage-stats.js';
 
+// Import prompts
+import { getPrompts, getPrompt } from './prompts/index.js';
+
 export class RubberDuckServer {
   private server: Server;
   private configManager: ConfigManager;
@@ -68,6 +73,7 @@ export class RubberDuckServer {
       {
         capabilities: {
           tools: {},
+          prompts: {},
         },
       }
     );
@@ -142,6 +148,23 @@ export class RubberDuckServer {
       return { tools: this.getTools() };
     });
 
+    // List available prompts
+    this.server.setRequestHandler(ListPromptsRequestSchema, () => {
+      return { prompts: getPrompts() };
+    });
+
+    // Get specific prompt
+    this.server.setRequestHandler(GetPromptRequestSchema, (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        return getPrompt(name, args || {});
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Prompt error for ${name}:`, errorMessage);
+        throw error;
+      }
+    });
+
     // Handle tool calls
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;

package/tests/prompts.test.ts

@@ -0,0 +1,314 @@
+import { describe, it, expect } from '@jest/globals';
+import { getPrompts, getPrompt, PROMPTS } from '../src/prompts/index.js';
+
+describe('Prompts', () => {
+  describe('getPrompts', () => {
+    it('should return all 8 prompts', () => {
+      const prompts = getPrompts();
+      expect(prompts).toHaveLength(8);
+    });
+
+    it('should return prompts with required fields', () => {
+      const prompts = getPrompts();
+      for (const prompt of prompts) {
+        expect(prompt).toHaveProperty('name');
+        expect(prompt).toHaveProperty('description');
+        expect(typeof prompt.name).toBe('string');
+        expect(typeof prompt.description).toBe('string');
+        expect(prompt.name.length).toBeGreaterThan(0);
+        expect(prompt.description.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should return prompts with arguments array', () => {
+      const prompts = getPrompts();
+      for (const prompt of prompts) {
+        expect(Array.isArray(prompt.arguments)).toBe(true);
+      }
+    });
+
+    it('should not expose buildMessages function', () => {
+      const prompts = getPrompts();
+      for (const prompt of prompts) {
+        expect(prompt).not.toHaveProperty('buildMessages');
+      }
+    });
+
+    it('should have unique prompt names', () => {
+      const prompts = getPrompts();
+      const names = prompts.map((p) => p.name);
+      const uniqueNames = new Set(names);
+      expect(uniqueNames.size).toBe(names.length);
+    });
+  });
+
+  describe('getPrompt', () => {
+    it('should throw for unknown prompt', () => {
+      expect(() => getPrompt('nonexistent', {})).toThrow('Unknown prompt: nonexistent');
+    });
+
+    it('should return description and messages', () => {
+      const result = getPrompt('reframe', { problem: 'Test problem' });
+      expect(result).toHaveProperty('description');
+      expect(result).toHaveProperty('messages');
+      expect(Array.isArray(result.messages)).toBe(true);
+      expect(result.messages.length).toBeGreaterThan(0);
+    });
+
+    it('should throw for missing required arguments', () => {
+      expect(() => getPrompt('perspectives', {})).toThrow();
+      expect(() => getPrompt('perspectives', { problem: 'test' })).toThrow(); // missing perspectives
+    });
+
+    it('should wrap errors with prompt context', () => {
+      try {
+        getPrompt('perspectives', {});
+        fail('Should have thrown');
+      } catch (e) {
+        expect((e as Error).message).toMatch(/^Failed to build prompt "perspectives":/);
+        expect((e as Error).message).toContain('problem argument is required');
+      }
+    });
+
+    it('should handle empty string arguments as missing', () => {
+      expect(() => getPrompt('perspectives', { problem: '', perspectives: 'test' })).toThrow(
+        'problem argument is required'
+      );
+    });
+
+    it('should handle whitespace-only arguments as valid', () => {
+      // Whitespace is truthy in JS, so it passes validation (this is intentional)
+      const result = getPrompt('perspectives', { problem: '   ', perspectives: 'test' });
+      expect(result.messages).toHaveLength(1);
+    });
+  });
+
+  describe('perspectives prompt', () => {
+    it('should require problem and perspectives arguments', () => {
+      expect(() => getPrompt('perspectives', {})).toThrow('problem argument is required');
+      expect(() => getPrompt('perspectives', { problem: 'test' })).toThrow(
+        'perspectives argument is required'
+      );
+    });
+
+    it('should build valid messages with required args', () => {
+      const result = getPrompt('perspectives', {
+        problem: 'Test problem',
+        perspectives: 'security, performance',
+      });
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].role).toBe('user');
+      expect(result.messages[0].content).toHaveProperty('type', 'text');
+    });
+
+    it('should include optional context in message', () => {
+      const result = getPrompt('perspectives', {
+        problem: 'Test problem',
+        perspectives: 'security',
+        context: 'Additional context',
+      });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('Additional context');
+    });
+  });
+
+  describe('assumptions prompt', () => {
+    it('should require plan argument', () => {
+      expect(() => getPrompt('assumptions', {})).toThrow('plan argument is required');
+    });
+
+    it('should build valid messages', () => {
+      const result = getPrompt('assumptions', { plan: 'Test plan' });
+      expect(result.messages).toHaveLength(1);
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('Test plan');
+    });
+
+    it('should include optional constraints and concerns', () => {
+      const result = getPrompt('assumptions', {
+        plan: 'Test plan',
+        constraints: 'Must be fast',
+        concerns: 'Worried about scale',
+      });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('Must be fast');
+      expect(text).toContain('Worried about scale');
+    });
+  });
+
+  describe('blindspots prompt', () => {
+    it('should require proposal argument', () => {
+      expect(() => getPrompt('blindspots', {})).toThrow('proposal argument is required');
+    });
+
+    it('should build valid messages', () => {
+      const result = getPrompt('blindspots', { proposal: 'Test proposal' });
+      expect(result.messages).toHaveLength(1);
+    });
+  });
+
+  describe('tradeoffs prompt', () => {
+    it('should require options and criteria arguments', () => {
+      expect(() => getPrompt('tradeoffs', {})).toThrow('options argument is required');
+      expect(() => getPrompt('tradeoffs', { options: 'A, B' })).toThrow(
+        'criteria argument is required'
+      );
+    });
+
+    it('should build valid messages with required args', () => {
+      const result = getPrompt('tradeoffs', {
+        options: 'Option A, Option B',
+        criteria: 'cost, speed',
+      });
+      expect(result.messages).toHaveLength(1);
+    });
+  });
+
+  describe('red_team prompt', () => {
+    it('should require target argument', () => {
+      expect(() => getPrompt('red_team', {})).toThrow('target argument is required');
+    });
+
+    it('should build valid messages', () => {
+      const result = getPrompt('red_team', { target: 'Test system' });
+      expect(result.messages).toHaveLength(1);
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('Test system');
+    });
+  });
+
+  describe('reframe prompt', () => {
+    it('should require problem argument', () => {
+      expect(() => getPrompt('reframe', {})).toThrow('problem argument is required');
+    });
+
+    it('should include three reframing types', () => {
+      const result = getPrompt('reframe', { problem: 'Test problem' });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('HIGHER ABSTRACTION');
+      expect(text).toContain('INVERSION');
+      expect(text).toContain('SIMPLIFICATION');
+    });
+  });
+
+  describe('architecture prompt', () => {
+    it('should require design, workloads, and priorities arguments', () => {
+      expect(() => getPrompt('architecture', {})).toThrow('design argument is required');
+      expect(() => getPrompt('architecture', { design: 'test' })).toThrow(
+        'workloads argument is required'
+      );
+      expect(() => getPrompt('architecture', { design: 'test', workloads: 'test' })).toThrow(
+        'priorities argument is required'
+      );
+    });
+
+    it('should build valid messages with all required args', () => {
+      const result = getPrompt('architecture', {
+        design: 'Microservices',
+        workloads: '1000 req/s',
+        priorities: 'latency, cost',
+      });
+      expect(result.messages).toHaveLength(1);
+    });
+
+    it('should include cross-cutting concerns', () => {
+      const result = getPrompt('architecture', {
+        design: 'test',
+        workloads: 'test',
+        priorities: 'test',
+      });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('Scalability');
+      expect(text).toContain('Reliability');
+      expect(text).toContain('Operational Complexity');
+      expect(text).toContain('Developer Experience');
+      expect(text).toContain('Cost Efficiency');
+    });
+  });
+
+  describe('diverge_converge prompt', () => {
+    it('should require challenge argument', () => {
+      expect(() => getPrompt('diverge_converge', {})).toThrow('challenge argument is required');
+    });
+
+    it('should include diverge and converge phases', () => {
+      const result = getPrompt('diverge_converge', { challenge: 'Test challenge' });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('PHASE 1: DIVERGE');
+      expect(text).toContain('PHASE 2: CONVERGE');
+    });
+
+    it('should use default width and criteria when not provided', () => {
+      const result = getPrompt('diverge_converge', { challenge: 'Test challenge' });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain('balanced');
+      expect(text).toContain('feasibility, impact, and effort required');
+    });
+  });
+
+  describe('PROMPTS registry', () => {
+    it('should have all expected prompts', () => {
+      const expectedNames = [
+        'perspectives',
+        'assumptions',
+        'blindspots',
+        'tradeoffs',
+        'red_team',
+        'reframe',
+        'architecture',
+        'diverge_converge',
+      ];
+      for (const name of expectedNames) {
+        expect(PROMPTS).toHaveProperty(name);
+      }
+    });
+
+    it('should have buildMessages function for all prompts', () => {
+      for (const [name, prompt] of Object.entries(PROMPTS)) {
+        expect(typeof prompt.buildMessages).toBe('function');
+        expect(prompt.name).toBe(name);
+      }
+    });
+  });
+
+  describe('MCP spec compliance', () => {
+    it('should return messages with valid role (user or assistant)', () => {
+      const result = getPrompt('reframe', { problem: 'test' });
+      for (const message of result.messages) {
+        expect(['user', 'assistant']).toContain(message.role);
+      }
+    });
+
+    it('should return messages with valid content type', () => {
+      const result = getPrompt('reframe', { problem: 'test' });
+      for (const message of result.messages) {
+        const content = message.content as { type: string; text?: string };
+        expect(['text', 'image', 'resource']).toContain(content.type);
+        if (content.type === 'text') {
+          expect(typeof content.text).toBe('string');
+        }
+      }
+    });
+
+    it('should preserve user input in generated messages', () => {
+      const userInput = 'Special chars: <>&"\' and unicode: 日本語';
+      const result = getPrompt('reframe', { problem: userInput });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain(userInput);
+    });
+
+    it('should handle very long inputs without truncation', () => {
+      const longInput = 'x'.repeat(50000);
+      const result = getPrompt('reframe', { problem: longInput });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain(longInput);
+    });
+
+    it('should handle inputs with newlines and special whitespace', () => {
+      const multilineInput = 'Line 1\nLine 2\n\tTabbed line\r\nWindows line';
+      const result = getPrompt('reframe', { problem: multilineInput });
+      const text = (result.messages[0].content as { type: string; text: string }).text;
+      expect(text).toContain(multilineInput);
+    });
+  });
+});