mcp-prompt-optimizer 3.2.3 → 3.4.0

package/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.4.0] - 2026-05-26
+
+### Added
+- `explore_sop_approaches` tool: generates 3 parallel SOP variants (process-oriented, decision-tree, role-based) for comparison. Optionally accepts `blend_description` to blend variants directly into a single SOP. Innovator tier required.
+
 ## [3.1.3] - 2026-04-13
 
 ### Changed

package/index.js

@@ -64,9 +64,18 @@ const ENDPOINTS = {
     SESSION:                 (id) => `/api/v1/context-engineer/sessions/${id}`,
     TRANSFORM:               '/api/v1/context-engineer/transform',
     QUOTA:                   '/api/v1/context-engineer/quota',
+    HARNESS_BUNDLE:          '/api/v1/context-engineer/harness-bundle',
+    SOP_EXPLORE:             '/api/v1/context-engineer/sop-explore',
+    SOP_BLEND:               '/api/v1/context-engineer/sop-blend',
   },
 };
 
+const DEPLOY_TARGET_ENUM = [
+  "claude_code", "claude_desktop", "cursor", "copilot",
+  "windsurf", "cline", "zed", "replit", "openai_agents", "ollama",
+  "amazon_q", "aider", "continue_dev", "crewai"
+];
+
 class MCPPromptOptimizer {
   constructor() {
     this.server = new Server(
@@ -330,7 +339,17 @@ class MCPPromptOptimizer {
             properties: {
               goal: { type: "string", description: "What the agent should accomplish" },
               context: { type: "string", description: "Additional context (optional)" },
-              model_id: { type: "string", description: "Model to use (optional)" }
+              model_id: { type: "string", description: "Model to use (optional)" },
+              intent_frame: {
+                type: "object",
+                description: "Optional IntentFrame to sharpen SOP scope and success criteria.",
+                properties: {
+                  perspective: { type: "string", description: "The agent role or viewpoint (e.g. DevOps engineer)." },
+                  out_of_scope: { type: "string", description: "What is explicitly excluded from this workflow." },
+                  success_definition: { type: "string", description: "Measurable criteria that define success." }
+                },
+                additionalProperties: false
+              }
             },
             required: ["goal"]
           }
@@ -366,6 +385,86 @@ class MCPPromptOptimizer {
           description: "Check your Context Engineer credit balance and available workflow types.",
           inputSchema: { type: "object", properties: {}, additionalProperties: false }
         },
+        {
+          name: "generate_harness_bundle",
+          description: (
+            "Generate a deployment-ready Agentic Harness ZIP bundle for a specific platform. "
+            + "Returns a confirmation message when the bundle is queued. "
+            + "Explorer+ required for non-default deploy targets."
+          ),
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal: {
+                type: "string",
+                description: "The workflow goal the harness is built for."
+              },
+              deploy_target: {
+                oneOf: [
+                  {
+                    type: "string",
+                    enum: DEPLOY_TARGET_ENUM,
+                    description: "Single deploy target."
+                  },
+                  {
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                      type: "string",
+                      enum: DEPLOY_TARGET_ENUM
+                    },
+                    description: "Multiple deploy targets simultaneously (Creator+ required)."
+                  }
+                ],
+                description: (
+                  "Target deployment platform(s). Single string (Explorer+) or array (Creator+). "
+                  + "amazon_q, aider, continue_dev, crewai require Creator+. "
+                  + "Default: claude_code."
+                )
+              },
+              session_id: {
+                type: "string",
+                description: "Optional: session ID from a prior generate_skill_package call to reuse SOP."
+              },
+              sop_content: {
+                type: "string",
+                description: "The SOP content to base the harness on (required if no session_id)."
+              }
+            },
+            required: ["goal"]
+          }
+        },
+        {
+          name: "explore_sop_approaches",
+          description: (
+            "Generate 3 parallel SOP variants (process-oriented, decision-tree, role-based) for comparison before committing. " +
+            "Returns exploration_html (self-contained comparison grid), variants array, and a recommended variant. " +
+            "Innovator tier required. " +
+            "Optionally provide blend_description to skip comparison and receive a single blended SOP instead."
+          ),
+          inputSchema: {
+            type: "object",
+            properties: {
+              goal: {
+                type: "string",
+                description: "The workflow goal to generate SOP variants for"
+              },
+              context: {
+                type: "string",
+                description: "Optional background context or documentation excerpt"
+              },
+              blend_description: {
+                type: "string",
+                description: "Optional: if provided, skips variant comparison and blends all 3 into one SOP using this description"
+              },
+              perspective: { type: "string", description: "Agent role or viewpoint (IntentFrame)" },
+              out_of_scope: { type: "string", description: "What is explicitly excluded (IntentFrame)" },
+              success_definition: { type: "string", description: "Measurable success criteria (IntentFrame)" },
+            },
+            required: ["goal"],
+            additionalProperties: false
+          }
+        },
       ];
 
       // Add advanced tools if Bayesian optimization is enabled
@@ -423,6 +522,8 @@ class MCPPromptOptimizer {
           case "generate_skill_package": return await this.handleGenerateSkillPackage(args);
           case "transform_for_framework": return await this.handleTransformForFramework(args);
           case "get_ce_quota_status": return await this.handleGetCEQuotaStatus();
+          case "generate_harness_bundle": return await this.handleGenerateHarnessBundle(args);
+          case "explore_sop_approaches": return await this.handleExploreSopApproaches(args);
           default: throw new Error(`Unknown tool: ${name}`);
         }
       } catch (error) {
@@ -1050,6 +1151,7 @@ class MCPPromptOptimizer {
     const payload = { goal: args.goal };
     if (args.context) payload.context = args.context;
     if (args.model_id) payload.model_id = args.model_id;
+    if (args.intent_frame) payload.intent_frame = args.intent_frame;
     try {
       const result = await this.callBackendAPI(ENDPOINTS.CE.SOP, payload);
       const sopContent = result.sop || result.content || result.result || JSON.stringify(result, null, 2);
@@ -1127,6 +1229,132 @@ class MCPPromptOptimizer {
     }
   }
 
+  async handleGenerateHarnessBundle(args) {
+    if (!args.sop_content && !args.session_id) {
+      return { content: [{ type: "text", text: "Error: provide either sop_content or session_id." }] };
+    }
+    // Normalize deploy_target: string → [string], array → array, undefined → ["claude_code"]
+    let deployTargets;
+    if (!args.deploy_target) {
+      deployTargets = ["claude_code"];
+    } else if (Array.isArray(args.deploy_target)) {
+      deployTargets = args.deploy_target;
+    } else {
+      deployTargets = [args.deploy_target];
+    }
+    // Guard: empty array falls back to default
+    if (deployTargets.length === 0) {
+      deployTargets = ["claude_code"];
+    }
+
+    const payload = {
+      goal: args.goal,
+      deploy_target: deployTargets.length === 1 ? deployTargets[0] : deployTargets,
+      platform: deployTargets[0],
+      user_goal: args.goal,
+      sop_content: args.sop_content || "",
+    };
+
+    // If session_id provided, first fetch session artifacts for sop_content
+    if (args.session_id) {
+      try {
+        const status = await this.callBackendAPI(ENDPOINTS.CE.SESSION(args.session_id), null, "GET");
+        const sop = status.artifacts?.sop_content || status.sop_content || "";
+        if (sop) payload.sop_content = sop;
+      } catch (sessionErr) {
+        console.error(`[handleGenerateHarnessBundle] Could not fetch session ${args.session_id}:`, sessionErr.message || sessionErr);
+        // Proceed with empty sop_content; backend will handle gracefully
+      }
+    }
+
+    try {
+      await this.callBackendAPI(ENDPOINTS.CE.HARNESS_BUNDLE, payload);
+      return {
+        content: [{
+          type: "text",
+          text: `# Harness Bundle Requested\n\nDeploy target: **${deployTargets.join(", ")}**\nGoal: ${args.goal}\n\nDownload from the CE dashboard or via the /harness-bundle API endpoint.`
+        }]
+      };
+    } catch (error) {
+      const msg = error?.message || String(error);
+      if (msg.includes("TIER_LIMIT_REACHED")) {
+        const CREATOR_ONLY = ["amazon_q", "aider", "continue_dev", "crewai"];
+        const needsCreator =
+          msg.includes("creator") ||
+          deployTargets.length > 1 ||
+          CREATOR_ONLY.some(t => deployTargets.includes(t));
+        const tierNeeded = needsCreator ? "Creator" : "Explorer";
+        return { content: [{ type: "text",
+          text: `Upgrade required: this deploy target requires ${tierNeeded} tier or higher. Upgrade at /pricing.`
+        }] };
+      }
+      throw error;
+    }
+  }
+
+  async handleExploreSopApproaches(args) {
+    if (!args.goal) {
+      return { content: [{ type: "text", text: "Error: goal is required." }] };
+    }
+
+    // If blend_description provided, explore then blend in one call chain
+    if (args.blend_description) {
+      try {
+        const explorePayload = {
+          goal: args.goal,
+          context: args.context || undefined,
+          perspective: args.perspective || undefined,
+          out_of_scope: args.out_of_scope || undefined,
+          success_definition: args.success_definition || undefined,
+        };
+        const exploreResult = await this.callBackendAPI(ENDPOINTS.CE.SOP_EXPLORE, explorePayload);
+        const blendPayload = {
+          variants: exploreResult.variants,
+          blend_description: args.blend_description,
+          goal: args.goal,
+        };
+        const blendResult = await this.callBackendAPI(ENDPOINTS.CE.SOP_BLEND, blendPayload);
+        return {
+          content: [{
+            type: "text",
+            text: `# Blended SOP\n\n${blendResult.sop_content}`
+          }]
+        };
+      } catch (error) {
+        throw new Error(`Failed to blend SOP approaches: ${error.message}`);
+      }
+    }
+
+    // Standard exploration: return 3 variant summaries
+    try {
+      const payload = {
+        goal: args.goal,
+        context: args.context || undefined,
+        perspective: args.perspective || undefined,
+        out_of_scope: args.out_of_scope || undefined,
+        success_definition: args.success_definition || undefined,
+      };
+      const result = await this.callBackendAPI(ENDPOINTS.CE.SOP_EXPLORE, payload);
+
+      const variantSummaries = result.variants.map(v => {
+        const rec = v.id === result.recommended ? " *(Recommended)*" : "";
+        return `## Variant ${v.id} — ${v.approach.replace('_', '-')}${rec}\n\n${v.content.slice(0, 600)}${v.content.length > 600 ? '\n\n...(truncated)' : ''}`;
+      }).join('\n\n---\n\n');
+
+      return {
+        content: [{
+          type: "text",
+          text: `# SOP Exploration Results\n\n**Goal:** ${args.goal}\n**Recommended:** Variant ${result.recommended}\n\n---\n\n${variantSummaries}\n\n---\n\n*To select a variant, call generate_skill_package with the full content of your chosen variant as sop_content. To blend variants, re-call explore_sop_approaches with blend_description.*`
+        }]
+      };
+    } catch (error) {
+      if (error.message && error.message.includes('403')) {
+        return { content: [{ type: "text", text: "Error: SOP exploration requires Innovator tier. Upgrade at /pricing." }] };
+      }
+      throw new Error(`Failed to explore SOP approaches: ${error.message}`);
+    }
+  }
+
   _formatSkillPackage(result) {
     const sections = ['# Skill Package Generated'];
     const artifacts = result.artifacts || result.steps || {};
@@ -1172,13 +1400,25 @@ class MCPPromptOptimizer {
         res.on('end', () => {
           try {
             if (res.statusCode >= 200 && res.statusCode < 300) {
-              const parsed = JSON.parse(responseData);
-              resolve(parsed);
+              const contentType = res.headers['content-type'] || '';
+              if (contentType.includes('application/json') || contentType === '') {
+                try {
+                  const parsed = JSON.parse(responseData);
+                  resolve(parsed);
+                } catch (e) {
+                  reject(new Error(`Invalid response format: ${e.message}`));
+                }
+              } else {
+                // Binary or non-JSON response (e.g., application/zip) — return metadata
+                resolve({ _binary: true, contentType, size: responseData.length });
+              }
             } else {
               let errorMessage;
               try {
                 const error = JSON.parse(responseData);
-                errorMessage = error.detail || error.message || `HTTP ${res.statusCode}`;
+                errorMessage = (typeof error.detail === 'object' && error.detail !== null)
+                  ? JSON.stringify(error.detail)
+                  : (error.detail || error.message || `HTTP ${res.statusCode}`);
               } catch {
                 errorMessage = `HTTP ${res.statusCode}: ${responseData}`;
               }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-prompt-optimizer",
-  "version": "3.2.3",
+  "version": "3.4.0",
   "description": "Professional cloud-based MCP server for AI-powered prompt optimization with intelligent context detection, Bayesian optimization, AG-UI real-time optimization, template auto-save, optimization insights, personal model configuration via WebUI, team collaboration, enterprise-grade features, production resilience, and startup validation. Universal compatibility with Claude Desktop, Cursor, Windsurf, and 17+ MCP clients.",
   "main": "index.js",
   "bin": {
@@ -191,9 +191,20 @@
     "feature_parity": true,
     "bayesian_support": true,
     "agui_support": true,
-    "last_sync": "2026-05-22T00:00:00Z"
+    "last_sync": "2026-05-23T00:00:00Z"
   },
   "release_notes": {
+    "v3.3.0": {
+      "major_features": [
+        "New tool: generate_harness_bundle — generate a deployment-ready Agentic Harness ZIP for 9 platforms (claude_code, claude_desktop, cursor, copilot, windsurf, cline, zed, replit, openai_agents)",
+        "generate_agent_sop now accepts intent_frame parameter (perspective, out_of_scope, success_definition) to sharpen SOP scope and success criteria",
+        "Explorer+ tier gate enforced server-side for non-default deploy targets",
+        "callBackendAPI now handles binary (ZIP) responses gracefully — skips JSON parse for non-JSON content types",
+        "Improved TIER_LIMIT_REACHED error detection with proper error detail stringification"
+      ],
+      "breaking_changes": [],
+      "migration_guide": "No migration required. Both new features are additive and fully optional; existing calls are unaffected."
+    },
     "v3.2.3": {
       "major_features": [
         "optimize_prompt now accepts intent_frame parameter for Question Method intent framing",