mcp-rubber-duck 1.7.0 → 1.8.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.8.0](https://github.com/nesquikm/mcp-rubber-duck/compare/v1.7.0...v1.8.0) (2026-01-14)
+
+
+### Features
+
+* add MCP prompts capability with 8 multi-LLM focused templates ([e62bfc1](https://github.com/nesquikm/mcp-rubber-duck/commit/e62bfc10dc3302ef8ea254684fb2bcaec1ac7fdd)), closes [#23](https://github.com/nesquikm/mcp-rubber-duck/issues/23)
+
 # [1.7.0](https://github.com/nesquikm/mcp-rubber-duck/compare/v1.6.1...v1.7.0) (2026-01-13)
 
 

package/README.md

@@ -23,6 +23,9 @@ An MCP (Model Context Protocol) server that acts as a bridge to query multiple O
   - [Basic Tools](#basic-tools)
   - [Multi-Agent Tools](#multi-agent-consensus--debate-tools)
   - [MCP Bridge Tools](#mcp-bridge-tools)
+- [Available Prompts](#available-prompts)
+  - [Known Limitations (Claude Code)](#known-limitations-claude-code)
+  - [Recommended: Use Prompts as Templates](#recommended-use-prompts-as-templates)
 - [Usage Examples](#usage-examples)
 - [Provider-Specific Setup](#provider-specific-setup)
 - [Docker Support](#docker-support)
@@ -40,12 +43,14 @@ An MCP (Model Context Protocol) server that acts as a bridge to query multiple O
 - ⚖️ **LLM-as-Judge**: Have ducks evaluate and rank each other's responses
 - 🔄 **Iterative Refinement**: Two ducks collaboratively improve responses
 - 🎓 **Structured Debates**: Oxford, Socratic, and adversarial debate formats
+- 📝 **MCP Prompts**: 8 reusable prompt templates for multi-LLM workflows (via `/` commands)
 - 💾 **Response Caching**: Avoid duplicate API calls with intelligent caching
 - 🔁 **Automatic Failover**: Falls back to other providers if primary fails
 - 📊 **Health Monitoring**: Real-time health checks for all providers
 - 💰 **Usage Tracking**: Track requests, tokens, and estimated costs per provider
 - 🔗 **MCP Bridge**: Connect ducks to other MCP servers for extended functionality
 - 🛡️ **Granular Security**: Per-server approval controls with session-based approvals
+- 🏷️ **Tool Annotations**: MCP-compliant hints for tool behavior (read-only, destructive, etc.)
 - 🎨 **Fun Duck Theme**: Rubber duck debugging with personality!
 
 ## Supported Providers
@@ -288,7 +293,7 @@ Use the compare_ducks tool with prompt: "Explain async/await in JavaScript"
 
 #### Test Specific Models
 ```
-Use the ask_duck tool with prompt: "Hello", provider: "openai", model: "gpt-4"
+Use the ask_duck tool with prompt: "Hello", provider: "openai", model: "gpt-4o"
 ```
 
 ### Troubleshooting Claude Desktop Setup
@@ -621,6 +626,102 @@ Approve or deny a duck's MCP tool request.
 }
 ```
 
+## Available Prompts
+
+MCP Prompts are reusable templates that help you structure questions for multi-LLM analysis. Access them via `/` commands in Claude Desktop or other MCP clients.
+
+**Key Concept**: Unlike tools (which execute actions), prompts help you *frame your questions* to get better multi-perspective responses from multiple LLMs.
+
+| Prompt | Purpose | Required Arguments |
+|--------|---------|-------------------|
+| 📊 `perspectives` | Multi-angle analysis with assigned lenses | `problem`, `perspectives` |
+| 🔍 `assumptions` | Surface hidden assumptions in plans | `plan` |
+| 👁️ `blindspots` | Hunt for overlooked risks and gaps | `proposal` |
+| ⚖️ `tradeoffs` | Structured option comparison | `options`, `criteria` |
+| 🛡️ `red_team` | Security/risk analysis from multiple angles | `target` |
+| 🔄 `reframe` | Problem reframing at different levels | `problem` |
+| 🏗️ `architecture` | Design review across concerns | `design`, `workloads`, `priorities` |
+| 💡 `diverge_converge` | Divergent exploration then convergence | `challenge` |
+
+### Example: Using `perspectives` with Duck Council
+
+The most reliable way to use prompts is as templates with duck tools:
+
+```
+Use duck_council with this prompt:
+
+"Analyze this problem from multiple perspectives:
+
+**PROBLEM:** Review this authentication middleware for our API
+
+**PERSPECTIVES:** security, performance, maintainability, error handling
+
+**CONTEXT:** [paste your code here]
+
+Each LLM should adopt ONE lens and provide targeted analysis from that viewpoint."
+```
+
+### Example: Using `tradeoffs` with Compare Ducks
+
+```
+Use compare_ducks with this prompt:
+
+"Analyze these technical options:
+
+**OPTIONS:** PostgreSQL, MongoDB, Redis
+
+**CRITERIA:** scalability, query flexibility, operational complexity, cost
+
+**CONTEXT:** Real-time analytics dashboard with 10k concurrent users
+
+Score each option against each criterion (1-5) and identify the biggest trade-off."
+```
+
+This approach works reliably and leverages multi-LLM analysis.
+
+### Known Limitations (Claude Code)
+
+MCP prompts are correctly implemented per the [MCP specification](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts), but Claude Code's support for MCP prompts has limitations:
+
+| Issue | Status | Workaround |
+|-------|--------|------------|
+| Must type `(MCP)` suffix | Required | Use `/rubber-duck:reframe (MCP)` not `/rubber-duck:reframe` |
+| Arguments with spaces broken | [Won't fix](https://github.com/anthropics/claude-code/issues/6657) | Use single words: `problem="checkout-abandonment"` |
+| Argument hints not shown | Missing | See table above for required arguments |
+| Optional-only prompts need input | [Won't fix](https://github.com/anthropics/claude-code/issues/5597) | Type at least one character |
+
+**Example that works:**
+```
+/rubber-duck:reframe (MCP) problem="slow-api-responses"
+```
+
+**Example that fails:**
+```
+/rubber-duck:reframe (MCP) problem="Users abandon checkout at payment"
+                                    ↑ spaces break argument parsing
+```
+
+### Recommended: Use Prompts as Templates
+
+For the best experience, use prompts as templates with duck tools directly. Copy the prompt structure and send to `duck_council`, `compare_ducks`, or `ask_duck`:
+
+```
+Use duck_council with this prompt:
+
+"Analyze this problem from multiple perspectives:
+
+**PROBLEM:** Users abandon checkout at payment step
+
+**PERSPECTIVES:** security, UX, performance, reliability
+
+Each LLM should adopt ONE lens and provide targeted analysis."
+```
+
+This approach:
+- ✅ Works reliably with full argument text
+- ✅ Leverages multi-LLM tools (council, compare, vote)
+- ✅ No Claude Code parsing issues
+
 ## Usage Examples
 
 ### Basic Query
@@ -961,12 +1062,26 @@ mcp-rubber-duck/
 │   ├── config/             # Configuration management
 │   ├── providers/          # OpenAI client wrapper
 │   ├── tools/              # MCP tool implementations
+│   ├── prompts/            # MCP prompt templates
 │   ├── services/           # Health, cache, conversations
 │   └── utils/              # Logging, ASCII art
 ├── config/                 # Configuration examples
 └── tests/                  # Test suites
 ```
 
+### Tool Annotations
+
+All tools include MCP-compliant annotations that describe their behavioral characteristics:
+
+| Annotation | Meaning |
+|------------|---------|
+| `readOnlyHint` | Tool doesn't modify any state |
+| `destructiveHint` | Tool performs irreversible operations |
+| `idempotentHint` | Tool is safe to retry multiple times |
+| `openWorldHint` | Tool accesses external systems (APIs, network) |
+
+These help MCP clients make informed decisions about tool execution and user confirmations.
+
 ## Troubleshooting
 
 ### Provider Not Working

package/dist/prompts/architecture.d.ts

@@ -0,0 +1,6 @@
+import { PromptDefinition } from './types.js';
+/**
+ * Prompt for structured architecture and design reviews.
+ */
+export declare const architecturePrompt: PromptDefinition;
+//# sourceMappingURL=architecture.d.ts.map

package/dist/prompts/architecture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"architecture.d.ts","sourceRoot":"","sources":["../../src/prompts/architecture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBAyGhC,CAAC"}

package/dist/prompts/architecture.js

@@ -0,0 +1,103 @@
+/**
+ * Prompt for structured architecture and design reviews.
+ */
+export const architecturePrompt = {
+    name: 'architecture',
+    description: 'Structured architecture or design review from multiple engineering perspectives. Each reviewer focuses on different cross-cutting concerns.',
+    arguments: [
+        {
+            name: 'design',
+            description: 'Description of the architecture, system design, or technical approach',
+            required: true,
+        },
+        {
+            name: 'workloads',
+            description: 'Key use cases, workloads, or scenarios the design must handle',
+            required: true,
+        },
+        {
+            name: 'priorities',
+            description: 'Non-functional priorities (e.g., "latency, cost, simplicity, observability")',
+            required: true,
+        },
+        {
+            name: 'uncertainties',
+            description: 'Areas where you feel most unsure or want extra scrutiny',
+            required: false,
+        },
+    ],
+    buildMessages: (args) => {
+        const { design, workloads, priorities, uncertainties } = args;
+        if (!design) {
+            throw new Error('design argument is required');
+        }
+        if (!workloads) {
+            throw new Error('workloads argument is required');
+        }
+        if (!priorities) {
+            throw new Error('priorities argument is required');
+        }
+        let messageText = `Review this architecture from multiple engineering perspectives:
+
+**DESIGN:**
+${design}
+
+**KEY WORKLOADS/USE CASES:**
+${workloads}
+
+**PRIORITIES:**
+${priorities}
+`;
+        if (uncertainties) {
+            messageText += `
+**AREAS OF UNCERTAINTY (extra scrutiny needed):**
+${uncertainties}
+`;
+        }
+        messageText += `
+**YOUR TASK:**
+Each reviewer should focus on a different cross-cutting concern:
+
+1. **Scalability & Performance**
+   - Can this handle the stated workloads?
+   - Where are the bottlenecks?
+   - How does it scale (vertically/horizontally)?
+
+2. **Reliability & Failure Modes**
+   - What happens when components fail?
+   - Are there single points of failure?
+   - How is state handled during failures?
+
+3. **Operational Complexity**
+   - How hard is this to deploy, monitor, and debug?
+   - What operational burden does this create?
+   - How observable is the system?
+
+4. **Developer Experience**
+   - How easy is this to understand and modify?
+   - What's the learning curve?
+   - How testable is this design?
+
+5. **Cost Efficiency**
+   - What are the cost drivers?
+   - Are there cheaper alternatives that meet requirements?
+   - How do costs scale with load?
+
+**For each concern:**
+- Identify specific issues or risks
+- Suggest improvements aligned with the stated priorities
+- Note trade-offs (improving one area may hurt another)
+
+Focus on actionable feedback, not generic advice.`;
+        return [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: messageText,
+                },
+            },
+        ];
+    },
+};
+//# sourceMappingURL=architecture.js.map

package/dist/prompts/architecture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"architecture.js","sourceRoot":"","sources":["../../src/prompts/architecture.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAqB;IAClD,IAAI,EAAE,cAAc;IACpB,WAAW,EACT,6IAA6I;IAC/I,SAAS,EAAE;QACT;YACE,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,uEAAuE;YACpF,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,WAAW;YACjB,WAAW,EAAE,+DAA+D;YAC5E,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,YAAY;YAClB,WAAW,EACT,8EAA8E;YAChF,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,eAAe;YACrB,WAAW,EAAE,yDAAyD;YACtE,QAAQ,EAAE,KAAK;SAChB;KACF;IACD,aAAa,EAAE,CAAC,IAA4B,EAAE,EAAE;QAC9C,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;QAE9D,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,WAAW,GAAG;;;EAGpB,MAAM;;;EAGN,SAAS;;;EAGT,UAAU;CACX,CAAC;QAEE,IAAI,aAAa,EAAE,CAAC;YAClB,WAAW,IAAI;;EAEnB,aAAa;CACd,CAAC;QACE,CAAC;QAED,WAAW,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAkC+B,CAAC;QAE/C,OAAO;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,WAAW;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/prompts/assumptions.d.ts

@@ -0,0 +1,6 @@
+import { PromptDefinition } from './types.js';
+/**
+ * Prompt to surface and challenge hidden assumptions in a plan or design.
+ */
+export declare const assumptionsPrompt: PromptDefinition;
+//# sourceMappingURL=assumptions.d.ts.map

package/dist/prompts/assumptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assumptions.d.ts","sourceRoot":"","sources":["../../src/prompts/assumptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBA0E/B,CAAC"}

package/dist/prompts/assumptions.js

@@ -0,0 +1,72 @@
+/**
+ * Prompt to surface and challenge hidden assumptions in a plan or design.
+ */
+export const assumptionsPrompt = {
+    name: 'assumptions',
+    description: 'Surface and challenge hidden assumptions in a plan, design, or idea. Identifies implicit premises that could be risky if wrong.',
+    arguments: [
+        {
+            name: 'plan',
+            description: 'The plan, design, or idea to analyze for hidden assumptions',
+            required: true,
+        },
+        {
+            name: 'constraints',
+            description: 'Known hard constraints that are definitely true',
+            required: false,
+        },
+        {
+            name: 'concerns',
+            description: 'Areas where you feel uncertain or worried',
+            required: false,
+        },
+    ],
+    buildMessages: (args) => {
+        const { plan, constraints, concerns } = args;
+        if (!plan) {
+            throw new Error('plan argument is required');
+        }
+        let messageText = `Please analyze the hidden assumptions in this plan:
+
+**PLAN/DESIGN/IDEA:**
+${plan}
+`;
+        if (constraints) {
+            messageText += `
+**KNOWN CONSTRAINTS (definitely true):**
+${constraints}
+`;
+        }
+        if (concerns) {
+            messageText += `
+**MY CONCERNS/UNCERTAINTIES:**
+${concerns}
+`;
+        }
+        messageText += `
+**YOUR TASK:**
+Identify the implicit assumptions underlying this plan. For each assumption:
+
+1. **State it explicitly** - What is being assumed without being stated?
+2. **Criticality** (high/medium/low) - How important is this assumption to the plan's success?
+3. **Fragility** (high/medium/low) - How likely is this assumption to be wrong?
+4. **Validation** - How could we test or verify this assumption?
+
+Focus on assumptions that:
+- Are easy to overlook
+- Would cause significant problems if wrong
+- Others analyzing this might miss
+
+Each LLM should try to find assumptions the others might not catch.`;
+        return [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: messageText,
+                },
+            },
+        ];
+    },
+};
+//# sourceMappingURL=assumptions.js.map

package/dist/prompts/assumptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assumptions.js","sourceRoot":"","sources":["../../src/prompts/assumptions.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAqB;IACjD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,iIAAiI;IACnI,SAAS,EAAE;QACT;YACE,IAAI,EAAE,MAAM;YACZ,WAAW,EAAE,6DAA6D;YAC1E,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,aAAa;YACnB,WAAW,EAAE,iDAAiD;YAC9D,QAAQ,EAAE,KAAK;SAChB;QACD;YACE,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,2CAA2C;YACxD,QAAQ,EAAE,KAAK;SAChB;KACF;IACD,aAAa,EAAE,CAAC,IAA4B,EAAE,EAAE;QAC9C,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAE7C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,WAAW,GAAG;;;EAGpB,IAAI;CACL,CAAC;QAEE,IAAI,WAAW,EAAE,CAAC;YAChB,WAAW,IAAI;;EAEnB,WAAW;CACZ,CAAC;QACE,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,WAAW,IAAI;;EAEnB,QAAQ;CACT,CAAC;QACE,CAAC;QAED,WAAW,IAAI;;;;;;;;;;;;;;oEAciD,CAAC;QAEjE,OAAO;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,WAAW;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/prompts/blindspots.d.ts

@@ -0,0 +1,6 @@
+import { PromptDefinition } from './types.js';
+/**
+ * Prompt to hunt for missing considerations, gaps, and overlooked risks.
+ */
+export declare const blindspotsPrompt: PromptDefinition;
+//# sourceMappingURL=blindspots.d.ts.map

package/dist/prompts/blindspots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blindspots.d.ts","sourceRoot":"","sources":["../../src/prompts/blindspots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAyE9B,CAAC"}

package/dist/prompts/blindspots.js

@@ -0,0 +1,71 @@
+/**
+ * Prompt to hunt for missing considerations, gaps, and overlooked risks.
+ */
+export const blindspotsPrompt = {
+    name: 'blindspots',
+    description: 'Hunt for missing considerations, overlooked risks, and gaps in a proposal. Acts as a panel of critical reviewers looking for what might be underweighted.',
+    arguments: [
+        {
+            name: 'proposal',
+            description: 'The plan, code, design, or proposal to review for blindspots',
+            required: true,
+        },
+        {
+            name: 'covered',
+            description: 'What you think you have already addressed or considered',
+            required: false,
+        },
+        {
+            name: 'risk_tolerance',
+            description: 'Your risk tolerance level: low, medium, or high',
+            required: false,
+        },
+    ],
+    buildMessages: (args) => {
+        const { proposal, covered, risk_tolerance } = args;
+        if (!proposal) {
+            throw new Error('proposal argument is required');
+        }
+        let messageText = `Act as a panel of critical reviewers looking for blindspots.
+
+**PROPOSAL TO REVIEW:**
+${proposal}
+`;
+        if (covered) {
+            messageText += `
+**ALREADY CONSIDERED:**
+${covered}
+`;
+        }
+        if (risk_tolerance) {
+            messageText += `
+**RISK TOLERANCE:** ${risk_tolerance}
+`;
+        }
+        messageText += `
+**YOUR TASK:**
+Each reviewer should identify 2-3 potential blindspots:
+
+1. **Failure modes** - Ways this could fail that aren't being considered
+2. **Missing considerations** - Important factors that are overlooked
+3. **Edge cases** - Scenarios that might break assumptions
+4. **Dependencies** - External factors that could cause problems
+
+For each blindspot:
+- Be specific about WHAT the concern is
+- Explain WHY it's concerning (impact if it happens)
+- Suggest potential mitigations
+
+Look for things that are easy to miss because they seem "obvious" or fall outside the immediate scope. Different reviewers should explore different angles.`;
+        return [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: messageText,
+                },
+            },
+        ];
+    },
+};
+//# sourceMappingURL=blindspots.js.map

package/dist/prompts/blindspots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blindspots.js","sourceRoot":"","sources":["../../src/prompts/blindspots.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqB;IAChD,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,2JAA2J;IAC7J,SAAS,EAAE;QACT;YACE,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,8DAA8D;YAC3E,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,yDAAyD;YACtE,QAAQ,EAAE,KAAK;SAChB;QACD;YACE,IAAI,EAAE,gBAAgB;YACtB,WAAW,EAAE,iDAAiD;YAC9D,QAAQ,EAAE,KAAK;SAChB;KACF;IACD,aAAa,EAAE,CAAC,IAA4B,EAAE,EAAE;QAC9C,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;QAEnD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,WAAW,GAAG;;;EAGpB,QAAQ;CACT,CAAC;QAEE,IAAI,OAAO,EAAE,CAAC;YACZ,WAAW,IAAI;;EAEnB,OAAO;CACR,CAAC;QACE,CAAC;QAED,IAAI,cAAc,EAAE,CAAC;YACnB,WAAW,IAAI;sBACC,cAAc;CACnC,CAAC;QACE,CAAC;QAED,WAAW,IAAI;;;;;;;;;;;;;;4JAcyI,CAAC;QAEzJ,OAAO;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,WAAW;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/prompts/diverge-converge.d.ts

@@ -0,0 +1,6 @@
+import { PromptDefinition } from './types.js';
+/**
+ * Prompt for divergent exploration followed by convergence.
+ */
+export declare const divergeConvergePrompt: PromptDefinition;
+//# sourceMappingURL=diverge-converge.d.ts.map

package/dist/prompts/diverge-converge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diverge-converge.d.ts","sourceRoot":"","sources":["../../src/prompts/diverge-converge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,gBAsFnC,CAAC"}

package/dist/prompts/diverge-converge.js

@@ -0,0 +1,85 @@
+/**
+ * Prompt for divergent exploration followed by convergence.
+ */
+export const divergeConvergePrompt = {
+    name: 'diverge_converge',
+    description: 'Structure divergent thinking (explore many options) followed by convergence (evaluate and select). Maximizes creative exploration before narrowing down.',
+    arguments: [
+        {
+            name: 'challenge',
+            description: 'The problem or challenge to solve',
+            required: true,
+        },
+        {
+            name: 'width',
+            description: 'Exploration width: "wild" for creative/unconventional, "focused" for practical',
+            required: false,
+        },
+        {
+            name: 'convergence_criteria',
+            description: 'What makes a solution "good" - criteria for evaluating options',
+            required: false,
+        },
+    ],
+    buildMessages: (args) => {
+        const { challenge, width, convergence_criteria } = args;
+        if (!challenge) {
+            throw new Error('challenge argument is required');
+        }
+        const explorationMode = width || 'balanced';
+        const criteria = convergence_criteria || 'feasibility, impact, and effort required';
+        let messageText = `Let's use divergent-then-convergent thinking:
+
+**CHALLENGE:**
+${challenge}
+
+**EXPLORATION MODE:** ${explorationMode}
+**SUCCESS CRITERIA:** ${criteria}
+
+---
+
+## PHASE 1: DIVERGE
+
+Each LLM should propose 2-3 **substantially DIFFERENT** approaches. The goal is diversity, not agreement.
+
+Guidelines:
+- Maximize variety in your proposals
+- Include at least one unconventional or surprising idea
+- Don't self-censor "crazy" ideas yet
+- Brief descriptions are fine - we'll evaluate later
+`;
+        if (explorationMode === 'wild') {
+            messageText += `- Push boundaries - what would you suggest if there were no constraints?
+`;
+        }
+        else if (explorationMode === 'focused') {
+            messageText += `- Stay practical - focus on implementable solutions
+`;
+        }
+        messageText += `
+---
+
+## PHASE 2: CONVERGE
+
+After all options are on the table, evaluate them against the success criteria:
+
+1. **Quick assessment** of each option against: ${criteria}
+2. **Identify top 2-3 candidates** that best meet the criteria
+3. **Hybrid opportunities** - can elements from different approaches be combined?
+4. **Recommendation** - which approach (or combination) should we pursue?
+
+---
+
+Start with Phase 1 - generate diverse options first, then we'll converge.`;
+        return [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: messageText,
+                },
+            },
+        ];
+    },
+};
+//# sourceMappingURL=diverge-converge.js.map

package/dist/prompts/diverge-converge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diverge-converge.js","sourceRoot":"","sources":["../../src/prompts/diverge-converge.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAqB;IACrD,IAAI,EAAE,kBAAkB;IACxB,WAAW,EACT,0JAA0J;IAC5J,SAAS,EAAE;QACT;YACE,IAAI,EAAE,WAAW;YACjB,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,gFAAgF;YAC7F,QAAQ,EAAE,KAAK;SAChB;QACD;YACE,IAAI,EAAE,sBAAsB;YAC5B,WAAW,EAAE,gEAAgE;YAC7E,QAAQ,EAAE,KAAK;SAChB;KACF;IACD,aAAa,EAAE,CAAC,IAA4B,EAAE,EAAE;QAC9C,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAAC;QAExD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,eAAe,GAAG,KAAK,IAAI,UAAU,CAAC;QAC5C,MAAM,QAAQ,GAAG,oBAAoB,IAAI,0CAA0C,CAAC;QAEpF,IAAI,WAAW,GAAG;;;EAGpB,SAAS;;wBAEa,eAAe;wBACf,QAAQ;;;;;;;;;;;;;CAa/B,CAAC;QAEE,IAAI,eAAe,KAAK,MAAM,EAAE,CAAC;YAC/B,WAAW,IAAI;CACpB,CAAC;QACE,CAAC;aAAM,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YACzC,WAAW,IAAI;CACpB,CAAC;QACE,CAAC;QAED,WAAW,IAAI;;;;;;;kDAO+B,QAAQ;;;;;;;0EAOgB,CAAC;QAEvE,OAAO;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,WAAW;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/prompts/index.d.ts

@@ -0,0 +1,22 @@
+import { Prompt, GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import { PromptDefinition } from './types.js';
+/**
+ * Registry of all available prompts.
+ */
+export declare const PROMPTS: Record<string, PromptDefinition>;
+/**
+ * Get all available prompts (without buildMessages function).
+ * Used for prompts/list handler.
+ */
+export declare function getPrompts(): Prompt[];
+/**
+ * Get a specific prompt with generated messages.
+ * Used for prompts/get handler.
+ *
+ * @param name - The prompt name
+ * @param args - Arguments to pass to the prompt
+ * @returns GetPromptResult with description and messages
+ * @throws Error if prompt not found or required arguments missing
+ */
+export declare function getPrompt(name: string, args: Record<string, string>): GetPromptResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAY9C;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CASpD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,EAAE,CAErC;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,eAAe,CAkBrF"}

package/dist/prompts/index.js

@@ -0,0 +1,57 @@
+// Import all prompt definitions
+import { perspectivesPrompt } from './perspectives.js';
+import { assumptionsPrompt } from './assumptions.js';
+import { blindspotsPrompt } from './blindspots.js';
+import { tradeoffsPrompt } from './tradeoffs.js';
+import { redTeamPrompt } from './red-team.js';
+import { reframePrompt } from './reframe.js';
+import { architecturePrompt } from './architecture.js';
+import { divergeConvergePrompt } from './diverge-converge.js';
+/**
+ * Registry of all available prompts.
+ */
+export const PROMPTS = {
+    perspectives: perspectivesPrompt,
+    assumptions: assumptionsPrompt,
+    blindspots: blindspotsPrompt,
+    tradeoffs: tradeoffsPrompt,
+    red_team: redTeamPrompt,
+    reframe: reframePrompt,
+    architecture: architecturePrompt,
+    diverge_converge: divergeConvergePrompt,
+};
+/**
+ * Get all available prompts (without buildMessages function).
+ * Used for prompts/list handler.
+ */
+export function getPrompts() {
+    return Object.values(PROMPTS).map(({ buildMessages: _, ...prompt }) => prompt);
+}
+/**
+ * Get a specific prompt with generated messages.
+ * Used for prompts/get handler.
+ *
+ * @param name - The prompt name
+ * @param args - Arguments to pass to the prompt
+ * @returns GetPromptResult with description and messages
+ * @throws Error if prompt not found or required arguments missing
+ */
+export function getPrompt(name, args) {
+    const prompt = PROMPTS[name];
+    if (!prompt) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    try {
+        const messages = prompt.buildMessages(args);
+        return {
+            description: prompt.description,
+            messages,
+        };
+    }
+    catch (error) {
+        // Re-throw with more context
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to build prompt "${name}": ${errorMessage}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/prompts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAGA,gCAAgC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAqC;IACvD,YAAY,EAAE,kBAAkB;IAChC,WAAW,EAAE,iBAAiB;IAC9B,UAAU,EAAE,gBAAgB;IAC5B,SAAS,EAAE,eAAe;IAC1B,QAAQ,EAAE,aAAa;IACvB,OAAO,EAAE,aAAa;IACtB,YAAY,EAAE,kBAAkB;IAChC,gBAAgB,EAAE,qBAAqB;CACxC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,IAA4B;IAClE,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAC5C,OAAO;YACL,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,QAAQ;SACT,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,6BAA6B;QAC7B,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5E,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,MAAM,YAAY,EAAE,CAAC,CAAC;IACvE,CAAC;AACH,CAAC"}

package/dist/prompts/perspectives.d.ts

@@ -0,0 +1,7 @@
+import { PromptDefinition } from './types.js';
+/**
+ * Multi-angle analysis prompt that assigns different analytical lenses
+ * to each LLM for comprehensive analysis.
+ */
+export declare const perspectivesPrompt: PromptDefinition;
+//# sourceMappingURL=perspectives.d.ts.map