mcp-prompt-optimizer 3.0.2 → 3.0.3

package/index.js

@@ -5,7 +5,7 @@
  * Production-grade with Bayesian optimization, AG-UI real-time features, enhanced network resilience, 
  * development mode, and complete backend alignment
  * 
- * Version: 2.2.0 - Aligned with FastAPI Backend production-v2.2.0-stable
+ * Version: 3.0.2 - Aligned with FastAPI Backend production-v2.2.0-stable
  */
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -14,6 +14,7 @@ const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontext
 const https = require('https');
 const CloudApiKeyManager = require('./lib/api-key-manager');
 const packageJson = require('./package.json');
+const OPTIMIZATION_TEMPLATES = require('./lib/optimization-templates.json');
 
 const API_KEYS_PREFIX = '/api/v1/api-keys';
 const MCP_PREFIX = '/api/v1/mcp';
@@ -35,9 +36,6 @@ const ENDPOINTS = {
 
     /** Update (PATCH) */
     UPDATE:            (id) => `${MCP_PREFIX}/templates/${id}`,
-
-    /** Delete (DELETE) */
-    DELETE:            (id) => `${MCP_PREFIX}/templates/${id}`,
   },
 
   /** Search templates (GET) — MCP endpoint, API-key auth */
@@ -77,9 +75,9 @@ class MCPPromptOptimizer {
     this.developmentMode = false;
     this.requestTimeout = parseInt(process.env.OPTIMIZER_REQUEST_TIMEOUT) || 30000;
     
-    // NEW: Feature flags aligned with backend
-    this.bayesianOptimizationEnabled = process.env.ENABLE_BAYESIAN_OPTIMIZATION === 'true';
-    this.aguiFeatures = process.env.ENABLE_AGUI_FEATURES === 'true';
+    // Feature flags: enabled by default, set to 'false' to disable
+    this.bayesianOptimizationEnabled = process.env.ENABLE_BAYESIAN_OPTIMIZATION !== 'false';
+    this.aguiFeatures = process.env.ENABLE_AGUI_FEATURES !== 'false';
     
     this.setupMCPHandlers();
   }
@@ -208,11 +206,16 @@ class MCPPromptOptimizer {
                 type: "string",
                 description: "Filter by optimization strategy used"
               },
-              limit: { 
-                type: "number", 
+              limit: {
+                type: "number",
                 default: 5,
                 description: "Number of templates to return (1-20)"
               },
+              page: {
+                type: "number",
+                default: 1,
+                description: "Page number for pagination (use with limit to access results beyond the first page)"
+              },
               sort_by: {
                 type: "string",
                 enum: ["created_at", "confidence_score", "usage_count", "title"],
@@ -228,6 +231,20 @@ class MCPPromptOptimizer {
             }
           }
         },
+        {
+          name: "list_recent_templates",
+          description: "📋 List your most recently saved optimization templates, sorted by creation date.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              limit: {
+                type: "number",
+                default: 10,
+                description: "Number of recent templates to return (1-20)"
+              }
+            }
+          }
+        },
         {
           name: "detect_ai_context",
           description: "🧠 Detects the AI context for a given prompt using advanced backend analysis.",
@@ -287,6 +304,7 @@ class MCPPromptOptimizer {
           case "optimize_prompt": return await this.handleOptimizePrompt(args);
           case "get_quota_status": return await this.handleGetQuotaStatus();
           case "search_templates": return await this.handleSearchTemplates(args);
+          case "list_recent_templates": return await this.handleListRecentTemplates(args);
           case "detect_ai_context": return await this.handleDetectAIContext(args);
           case "create_template": return await this.handleCreateTemplate(args);
           case "get_template": return await this.handleGetTemplate(args);
@@ -301,11 +319,185 @@ class MCPPromptOptimizer {
     });
   }
 
+  // ─── Rules-Based Optimization (offline / fallback tier) ─────────────────────
+
+  /**
+   * Select the best-matching template for a prompt using pattern scoring.
+   * Mirrors the backend's pattern-based fallback (no LLM required).
+   */
+  _matchTemplate(prompt, backendContext) {
+    const lc = prompt.toLowerCase();
+    let bestTemplate = null;
+    let bestScore = 0;
+    let fallbackName = null;
+
+    for (const [name, template] of Object.entries(OPTIMIZATION_TEMPLATES)) {
+      if (template.context !== backendContext) continue;
+      if (name.startsWith('fallback_')) { fallbackName = name; continue; }
+
+      let hits = 0;
+      for (const pattern of template.patterns) {
+        if (pattern === '.*') continue;
+        if (lc.includes(pattern.toLowerCase())) hits++;
+      }
+      if (hits === 0) continue;
+
+      // Confidence: 1 hit → 0.6, 2 hits → 0.75, 3+ hits → 0.9 (mirrors backend)
+      const patternConf = hits === 1 ? 0.6 : hits === 2 ? 0.75 : 0.9;
+      const score = patternConf + (template.priority || 1) / 100;
+
+      if (score > bestScore) { bestScore = score; bestTemplate = name; }
+    }
+
+    if (!bestTemplate) {
+      return { templateName: fallbackName || `fallback_${backendContext.toLowerCase()}`, matchConfidence: 0.3 };
+    }
+    return { templateName: bestTemplate, matchConfidence: bestScore };
+  }
+
+  /** Extract a user-defined role from the start of a prompt (e.g. "As a doctor, …"). */
+  _extractUserRole(request) {
+    const rolePatterns = [
+      /^['"]?(?:As a|You are a|My role is)\s+([a-zA-Z0-9\s\-/()]+?)(?:,|(?=\s*\.))/i,
+      /^['"]?(?:I am a|I'm a)\s+([a-zA-Z0-9\s\-/()]+?)(?:,|(?=\s*\.))/i,
+    ];
+    for (const re of rolePatterns) {
+      const m = request.match(re);
+      if (m) return m[1].trim();
+    }
+    return null;
+  }
+
+  /**
+   * Compile a template playbook into a user-facing prose prompt.
+   * Produces readable output instead of XML scaffolding, matching the
+   * result a backend LLM pass would generate from the same playbook.
+   */
+  _compilePlaybook(playbook, originalRequest) {
+    const parts = [];
+
+    parts.push(originalRequest.trim());
+    parts.push('');
+
+    const userFacingPrinciples = (playbook.principles || []).filter(p => {
+      const lc = p.toLowerCase();
+      return !lc.includes('scratchpad') &&
+             !lc.startsWith('first, think') &&
+             !/<[a-z]/i.test(p);
+    });
+
+    if (userFacingPrinciples.length > 0) {
+      parts.push('To address this effectively:');
+      for (const p of userFacingPrinciples) parts.push(`- ${p}`);
+      parts.push('');
+    }
+
+    if (playbook.output_format) {
+      parts.push(`*Response format: ${playbook.output_format}*`);
+    }
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Enhance an image generation prompt by appending style-appropriate
+   * quality/composition boosters (mirrors backend _compile_image_prompt_fallback).
+   */
+  _compileImagePrompt(originalRequest) {
+    const text = originalRequest.trim();
+    const lc = text.toLowerCase();
+
+    const styles = {
+      photorealistic: ['photorealistic','realistic','photo','photograph','photography'],
+      '3d_render':    ['3d','render','octane','unreal engine','blender','cinema 4d','ray tracing'],
+      cinematic:      ['cinematic','movie','film','dramatic','epic'],
+      digital_art:    ['digital art','concept art','digital illustration','cg','cgi'],
+      artistic:       ['artistic','painting','watercolor','oil painting','impressionist'],
+      anime:          ['anime','manga'],
+      vintage:        ['vintage','retro','nostalgic'],
+      minimalist:     ['minimalist','minimal','simple','clean'],
+    };
+
+    let detectedStyle = null;
+    for (const [style, kws] of Object.entries(styles)) {
+      if (kws.some(kw => lc.includes(kw))) { detectedStyle = style; break; }
+    }
+
+    const enhancements = [];
+    const hasQuality = ['high quality','8k','4k','hd','highly detailed','detailed'].some(t => lc.includes(t));
+    const hasLighting = ['lighting','light','shadow','illuminated','lit'].some(t => lc.includes(t));
+    const hasComposition = ['composition','rule of thirds','centered','framed'].some(t => lc.includes(t));
+
+    if (detectedStyle === 'photorealistic' && !hasQuality) {
+      enhancements.push('ultra realistic, sharp focus, professional photography');
+    } else if (detectedStyle === '3d_render' && !['octane','render'].some(t => lc.includes(t))) {
+      enhancements.push('high quality 3D render, volumetric lighting, ray traced shadows');
+    } else if (detectedStyle === 'cinematic' && !hasLighting) {
+      enhancements.push('cinematic lighting, dramatic atmosphere, film grain');
+    } else if (detectedStyle === 'digital_art' && !hasQuality) {
+      enhancements.push('highly detailed digital art, professional illustration');
+    } else if (detectedStyle === 'artistic' && !lc.includes('masterpiece')) {
+      enhancements.push('masterful technique, rich colors, artistic composition');
+    }
+
+    if (!hasLighting && detectedStyle !== 'minimalist') enhancements.push('dynamic lighting');
+    if (!hasComposition) enhancements.push('balanced composition');
+    if (!hasQuality) enhancements.push('high quality, 4K');
+
+    return enhancements.length > 0 ? `${text}, ${enhancements.join(', ')}` : text;
+  }
+
+  /**
+   * Core rules-based optimizer — no network, no LLM.
+   * Selects the best template by pattern matching, then compiles
+   * the playbook into a structured prompt. Confidence range: 0.35–0.55.
+   */
+  rulesBasedOptimize(prompt, aiContext, goals = []) {
+    const contextMap = {
+      code_generation:      'CODE_GENERATION',
+      llm_interaction:      'LLM_INTERACTION',
+      image_generation:     'IMAGE_GENERATION',
+      human_communication:  'HUMAN_COMMUNICATION',
+      api_automation:       'API_AUTOMATION',
+      technical_automation: 'TECHNICAL_AUTOMATION',
+      structured_output:    'STRUCTURED_OUTPUT',
+      creative_enhancement: 'CREATIVE_ENHANCEMENT',
+      creative_writing:     'CREATIVE_ENHANCEMENT',
+      general_assistant:    'LLM_INTERACTION',
+    };
+    const backendContext = contextMap[aiContext] || 'LLM_INTERACTION';
+
+    const { templateName, matchConfidence } = this._matchTemplate(prompt, backendContext);
+    const template = OPTIMIZATION_TEMPLATES[templateName];
+
+    const optimizedPrompt = backendContext === 'IMAGE_GENERATION'
+      ? this._compileImagePrompt(prompt)
+      : this._compilePlaybook(template.playbook, prompt);
+
+    // Honest confidence: rules-based tops out around 0.55
+    const confidence = parseFloat(Math.min(0.35 + matchConfidence * 0.2, 0.55).toFixed(2));
+
+    return {
+      optimized_prompt: optimizedPrompt,
+      confidence_score: confidence,
+      tier: 'rules',
+      template_used: templateName,
+      rules_based: true,
+      template_saved: false,
+      templates_found: [],
+      optimization_insights: null,
+      bayesian_insights: null,
+    };
+  }
+
+  // ─── End Rules-Based Optimization ────────────────────────────────────────────
+
   generateMockOptimization(prompt, goals, aiContext, enableBayesian = false) {
-    const optimized_prompt = `Enhanced for ${aiContext}: ${prompt}`;
+    // Use real rules-based optimization instead of fake placeholder output
+    const rulesResult = this.rulesBasedOptimize(prompt, aiContext, goals);
     const baseResult = {
-      optimized_prompt,
-      confidence_score: 0.87,
+      ...rulesResult,
+      rules_based: false,  // Show as normal optimized output in mock mode
       tier: 'explorer',
       mock_mode: true,
       template_saved: true,
@@ -381,7 +573,7 @@ class MCPPromptOptimizer {
       secondary_contexts: ['llm_interaction'],
       detected_parameters: [],
       mock_mode: true,
-      reason: 'Running in development/fallback mode.'
+      reason: 'Backend unavailable — using local pattern matching as fallback.'
     };
   }
 
@@ -432,7 +624,7 @@ class MCPPromptOptimizer {
       if (error.message.includes('Network') || error.message.includes('DNS') || error.message.includes('timeout') || error.message.includes('Connection')) {
         const fallbackContext = args.ai_context || 'human_communication';
         const fallbackEnableBayesian = args.enable_bayesian !== false && this.bayesianOptimizationEnabled;
-        const fallbackResult = this.generateMockOptimization(args.prompt, args.goals || ['clarity'], fallbackContext, fallbackEnableBayesian);
+        const fallbackResult = this.rulesBasedOptimize(args.prompt, fallbackContext, args.goals || ['clarity']);
         fallbackResult.fallback_mode = true;
         fallbackResult.error_reason = error.message;
         const formatted = this.formatOptimizationResult(fallbackResult, { detectedContext: fallbackContext, enableBayesian: fallbackEnableBayesian });
@@ -451,7 +643,7 @@ class MCPPromptOptimizer {
   async handleSearchTemplates(args) {
     try {
       const params = new URLSearchParams({
-        page: '1',
+        page: (args.page || 1).toString(),
         per_page: Math.min(args.limit || 5, 20).toString(),
         sort_by: args.sort_by || 'confidence_score',
         sort_order: args.sort_order || 'desc'
@@ -492,6 +684,49 @@ class MCPPromptOptimizer {
     }
   }
 
+  async handleListRecentTemplates(args) {
+    try {
+      const limit = Math.min(Math.max(args.limit || 10, 1), 20);
+      const params = new URLSearchParams({
+        page: '1',
+        per_page: limit.toString(),
+        sort_by: 'created_at',
+        sort_order: 'desc'
+      });
+
+      const endpoint = `${ENDPOINTS.SEARCH_TEMPLATES}?${params.toString()}`;
+      const result = await this.callBackendAPI(endpoint, null, 'GET');
+
+      const templates = result.templates || [];
+      let output = `# 📋 Recent Templates\n\n`;
+      output += `Showing **${templates.length}** most recently saved template(s).\n\n`;
+
+      if (templates.length === 0) {
+        output += `📭 No templates found yet.\nRun \`optimize_prompt\` to start building your template library.\n`;
+      } else {
+        output += `## 📋 **Template Results**\n`;
+        templates.forEach((t, index) => {
+          const confidence = t.confidence_score ? `${(t.confidence_score * 100).toFixed(1)}%` : 'N/A';
+          const preview = t.optimized_prompt ? t.optimized_prompt.substring(0, 60) + '...' : 'Preview unavailable';
+          output += `### ${index + 1}. ${t.title}\n`;
+          output += `- **Confidence:** ${confidence}\n`;
+          output += `- **ID:** \`${t.id}\`\n`;
+          output += `- **Preview:** ${preview}\n`;
+          if (t.ai_context) output += `- **Context:** ${t.ai_context}\n`;
+          if (t.optimization_goals && t.optimization_goals.length) {
+            output += `- **Goals:** ${t.optimization_goals.join(', ')}\n`;
+          }
+          output += `\n`;
+        });
+        output += `💡 Use \`get_template\` with an ID above to view the full optimized prompt.\n`;
+      }
+
+      return { content: [{ type: "text", text: output }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `❌ Could not retrieve recent templates: ${error.message}` }] };
+    }
+  }
+
   async handleGetOptimizationInsights(args) {
     if (!this.bayesianOptimizationEnabled) {
       return { content: [{ type: "text", text: "🧠 Bayesian optimization features are not enabled. Set ENABLE_BAYESIAN_OPTIMIZATION=true to access advanced insights." }] };
@@ -607,6 +842,18 @@ class MCPPromptOptimizer {
   }
 
   async handleCreateTemplate(args) {
+    // Client-side validation before network call
+    const requiredStrings = ['title', 'original_prompt', 'optimized_prompt'];
+    for (const field of requiredStrings) {
+      if (!args[field] || typeof args[field] !== 'string' || args[field].trim() === '') {
+        return { content: [{ type: "text", text: `❌ Missing required field: '${field}'. Required fields: title, original_prompt, optimized_prompt, confidence_score (0.0–1.0)` }] };
+      }
+    }
+    if (args.confidence_score === undefined || args.confidence_score === null ||
+        typeof args.confidence_score !== 'number' || args.confidence_score < 0 || args.confidence_score > 1) {
+      return { content: [{ type: "text", text: `❌ Missing required field: 'confidence_score'. Required fields: title, original_prompt, optimized_prompt, confidence_score (0.0–1.0)` }] };
+    }
+
     try {
       const result = await this.callBackendAPI(ENDPOINTS.TEMPLATE.CREATE, args);
       let output = `# ✅ Template Created Successfully!\n\n`;
@@ -638,6 +885,10 @@ class MCPPromptOptimizer {
       output += `**Optimized Prompt:**\n\`\`\`\n${result.optimized_prompt}\n\`\`\`\n`;
       return { content: [{ type: "text", text: output }] };
     } catch (error) {
+      const msg = error.message || '';
+      if (msg.includes('404') || msg.toLowerCase().includes('not found')) {
+        throw new Error(`Template \`${args.template_id}\` not found. It may have been deleted or the ID is incorrect. Use \`search_templates\` to find available templates.`);
+      }
       throw new Error(`Failed to retrieve template: ${error.message}`);
     }
   }
@@ -736,8 +987,37 @@ class MCPPromptOptimizer {
   }
 
   formatOptimizationResult(result, context) {
-    let output = `# 🎯 Optimized Prompt\n\n${result.optimized_prompt}\n\n`;
-    output += `**Confidence:** ${(result.confidence_score * 100).toFixed(1)}%\n`;
+    let output;
+    if (result.rules_based) {
+      if (result.fallback_mode) {
+        output = `# 🔧 Rules-Based Optimization Applied\n\n`;
+        output += `⚠️ *Backend unreachable — your prompt has been structured using local rule templates (no LLM). `;
+        output += `Re-run when the backend is available for full LLM optimization.*\n\n`;
+      } else {
+        output = `# 🔧 Rules-Based Optimization Applied\n\n`;
+        output += `*API key not validated — optimized using local rule templates. `;
+        output += `Set \`MCP_API_KEY\` for full LLM optimization.*\n\n`;
+      }
+      output += `**Template:** \`${result.template_used || 'general'}\`\n\n`;
+      output += `**Optimized Prompt:**\n\`\`\`\n${result.optimized_prompt}\n\`\`\`\n\n`;
+    } else if (result.fallback_mode) {
+      // Legacy path — should no longer be reached
+      output = `# ⚠️ Backend Unavailable — Prompt Not Optimized\n\n`;
+      output += `**Issue:** ${result.error_reason}\n`;
+      output += `The backend could not be reached. Your original prompt is returned below unmodified.\n\n`;
+      output += `**Original Prompt:**\n\`\`\`\n${result.optimized_prompt}\n\`\`\`\n\n`;
+    } else {
+      output = `# 🎯 Optimized Prompt\n\n${result.optimized_prompt}\n\n`;
+      if (result.confidence_score < 0.25) {
+        output += `> ℹ️ *Low confidence indicates the backend applied rules-based optimization (no LLM). `;
+        output += `Ensure \`OPENROUTER_API_KEY\` is configured in the backend for full LLM enhancement.*\n\n`;
+      }
+    }
+    if (result.rules_based) {
+      output += `**Confidence:** ${(result.confidence_score * 100).toFixed(1)}% *(rules-based — LLM optimization typically 70–95%)*\n`;
+    } else {
+      output += `**Confidence:** ${(result.confidence_score * 100).toFixed(1)}%\n`;
+    }
     output += `**AI Context:** ${context.detectedContext}\n`;
     
     if (result.template_saved) {
@@ -747,8 +1027,9 @@ class MCPPromptOptimizer {
     if (result.templates_found?.length) {
       output += `\n📋 **Similar Templates Found**\nFound **${result.templates_found.length}** similar template(s):\n`;
       result.templates_found.slice(0, 3).forEach(t => {
-        output += `- ${t.title} (${(t.confidence_score * 100).toFixed(1)}% match)\n`;
+        output += `- ${t.title} (${(t.confidence_score * 100).toFixed(1)}% match) — ID: \`${t.id}\`\n`;
       });
+      output += `\n💡 Use \`get_template\` with any ID above to view the full optimized prompt.\n`;
     }
     
     if (result.optimization_insights) {
@@ -796,12 +1077,10 @@ class MCPPromptOptimizer {
       }
     }
     
-    if (result.fallback_mode) {
-      output += `\n⚠️ **Fallback Mode Active**\n**Issue:** ${result.error_reason}\n`;
+    if (!result.fallback_mode) {
+      output += `\n🔗 **Quick Actions**\n- Dashboard: https://promptoptimizer-blog.vercel.app/dashboard\n- Analytics: https://promptoptimizer-blog.vercel.app/analytics\n`;
     }
     
-    output += `\n🔗 **Quick Actions**\n- Dashboard: https://promptoptimizer-blog.vercel.app/dashboard\n- Analytics: https://promptoptimizer-blog.vercel.app/analytics\n`;
-    
     return output;
   }
 
@@ -821,6 +1100,17 @@ class MCPPromptOptimizer {
       else if (percentage >= 75) statusIcon = '🟡';
       
       output += `**Usage:** ${statusIcon} ${used}/${limit} (${percentage}%)\n`;
+
+      const remaining = limit - used;
+      if (remaining <= 0) {
+        output += `\n❌ **Quota Exhausted** — You have no optimizations remaining this month.\n`;
+        output += `Upgrade at https://promptoptimizer-blog.vercel.app/pricing\n`;
+        output += `*(Quota resets at the start of your next billing cycle)*\n`;
+      } else if (percentage >= 90) {
+        output += `\n⚠️ **Critical** — ${remaining} optimization${remaining === 1 ? '' : 's'} remaining. Upgrade at https://promptoptimizer-blog.vercel.app/pricing\n`;
+      } else if (percentage >= 75) {
+        output += `\n⚠️ **Warning** — Approaching your monthly limit.\n`;
+      }
     }
 
     output += `\n## ✨ **Available Features**\n`;
@@ -865,10 +1155,12 @@ class MCPPromptOptimizer {
     
     if (!result.templates || result.templates.length === 0) {
       output += `📭 **No Templates Found**\n`;
-      if (originalArgs.query) {
-        output += `Try searching with different keywords or remove filters.\n`;
+      const hasActiveFilters = originalArgs.query || originalArgs.ai_context || originalArgs.sophistication_level || originalArgs.complexity_level;
+      if (hasActiveFilters) {
+        output += `No templates matched your filters. Try removing \`ai_context\` or \`query\` filters.\n`;
       } else {
         output += `You don't have any saved templates yet. Templates are automatically saved when optimization confidence is >70%.\n`;
+        output += `Run \`optimize_prompt\` to start building your template library.\n`;
       }
     } else {
       output += `## 📋 **Template Results**\n`;

package/lib/api-key-manager.js

@@ -488,7 +488,7 @@ class CloudApiKeyManager {
 
         try {
             // Step 1: Validate API key
-            const validation = await this.validateApiKey();
+            let validation = await this.validateApiKey();
             
             // Step 2: Get comprehensive quota status
             const info = await this.getApiKeyInfo();

package/lib/optimization-templates.json

@@ -0,0 +1,466 @@
+{
+  "debugging_request": {
+    "context": "CODE_GENERATION",
+    "patterns": ["debug","fix","error","bug","troubleshoot","problem","issue","crash","failing","not working"],
+    "priority": 5,
+    "playbook": {
+      "persona": "You are an expert software engineer specializing in root cause analysis. Your goal is to help the user methodically debug their code.",
+      "instruction": "Analyze the following debugging request and provide a comprehensive diagnostic framework to help resolve the issue.",
+      "principles": [
+        "Identify the most likely root causes given the error description.",
+        "Request the full error message and stack trace, plus the relevant code snippet.",
+        "Ask about expected vs. actual behavior, programming language, and library versions."
+      ],
+      "examples": [
+        "Input: 'My python script is not working.'\nEnhanced: 'My Python script is not working and I need help debugging it. Please identify likely root causes, request the full error message and relevant code snippet, and ask about expected vs. actual behavior and library versions.'"
+      ],
+      "anti_patterns": [
+        "Do not provide a solution without understanding the root cause.",
+        "Avoid guessing the user's programming language or environment."
+      ],
+      "output_format": "Step-by-step debugging walkthrough with a specific fix or next diagnostic steps."
+    }
+  },
+  "code_review_request": {
+    "context": "CODE_GENERATION",
+    "patterns": ["review","code review","pull request","pr review","critique","feedback on code","check my code"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a senior software engineer conducting a thorough code review.",
+      "instruction": "Analyze the provided code and deliver a structured code review covering correctness, performance, security, and maintainability.",
+      "principles": [
+        "Identify bugs, security vulnerabilities, and performance issues.",
+        "Suggest specific improvements with code examples.",
+        "Acknowledge good patterns and practices.",
+        "Prioritize issues by severity."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not provide vague feedback like 'looks good'",
+        "Do not focus only on style issues while ignoring logic errors"
+      ],
+      "output_format": "Structured review with sections: Summary, Critical Issues, Suggestions, Positive Aspects."
+    }
+  },
+  "software_engineering": {
+    "context": "CODE_GENERATION",
+    "patterns": ["backend","back-end","fullstack","full-stack","server","database","algorithm","architecture","design pattern","api","microservice","class","function","module","python","java","go","rust","sql","system design","scalability","performance","refactor","test","unit test"],
+    "priority": 5,
+    "playbook": {
+      "persona": "You are a senior software engineer and system architect specialized in building scalable, efficient, and clean software solutions.",
+      "instruction": "Design or implement the requested software solution focusing on clean code, architectural best practices, and performance.",
+      "principles": [
+        "Apply SOLID principles and clean code practices.",
+        "Prioritize scalability, maintainability, and performance.",
+        "Include proper error handling and logging.",
+        "Address security implications in the design.",
+        "Include tests and documentation."
+      ],
+      "examples": [
+        "Input: 'Design a user authentication system'\nEnhanced: 'Design a secure and scalable user authentication system including: database schema for users and roles, API endpoints for login/register, JWT token management, password hashing strategy (Argon2/bcrypt), and security considerations (rate limiting, validation).'",
+        "Input: 'Optimize this python function'\nEnhanced: 'Analyze and optimize the provided Python function for time and space complexity, using appropriate algorithms and data structures, and validating correctness with unit tests.'"
+      ],
+      "anti_patterns": [
+        "Do not overengineer simple solutions.",
+        "Do not ignore edge cases or error handling.",
+        "Do not write spaghetti code or monolithic functions."
+      ],
+      "output_format": "Well-structured code with architectural explanation and design rationale."
+    }
+  },
+  "web_development": {
+    "context": "CODE_GENERATION",
+    "patterns": ["landing page","web page","website","webpage","homepage","home page","hero section","navbar","nav bar","navigation","frontend","front-end","responsive","mobile-first","component","layout","react","vue","angular","svelte","next.js","tailwind","bootstrap","css","html","form","modal","accessibility","a11y"],
+    "priority": 5,
+    "playbook": {
+      "persona": "You are a senior frontend developer and UI/UX expert specializing in modern web development frameworks and responsive design.",
+      "instruction": "Help the user create or enhance their web development project with clean, modern, and accessible code following best practices.",
+      "principles": [
+        "Use semantic HTML and modern CSS practices (flexbox, grid, custom properties).",
+        "Ensure responsive design with a mobile-first approach.",
+        "Follow accessibility guidelines (WCAG 2.1 AA compliance).",
+        "Apply framework patterns and conventions appropriate to the specified stack.",
+        "Include SEO best practices where relevant.",
+        "Structure code for maintainability and scalability."
+      ],
+      "examples": [
+        "Input: 'Help me create a landing page'\nEnhanced: 'Create a modern, responsive landing page with: a compelling hero section with headline and CTA, navigation bar with smooth scroll, feature highlights section with icons and descriptions, social proof/testimonials, clear call-to-action sections, and a footer with links. Use semantic HTML5, modern CSS (flexbox/grid), and ensure mobile responsiveness and accessibility.'"
+      ],
+      "anti_patterns": [
+        "Do not use deprecated HTML elements or inline styles.",
+        "Do not ignore mobile responsiveness.",
+        "Do not sacrifice accessibility for aesthetics.",
+        "Do not use excessive JavaScript where CSS would suffice."
+      ],
+      "output_format": "Complete implementation with component structure, code, and accessibility notes."
+    }
+  },
+  "fallback_code_generation": {
+    "context": "CODE_GENERATION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a helpful AI assistant and expert software engineer.",
+      "instruction": "Provide a high-quality, well-structured code solution based on the user's request. Include explanations and usage examples.",
+      "principles": [
+        "Infer the most likely programming language if not specified.",
+        "Focus on clarity, correctness, and best practices.",
+        "Include error handling and edge cases.",
+        "Add comments explaining non-obvious logic."
+      ],
+      "examples": [],
+      "anti_patterns": [],
+      "output_format": "Well-structured code with inline comments and a brief usage example."
+    }
+  },
+  "analysis_request": {
+    "context": "LLM_INTERACTION",
+    "patterns": ["analyze","analysis","examine","evaluate","explain","compare","contrast","research","investigate"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a world-class research analyst. Your responses are always objective, evidence-based, and deeply insightful.",
+      "instruction": "Provide a comprehensive, structured analysis of the user's request. Adhere strictly to the requested output format.",
+      "principles": [
+        "Restate the core question to confirm understanding.",
+        "Clearly separate findings from conclusions.",
+        "Support all claims with evidence or reasoning."
+      ],
+      "examples": [
+        "User Request: 'Explain the difference between GPT-3 and GPT-4.'\nStructured Analysis:\n## 1. Core Question\nThe user wants to understand the key differences between the GPT-3 and GPT-4 language models.\n## 2. Analysis\n- **Architecture:** GPT-4 has a significantly larger parameter count...\n- **Capabilities:** GPT-4 demonstrates superior reasoning..."
+      ],
+      "anti_patterns": [
+        "Do not give opinions without supporting evidence.",
+        "Do not provide an unstructured wall of text."
+      ],
+      "output_format": "Markdown with clear headings: ## Core Question, ## Analysis, ## Conclusion."
+    }
+  },
+  "translation_request": {
+    "context": "LLM_INTERACTION",
+    "patterns": ["translate","translation","in spanish","in french","in german","in chinese","in japanese","to english","how do you say"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a professional translator fluent in multiple languages with expertise in cultural nuance.",
+      "instruction": "Provide an accurate translation preserving meaning, tone, and cultural context.",
+      "principles": [
+        "Preserve the original meaning and intent precisely.",
+        "Adapt idioms and cultural references appropriately.",
+        "Maintain the formality level of the original.",
+        "Note any terms that do not translate directly."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not provide literal word-for-word translations that lose meaning",
+        "Do not ignore cultural context"
+      ],
+      "output_format": "Translation followed by brief notes on any cultural adaptations made."
+    }
+  },
+  "business_plan_comprehensive": {
+    "context": "LLM_INTERACTION",
+    "patterns": ["business plan","startup","venture","market analysis","pitch","business model","strategy"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a seasoned venture capitalist and business strategist.",
+      "instruction": "Provide a comprehensive business plan framework based on the user's request.",
+      "principles": [
+        "Structure the plan with Executive Summary, Company Description, Market Analysis, and Financial Projections.",
+        "Define the value proposition, target market, and competitive advantage.",
+        "Include key market sizing metrics (TAM, SAM, SOM)."
+      ],
+      "examples": [],
+      "anti_patterns": [],
+      "output_format": "Standard business plan document structure in Markdown."
+    }
+  },
+  "fallback_llm_interaction": {
+    "context": "LLM_INTERACTION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a helpful AI assistant with broad expertise.",
+      "instruction": "Provide a comprehensive, well-structured response based on the user's request.",
+      "principles": [
+        "Infer the user's goal and provide a relevant, structured answer.",
+        "Focus on clarity, completeness, and helpfulness.",
+        "Use appropriate structure (lists, headings, examples) for the content type."
+      ],
+      "examples": [],
+      "anti_patterns": [],
+      "output_format": "A well-structured, informative response."
+    }
+  },
+  "image_creation": {
+    "context": "IMAGE_GENERATION",
+    "patterns": ["image","picture","draw","visual","render","3d","photorealistic","realistic","photo","photograph","illustration","artwork","art","design","graphic","scene","portrait","landscape","cinematic","concept art","digital art","oil painting","watercolor","futuristic","stylized","aesthetic","lighting","midjourney","dall-e","stable diffusion","anime","cartoon","sketch","surreal","abstract","minimalist","vintage","retro"],
+    "priority": 5,
+    "playbook": {
+      "persona": "You are an expert prompt engineer specializing in AI image generation.",
+      "instruction": "Transform the user's image request into an optimized, detailed prompt that will produce high-quality results.",
+      "principles": [
+        "Preserve the core creative intent while adding technical precision.",
+        "Structure the prompt with subject first, then style, then technical details.",
+        "Add quality boosters appropriate for the detected style.",
+        "Include lighting, composition, and atmosphere details when not specified.",
+        "Avoid conflicting style descriptors."
+      ],
+      "examples": [
+        "Input: 'A cat sitting on a windowsill'\nOutput: 'A fluffy orange tabby cat sitting peacefully on a sunlit wooden windowsill, warm afternoon light streaming through sheer curtains, soft bokeh background, photorealistic, high detail, 4K quality'",
+        "Input: 'Futuristic city'\nOutput: 'Sprawling futuristic metropolis at dusk, towering chrome skyscrapers with holographic advertisements, flying vehicles, neon lights reflecting on wet streets, cyberpunk aesthetic, cinematic composition, volumetric lighting, ultra detailed, 8K'"
+      ],
+      "anti_patterns": [
+        "Do not wrap the output in XML tags or meta-instructions.",
+        "Do not add explanatory text - output only the enhanced prompt.",
+        "Do not add conflicting style descriptors."
+      ],
+      "output_format": "A single, enhanced image generation prompt ready for direct use."
+    }
+  },
+  "fallback_image_generation": {
+    "context": "IMAGE_GENERATION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are an expert AI image prompt engineer.",
+      "instruction": "Enhance this image generation request with additional visual details, style specifications, and quality modifiers.",
+      "principles": [
+        "Add specific visual details: lighting, composition, perspective.",
+        "Include style descriptors that match the apparent intent.",
+        "Add quality boosters: high detail, professional, 4K/8K where appropriate.",
+        "Preserve all original creative elements while enhancing clarity."
+      ],
+      "examples": [
+        "Input: 'Mountain landscape'\nOutput: 'Majestic snow-capped mountain range at golden hour, dramatic clouds, pine forest in foreground, crystal clear alpine lake reflecting peaks, landscape photography, ultra sharp, high dynamic range, 8K resolution'"
+      ],
+      "anti_patterns": [
+        "Do not wrap output in XML tags.",
+        "Do not change the core subject or intent."
+      ],
+      "output_format": "A single enhanced image prompt ready for direct use."
+    }
+  },
+  "email_composition": {
+    "context": "HUMAN_COMMUNICATION",
+    "patterns": ["email","e-mail","mail","letter","message","correspondence","memo","memorandum","reply","respond","write to","dear","regards","sincerely","professional","formal","informal","business","thank you","follow up","introduction","invitation","request","complaint","apology"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are an expert business communication specialist.",
+      "instruction": "Help craft clear, effective written communication tailored to the context and audience.",
+      "principles": [
+        "Use an appropriate tone for the relationship and context (formal, professional, or informal).",
+        "Structure the message with a clear opening, body, and closing.",
+        "Make the key message and any required action prominent.",
+        "Keep the message concise and unambiguous."
+      ],
+      "examples": [
+        "Input: 'Write an email to my boss about needing time off'\nEnhanced: 'Compose a professional email requesting time off that includes: specific dates, reason (optional level of detail), coverage plan for responsibilities, and a polite closing that invites discussion.'"
+      ],
+      "anti_patterns": [
+        "Do not use overly casual language in professional contexts.",
+        "Do not make the message longer than necessary.",
+        "Avoid vague or ambiguous requests."
+      ],
+      "output_format": "A complete, ready-to-send message with subject line and body."
+    }
+  },
+  "fallback_human_communication": {
+    "context": "HUMAN_COMMUNICATION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a communication specialist helping craft effective messages.",
+      "instruction": "Enhance this communication request to be clearer, more effective, and appropriately structured for its intended audience.",
+      "principles": [
+        "Use an appropriate tone and formality level for the audience.",
+        "Structure the message for clarity and impact.",
+        "Include all necessary context and action items."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not use jargon unless appropriate for the audience.",
+        "Avoid ambiguous language that could be misinterpreted."
+      ],
+      "output_format": "A clear, well-structured message ready to send or adapt."
+    }
+  },
+  "api_integration": {
+    "context": "API_AUTOMATION",
+    "patterns": ["api","endpoint","rest","restful","graphql","http","https","webhook","authentication","oauth","bearer","token","header","payload","status code","curl","fetch","swagger","openapi","postman","integration","microservice"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a senior API architect with expertise in RESTful services and integration patterns.",
+      "instruction": "Provide comprehensive guidance on API design, implementation, or integration based on the user's request.",
+      "principles": [
+        "Follow REST best practices and HTTP standards.",
+        "Include proper error handling and status codes.",
+        "Address authentication, authorization, and security.",
+        "Provide clear request and response examples."
+      ],
+      "examples": [
+        "Input: 'Create an API for user authentication'\nEnhanced: 'Design a secure REST API for user authentication including: POST /auth/login endpoint, JWT token generation, refresh token mechanism, proper HTTP status codes (200, 401, 403), rate limiting considerations, and example request/response payloads.'"
+      ],
+      "anti_patterns": [
+        "Do not ignore security considerations.",
+        "Do not use non-standard HTTP methods inappropriately.",
+        "Avoid exposing sensitive data in URLs or responses."
+      ],
+      "output_format": "Structured API specification with endpoints, methods, payloads, and examples."
+    }
+  },
+  "fallback_api_automation": {
+    "context": "API_AUTOMATION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are an API development specialist.",
+      "instruction": "Enhance this API-related request with best practices for design, implementation, or integration.",
+      "principles": [
+        "Follow RESTful conventions and HTTP standards.",
+        "Include error handling and appropriate status codes.",
+        "Address security and authentication requirements.",
+        "Provide clear examples of requests and responses."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not ignore security best practices.",
+        "Do not use inconsistent naming conventions."
+      ],
+      "output_format": "API design with endpoints, methods, and annotated examples."
+    }
+  },
+  "automation_script": {
+    "context": "TECHNICAL_AUTOMATION",
+    "patterns": ["automate","automation","script","bash","shell","powershell","deploy","deployment","ci/cd","pipeline","workflow","docker","kubernetes","k8s","ansible","terraform","helm","jenkins","github actions","gitlab ci","aws","azure","gcp","cron","scheduled","batch","infrastructure","devops","monitoring","logging","alerting"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a DevOps engineer and automation specialist with expertise in infrastructure as code.",
+      "instruction": "Provide comprehensive automation solutions including scripts, pipelines, or infrastructure configurations.",
+      "principles": [
+        "Follow infrastructure as code best practices.",
+        "Include error handling and rollback mechanisms.",
+        "Ensure idempotency and reproducibility.",
+        "Document configuration and dependencies clearly."
+      ],
+      "examples": [
+        "Input: 'Automate deployment to AWS'\nEnhanced: 'Create a CI/CD pipeline for AWS deployment including: GitHub Actions workflow, Docker container build, ECR push, ECS/EKS deployment, environment variable management, health checks, rollback strategy, and notification on success/failure.'"
+      ],
+      "anti_patterns": [
+        "Do not hardcode secrets or credentials.",
+        "Do not skip error handling in scripts.",
+        "Avoid manual steps in automated workflows."
+      ],
+      "output_format": "Complete automation scripts or pipeline configuration with inline documentation."
+    }
+  },
+  "fallback_technical_automation": {
+    "context": "TECHNICAL_AUTOMATION",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a technical automation specialist.",
+      "instruction": "Enhance this automation request with best practices for scripting, deployment, or infrastructure management.",
+      "principles": [
+        "Follow infrastructure as code principles.",
+        "Include proper error handling and logging.",
+        "Address security and credential management.",
+        "Ensure reproducibility and idempotency."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not hardcode sensitive values.",
+        "Do not skip testing automation scripts."
+      ],
+      "output_format": "Automation script or configuration with error handling and documentation."
+    }
+  },
+  "data_formatting": {
+    "context": "STRUCTURED_OUTPUT",
+    "patterns": ["json","xml","csv","yaml","toml","format","structure","schema","table","chart","report","parse","extract","transform","convert","serialize","deserialize","spreadsheet","database","export","import","data","output"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are a data engineer specializing in data transformation and structured output formats.",
+      "instruction": "Help design or implement structured data formats, schemas, or transformations based on the requirements.",
+      "principles": [
+        "Choose the appropriate data format for the use case.",
+        "Define a clear schema with proper data types.",
+        "Handle edge cases such as null values and special characters.",
+        "Include validation rules and error handling."
+      ],
+      "examples": [
+        "Input: 'Create a JSON schema for user data'\nEnhanced: 'Design a JSON schema for user data including: required fields (id, email, name), optional fields (phone, address), proper data types and formats, validation rules (email format, string lengths), and example valid/invalid payloads.'"
+      ],
+      "anti_patterns": [
+        "Do not use ambiguous field names.",
+        "Do not skip validation rules.",
+        "Avoid deeply nested structures when flat would work."
+      ],
+      "output_format": "Schema definition with example data, validation rules, and transformation logic."
+    }
+  },
+  "fallback_structured_output": {
+    "context": "STRUCTURED_OUTPUT",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a data formatting specialist.",
+      "instruction": "Enhance this data or formatting request with appropriate structure, schema design, and best practices.",
+      "principles": [
+        "Use the appropriate data format for the use case.",
+        "Define a clear, consistent schema.",
+        "Handle edge cases and include validation.",
+        "Provide clear examples."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not use inconsistent naming conventions.",
+        "Avoid overly complex nested structures."
+      ],
+      "output_format": "Well-defined data structure or schema with examples."
+    }
+  },
+  "creative_writing": {
+    "context": "CREATIVE_ENHANCEMENT",
+    "patterns": ["story","narrative","tale","fiction","novel","short story","poem","poetry","verse","sonnet","haiku","creative writing","storytelling","character","plot","dialogue","marketing","campaign","ad copy","tagline","slogan","brand","copywriting","content","blog","article","script","screenplay"],
+    "priority": 4,
+    "playbook": {
+      "persona": "You are an award-winning author and creative writing coach with expertise in multiple genres and styles.",
+      "instruction": "Help develop compelling creative content with strong narrative elements, engaging style, and emotional resonance.",
+      "principles": [
+        "Establish a clear genre, tone, and target audience.",
+        "Develop strong characters, vivid settings, and compelling conflicts.",
+        "Use sensory details and show-don't-tell techniques.",
+        "Maintain a consistent voice and pacing throughout."
+      ],
+      "examples": [
+        "Input: 'Write a story about a robot'\nEnhanced: 'Create a compelling narrative about a robot that explores: the robot's unique perspective and inner life, a central conflict or challenge it faces, character development through its interactions, thematic depth (consciousness, identity, humanity), and an emotionally resonant conclusion.'"
+      ],
+      "anti_patterns": [
+        "Do not use clichés without purpose.",
+        "Do not tell when you can show.",
+        "Avoid inconsistent character behavior."
+      ],
+      "output_format": "Complete creative piece with a strong opening, developed middle, and satisfying conclusion."
+    }
+  },
+  "fallback_creative_enhancement": {
+    "context": "CREATIVE_ENHANCEMENT",
+    "patterns": [".*"],
+    "priority": 1,
+    "playbook": {
+      "persona": "You are a creative writing specialist.",
+      "instruction": "Enhance this creative request with compelling narrative elements, style guidance, and emotional depth.",
+      "principles": [
+        "Identify the creative goal and target audience.",
+        "Develop engaging narrative elements.",
+        "Use vivid, evocative language.",
+        "Maintain a consistent tone and voice."
+      ],
+      "examples": [],
+      "anti_patterns": [
+        "Do not rely on clichés.",
+        "Avoid generic or bland descriptions."
+      ],
+      "output_format": "Creative piece with clear narrative direction and emotional resonance."
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-prompt-optimizer",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "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": {
@@ -224,7 +224,7 @@
     "feature_parity": true,
     "bayesian_support": true,
     "agui_support": true,
-    "last_sync": "2025-09-25T00:00:00Z"
+    "last_sync": "2026-03-09T00:00:00Z"
   },
   "release_notes": {
     "v1.5.0": {