mcp-rubber-duck 1.2.5 → 1.3.0

package/src/server.ts

@@ -27,6 +27,10 @@ import { listDucksTool } from './tools/list-ducks.js';
 import { listModelsTool } from './tools/list-models.js';
 import { compareDucksTool } from './tools/compare-ducks.js';
 import { duckCouncilTool } from './tools/duck-council.js';
+import { duckVoteTool } from './tools/duck-vote.js';
+import { duckJudgeTool } from './tools/duck-judge.js';
+import { duckIterateTool } from './tools/duck-iterate.js';
+import { duckDebateTool } from './tools/duck-debate.js';
 
 // Import MCP tools
 import { getPendingApprovalsTool } from './tools/get-pending-approvals.js';
@@ -162,6 +166,18 @@ export class RubberDuckServer {
             }
             return await duckCouncilTool(this.providerManager, args || {});
 
+          case 'duck_vote':
+            return await duckVoteTool(this.providerManager, args || {});
+
+          case 'duck_judge':
+            return await duckJudgeTool(this.providerManager, args || {});
+
+          case 'duck_iterate':
+            return await duckIterateTool(this.providerManager, args || {});
+
+          case 'duck_debate':
+            return await duckDebateTool(this.providerManager, args || {});
+
           // MCP-specific tools
           case 'get_pending_approvals':
             if (!this.approvalService) {
@@ -487,6 +503,144 @@ export class RubberDuckServer {
           required: ['prompt'],
         },
       },
+      {
+        name: 'duck_vote',
+        description: 'Have multiple ducks vote on options with reasoning. Returns vote tally, confidence scores, and consensus level.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            question: {
+              type: 'string',
+              description: 'The question to vote on (e.g., "Best approach for error handling?")',
+            },
+            options: {
+              type: 'array',
+              items: { type: 'string' },
+              minItems: 2,
+              maxItems: 10,
+              description: 'The options to vote on (2-10 options)',
+            },
+            voters: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'List of provider names to vote (optional, uses all if not specified)',
+            },
+            require_reasoning: {
+              type: 'boolean',
+              default: true,
+              description: 'Require ducks to explain their vote (default: true)',
+            },
+          },
+          required: ['question', 'options'],
+        },
+      },
+      {
+        name: 'duck_judge',
+        description: 'Have one duck evaluate and rank other ducks\' responses. Use after duck_council to get a comparative evaluation.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            responses: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  provider: { type: 'string' },
+                  nickname: { type: 'string' },
+                  model: { type: 'string' },
+                  content: { type: 'string' },
+                },
+                required: ['provider', 'nickname', 'content'],
+              },
+              minItems: 2,
+              description: 'Array of duck responses to evaluate (from duck_council output)',
+            },
+            judge: {
+              type: 'string',
+              description: 'Provider name of the judge duck (optional, uses first available)',
+            },
+            criteria: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Evaluation criteria (default: ["accuracy", "completeness", "clarity"])',
+            },
+            persona: {
+              type: 'string',
+              description: 'Judge persona (e.g., "senior engineer", "security expert")',
+            },
+          },
+          required: ['responses'],
+        },
+      },
+      {
+        name: 'duck_iterate',
+        description: 'Iteratively refine a response between two ducks. One generates, the other critiques/improves, alternating for multiple rounds.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            prompt: {
+              type: 'string',
+              description: 'The initial prompt/task to iterate on',
+            },
+            iterations: {
+              type: 'number',
+              minimum: 1,
+              maximum: 10,
+              default: 3,
+              description: 'Number of iteration rounds (default: 3, max: 10)',
+            },
+            providers: {
+              type: 'array',
+              items: { type: 'string' },
+              minItems: 2,
+              maxItems: 2,
+              description: 'Exactly 2 provider names for the ping-pong iteration',
+            },
+            mode: {
+              type: 'string',
+              enum: ['refine', 'critique-improve'],
+              description: 'refine: each duck improves the previous response. critique-improve: alternates between critiquing and improving.',
+            },
+          },
+          required: ['prompt', 'providers', 'mode'],
+        },
+      },
+      {
+        name: 'duck_debate',
+        description: 'Structured multi-round debate between ducks. Supports oxford (pro/con), socratic (questioning), and adversarial (attack/defend) formats.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            prompt: {
+              type: 'string',
+              description: 'The debate topic or proposition',
+            },
+            rounds: {
+              type: 'number',
+              minimum: 1,
+              maximum: 10,
+              default: 3,
+              description: 'Number of debate rounds (default: 3)',
+            },
+            providers: {
+              type: 'array',
+              items: { type: 'string' },
+              minItems: 2,
+              description: 'Provider names to participate (min 2, uses all if not specified)',
+            },
+            format: {
+              type: 'string',
+              enum: ['oxford', 'socratic', 'adversarial'],
+              description: 'Debate format: oxford (pro/con), socratic (questioning), adversarial (attack/defend)',
+            },
+            synthesizer: {
+              type: 'string',
+              description: 'Provider to synthesize the debate (optional, uses first provider)',
+            },
+          },
+          required: ['prompt', 'format'],
+        },
+      },
     ];
 
     // Add MCP-specific tools if enabled

package/src/services/consensus.ts

@@ -0,0 +1,324 @@
+import { VoteResult, AggregatedVote } from '../config/types.js';
+import { logger } from '../utils/logger.js';
+
+interface ParsedVote {
+  choice?: string;
+  confidence?: number | string;
+  reasoning?: string;
+}
+
+export class ConsensusService {
+  /**
+   * Build a voting prompt that asks the LLM to vote on options
+   */
+  buildVotePrompt(
+    question: string,
+    options: string[],
+    requireReasoning: boolean = true
+  ): string {
+    const optionsList = options.map((opt, i) => `${i + 1}. ${opt}`).join('\n');
+
+    const format = requireReasoning
+      ? `{
+  "choice": "<exact option text>",
+  "confidence": <0-100>,
+  "reasoning": "<brief explanation>"
+}`
+      : `{
+  "choice": "<exact option text>",
+  "confidence": <0-100>
+}`;
+
+    return `You are voting on the following question. You MUST choose exactly ONE option from the list below.
+
+QUESTION: ${question}
+
+OPTIONS:
+${optionsList}
+
+INSTRUCTIONS:
+1. Analyze each option carefully
+2. Choose the BEST option based on your knowledge and reasoning
+3. Respond with ONLY a JSON object in this exact format:
+
+${format}
+
+IMPORTANT:
+- "choice" must be the EXACT text of one of the options above
+- "confidence" must be a number from 0 to 100
+- Do NOT include any text before or after the JSON
+- Do NOT use markdown code blocks`;
+  }
+
+  /**
+   * Parse a vote from an LLM response
+   */
+  parseVote(
+    response: string,
+    voter: string,
+    nickname: string,
+    options: string[]
+  ): VoteResult {
+    const result: VoteResult = {
+      voter,
+      nickname,
+      choice: '',
+      confidence: 0,
+      reasoning: '',
+      rawResponse: response,
+    };
+
+    try {
+      // Try to extract JSON from the response (greedy to handle nested objects)
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        logger.warn(`No JSON found in vote response from ${voter}`);
+        return this.fallbackParse(response, voter, nickname, options);
+      }
+
+      const parsed = JSON.parse(jsonMatch[0]) as ParsedVote;
+
+      // Validate choice
+      const choice = parsed.choice?.toString().trim();
+      if (choice) {
+        // Try exact match first
+        const exactMatch = options.find(
+          opt => opt.toLowerCase() === choice.toLowerCase()
+        );
+
+        if (exactMatch) {
+          result.choice = exactMatch;
+        } else {
+          // Try partial match
+          const partialMatch = options.find(
+            opt => opt.toLowerCase().includes(choice.toLowerCase()) ||
+                   choice.toLowerCase().includes(opt.toLowerCase())
+          );
+          if (partialMatch) {
+            result.choice = partialMatch;
+            logger.debug(`Fuzzy matched "${choice}" to "${partialMatch}" for ${voter}`);
+          }
+        }
+      }
+
+      // Parse confidence
+      if (typeof parsed.confidence === 'number') {
+        result.confidence = Math.max(0, Math.min(100, parsed.confidence));
+      } else if (typeof parsed.confidence === 'string') {
+        const conf = parseFloat(parsed.confidence);
+        if (!isNaN(conf)) {
+          result.confidence = Math.max(0, Math.min(100, conf));
+        }
+      }
+
+      // Parse reasoning
+      if (parsed.reasoning) {
+        result.reasoning = parsed.reasoning.toString().trim();
+      }
+
+    } catch (error) {
+      logger.warn(`Failed to parse JSON vote from ${voter}:`, error);
+      return this.fallbackParse(response, voter, nickname, options);
+    }
+
+    return result;
+  }
+
+  /**
+   * Fallback parsing when JSON fails - try to extract choice from text
+   */
+  private fallbackParse(
+    response: string,
+    voter: string,
+    nickname: string,
+    options: string[]
+  ): VoteResult {
+    const result: VoteResult = {
+      voter,
+      nickname,
+      choice: '',
+      confidence: 50, // Default confidence for fallback
+      reasoning: 'Vote extracted via fallback parsing',
+      rawResponse: response,
+    };
+
+    // Try to find any option mentioned in the response
+    const responseLower = response.toLowerCase();
+    for (const option of options) {
+      if (responseLower.includes(option.toLowerCase())) {
+        result.choice = option;
+        logger.debug(`Fallback parsed choice "${option}" from ${voter}`);
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Aggregate votes into a final result
+   */
+  aggregateVotes(
+    question: string,
+    options: string[],
+    votes: VoteResult[]
+  ): AggregatedVote {
+    // Initialize tally and confidence tracking
+    const tally: Record<string, number> = {};
+    const confidenceSums: Record<string, number> = {};
+    const confidenceCounts: Record<string, number> = {};
+
+    for (const option of options) {
+      tally[option] = 0;
+      confidenceSums[option] = 0;
+      confidenceCounts[option] = 0;
+    }
+
+    // Count votes
+    let validVotes = 0;
+    for (const vote of votes) {
+      if (vote.choice && options.includes(vote.choice)) {
+        tally[vote.choice]++;
+        confidenceSums[vote.choice] += vote.confidence;
+        confidenceCounts[vote.choice]++;
+        validVotes++;
+      }
+    }
+
+    // Calculate average confidence per option
+    const confidenceByOption: Record<string, number> = {};
+    for (const option of options) {
+      confidenceByOption[option] = confidenceCounts[option] > 0
+        ? Math.round(confidenceSums[option] / confidenceCounts[option])
+        : 0;
+    }
+
+    // Determine winner
+    const maxVotes = Math.max(...Object.values(tally));
+    const winners = options.filter(opt => tally[opt] === maxVotes && maxVotes > 0);
+
+    const isTie = winners.length > 1;
+    let winner: string | null = null;
+
+    if (winners.length === 1) {
+      winner = winners[0];
+    } else if (isTie && winners.length > 0) {
+      // Break tie by confidence
+      let highestConfidence = -1;
+      for (const w of winners) {
+        if (confidenceByOption[w] > highestConfidence) {
+          highestConfidence = confidenceByOption[w];
+          winner = w;
+        }
+      }
+    }
+
+    // Determine consensus level
+    const consensusLevel = this.determineConsensusLevel(
+      validVotes,
+      votes.length,
+      maxVotes,
+      isTie
+    );
+
+    return {
+      question,
+      options,
+      winner,
+      isTie,
+      tally,
+      confidenceByOption,
+      votes,
+      totalVoters: votes.length,
+      validVotes,
+      consensusLevel,
+    };
+  }
+
+  /**
+   * Determine the level of consensus reached
+   */
+  private determineConsensusLevel(
+    validVotes: number,
+    totalVoters: number,
+    maxVotes: number,
+    isTie: boolean
+  ): 'unanimous' | 'majority' | 'plurality' | 'split' | 'none' {
+    if (validVotes === 0) {
+      return 'none';
+    }
+
+    const winnerRatio = maxVotes / validVotes;
+
+    if (winnerRatio === 1 && validVotes === totalVoters) {
+      return 'unanimous';
+    } else if (winnerRatio > 0.5) {
+      return 'majority';
+    } else if (!isTie && maxVotes > 0) {
+      return 'plurality';
+    } else if (isTie) {
+      return 'split';
+    }
+
+    return 'none';
+  }
+
+  /**
+   * Format the aggregated vote result for display
+   */
+  formatVoteResult(result: AggregatedVote): string {
+    let output = `🗳️ **Vote Results**\n`;
+    output += `═══════════════════════════════════════\n\n`;
+    output += `**Question:** ${result.question}\n\n`;
+
+    // Winner announcement
+    if (result.winner) {
+      const emoji = result.consensusLevel === 'unanimous' ? '🏆' :
+                    result.consensusLevel === 'majority' ? '✅' : '📊';
+      output += `${emoji} **Winner:** ${result.winner}`;
+      if (result.isTie) {
+        output += ` (tie-breaker by confidence)`;
+      }
+      output += `\n`;
+      output += `📈 **Consensus:** ${result.consensusLevel}\n\n`;
+    } else {
+      output += `⚠️ **No valid votes recorded**\n\n`;
+    }
+
+    // Vote tally
+    output += `**Vote Tally:**\n`;
+    const sortedOptions = [...result.options].sort(
+      (a, b) => result.tally[b] - result.tally[a]
+    );
+
+    for (const option of sortedOptions) {
+      const votes = result.tally[option];
+      const confidence = result.confidenceByOption[option];
+      const bar = '█'.repeat(Math.min(votes * 3, 15));
+      const isWinner = option === result.winner;
+      const marker = isWinner ? ' 👑' : '';
+      output += `  ${option}: ${bar} ${votes} vote(s) (avg confidence: ${confidence}%)${marker}\n`;
+    }
+
+    output += `\n**Individual Votes:**\n`;
+    output += `─────────────────────────────────────\n`;
+
+    for (const vote of result.votes) {
+      if (vote.choice) {
+        output += `🦆 **${vote.nickname}** voted: **${vote.choice}**`;
+        output += ` (confidence: ${vote.confidence}%)\n`;
+        if (vote.reasoning) {
+          output += `   💭 "${vote.reasoning}"\n`;
+        }
+      } else {
+        output += `🦆 **${vote.nickname}**: ❌ Invalid vote\n`;
+      }
+      output += `\n`;
+    }
+
+    output += `═══════════════════════════════════════\n`;
+    output += `📊 ${result.validVotes}/${result.totalVoters} valid votes\n`;
+
+    return output;
+  }
+}