mcp-prompt-optimizer 3.2.2 → 3.3.0

package/index.js

@@ -64,6 +64,7 @@ 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',
   },
 };
 
@@ -146,6 +147,25 @@ class MCPPromptOptimizer {
                   },
                   required: ["label", "description"]
                 }
+              },
+              intent_frame: {
+                type: "object",
+                description: "Question Method intent framing — steers optimization toward a specific angle, excludes off-topic territory, and defines what success looks like. Any non-null field floors routing to HYBRID tier minimum.",
+                properties: {
+                  perspective: {
+                    type: "string",
+                    description: "The angle or thesis to optimize from (e.g. 'growth is a retention problem, not an acquisition problem'). Gives the optimizer a north-star direction."
+                  },
+                  out_of_scope: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Topics, approaches, or angles to explicitly exclude from optimization (e.g. ['pricing strategy', 'acquisition channels'])."
+                  },
+                  success_definition: {
+                    type: "string",
+                    description: "Narrative description of what a successful optimized output achieves (e.g. 'reader understands why churn drives flat revenue even with user growth')."
+                  }
+                }
               }
             },
             required: ["prompt"]
@@ -311,7 +331,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"]
           }
@@ -347,6 +377,37 @@ 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: {
+                type: "string",
+                enum: ["claude_code", "claude_desktop", "cursor", "copilot", "windsurf", "cline", "zed", "replit", "openai_agents", "ollama"],
+                description: "Target deployment platform. 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"]
+          }
+        },
       ];
 
       // Add advanced tools if Bayesian optimization is enabled
@@ -404,6 +465,7 @@ 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);
           default: throw new Error(`Unknown tool: ${name}`);
         }
       } catch (error) {
@@ -712,6 +774,13 @@ class MCPPromptOptimizer {
         optimizationPayload.value_hierarchy = args.value_hierarchy;
       }
 
+      if (args.intent_frame && typeof args.intent_frame === 'object') {
+        const { perspective, out_of_scope, success_definition } = args.intent_frame;
+        if (perspective || (out_of_scope && out_of_scope.length > 0) || success_definition) {
+          optimizationPayload.intent_frame = args.intent_frame;
+        }
+      }
+
       const result = await this.callBackendAPI(ENDPOINTS.OPTIMIZE, optimizationPayload);
       
       const enableBayesian = args.enable_bayesian !== false && this.bayesianOptimizationEnabled;
@@ -1024,6 +1093,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);
@@ -1101,6 +1171,48 @@ 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." }] };
+    }
+    const deployTarget = args.deploy_target || "claude_code";
+    const payload = {
+      goal: args.goal,
+      deploy_target: deployTarget,
+      platform: deployTarget,
+      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: **${deployTarget}**\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")) {
+        return { content: [{ type: "text", text: `Upgrade required: Deploy target requires Explorer tier. Upgrade at /pricing.` }] };
+      }
+      throw error;
+    }
+  }
+
   _formatSkillPackage(result) {
     const sections = ['# Skill Package Generated'];
     const artifacts = result.artifacts || result.steps || {};
@@ -1146,13 +1258,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.2",
+  "version": "3.3.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,32 @@
     "feature_parity": true,
     "bayesian_support": true,
     "agui_support": true,
-    "last_sync": "2026-05-19T00: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",
+        "intent_frame.perspective steers optimization toward a specific angle or thesis",
+        "intent_frame.out_of_scope excludes topics/approaches from optimization scope",
+        "intent_frame.success_definition defines what a successful output achieves",
+        "Any non-null intent_frame field floors routing to HYBRID tier minimum for higher-quality optimization",
+        "Fixed value_hierarchy passthrough — was sent by client but silently dropped by backend MCP router (now fixed end-to-end)"
+      ],
+      "breaking_changes": [],
+      "migration_guide": "No migration required. intent_frame is fully optional; existing calls are unaffected."
+    },
     "v3.2.2": {
       "major_features": [
         "optimize_prompt now accepts value_hierarchy parameter for constraint-driven optimization",