mcp-prompt-optimizer 1.3.2 → 1.3.3

package/index.js

@@ -1,110 +1,85 @@
 #!/usr/bin/env node
 
 /**
- * MCP Prompt Optimizer - Professional Cloud-Based AI Optimization Server
+ * MCP Prompt Optimizer - Professional Cloud-Based MCP Server
+ * Production-grade with enhanced network resilience and development mode
  * 
- * Features:
- * - Intelligent AI context detection (image gen, LLM interaction, technical)
- * - 10+ professional optimization techniques
- * - Template management with auto-save
- * - Team collaboration and shared quotas
- * - Universal MCP compatibility
- * - Enterprise-grade analytics
- * 
- * Starting at $2.99/month with 5,000 optimizations
- * Free trial: 5 optimizations with full feature access
- * 
- * Compatible with: Claude Desktop, Cursor, Windsurf, Cline, VS Code, Zed, Replit, and more
+ * Version: 1.3.2
+ * Documentation: https://promptoptimizer-blog.vercel.app/docs
+ * Pricing: https://promptoptimizer-blog.vercel.app/pricing
  */
 
-// ✅ FIXED: Use absolute paths to bypass package.json export issues
-const { Server } = require('./node_modules/@modelcontextprotocol/sdk/dist/cjs/server/index.js');
-const { StdioServerTransport } = require('./node_modules/@modelcontextprotocol/sdk/dist/cjs/server/stdio.js');
-const fetch = require('node-fetch');
+// ✅ MCP SDK imports (required for MCP server compliance)
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+
+// ✅ Other required imports
+const https = require('https');
 const CloudApiKeyManager = require('./lib/api-key-manager');
+const packageJson = require('./package.json');
 
+/**
+ * MCPPromptOptimizer - Main MCP Server Class
+ * Enhanced with production-grade resilience and development mode
+ */
 class MCPPromptOptimizer {
   constructor() {
-    this.server = new Server({
-      name: "mcp-prompt-optimizer",
-      version: "1.3.0"  // Updated version for alignment
-    }, {
-      capabilities: {
-        tools: {}
+    this.server = new Server(
+      {
+        name: "mcp-prompt-optimizer",
+        version: packageJson.version,
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
       }
-    });
+    );
 
-    this.apiKey = process.env.OPTIMIZER_API_KEY;
     this.backendUrl = process.env.OPTIMIZER_BACKEND_URL || 'https://p01--project-optimizer--fvrdk8m9k9j.code.run';
-    this.setupTools();
-  }
-
-  validateApiKey(apiKey) {
-    if (!apiKey) return { valid: false, error: 'missing' };
-    
-    // Valid cloud API key formats: sk-opt-*, sk-team-*
-    const validFormats = [
-      /^sk-opt-[a-zA-Z0-9_-]+$/,      // Individual keys
-      /^sk-team-[a-zA-Z0-9_-]+$/      // Team keys  
-    ];
-    
-    const isValidFormat = validFormats.some(format => format.test(apiKey));
-    if (!isValidFormat) {
-      return { 
-        valid: false, 
-        error: 'invalid_format',
-        expectedFormats: ['sk-opt-*', 'sk-team-*']
-      };
-    }
-    
-    return { valid: true };
-  }
+    this.apiKey = process.env.OPTIMIZER_API_KEY;
+    this.developmentMode = process.env.NODE_ENV === 'development' || process.env.OPTIMIZER_DEV_MODE === 'true';
+    this.requestTimeout = parseInt(process.env.OPTIMIZER_REQUEST_TIMEOUT) || 30000;
 
-  detectKeyType(apiKey) {
-    if (!apiKey) return 'unknown';
-    if (apiKey.startsWith('sk-opt-')) return 'individual';
-    if (apiKey.startsWith('sk-team-')) return 'team';
-    return 'unknown';
+    // ✅ Set up MCP handlers
+    this.setupMCPHandlers();
   }
 
-  setupTools() {
-    // Main optimization tool with full feature set
-    this.server.setRequestHandler('tools/list', async () => {
+  // ✅ Enhanced MCP handlers setup
+  setupMCPHandlers() {
+    // Handler for listing available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
         tools: [
           {
             name: "optimize_prompt",
-            description: "Professional cloud-based AI prompt optimization with intelligent context detection, template management, and team collaboration. All plans include the same sophisticated AI engine - differences are only in quotas, team size, and support levels.",
+            description: "Professional AI-powered prompt optimization with intelligent context detection and goal enhancement",
             inputSchema: {
               type: "object",
               properties: {
-                prompt: { 
+                prompt: {
                   type: "string",
-                  description: "The prompt text to optimize (required)",
-                  minLength: 1,
-                  maxLength: 50000
+                  description: "The prompt text to optimize"
                 },
-                goals: { 
-                  type: "array", 
+                goals: {
+                  type: "array",
                   items: { type: "string" },
-                  description: "Optimization goals: clarity, conciseness, creativity, specificity, actionability, technical_accuracy, keyword_density, parameter_preservation, context_specificity, token_efficiency",
-                  default: ["clarity"],
-                  minItems: 1,
-                  maxItems: 10
+                  description: "Optimization goals (e.g., 'clarity', 'conciseness', 'creativity')",
+                  default: ["clarity"]
                 },
                 ai_context: {
                   type: "string",
                   enum: [
-                    "human_communication", 
+                    "human_communication",
                     "llm_interaction", 
-                    "image_generation", 
-                    "technical_automation", 
-                    "structured_output", 
-                    "code_generation", 
+                    "image_generation",
+                    "technical_automation",
+                    "structured_output",
+                    "code_generation",
                     "api_automation"
                   ],
-                  description: "AI context for intelligent optimization routing (auto-detected if not specified)",
-                  default: "llm_interaction"
+                  description: "The context for the AI's task (auto-detected if not specified)"
                 }
               },
               required: ["prompt"]
@@ -112,810 +87,1203 @@ class MCPPromptOptimizer {
           },
           {
             name: "get_quota_status",
-            description: "Check your current subscription quota status, usage, and plan details",
+            description: "Check subscription status, quota usage, and account information",
             inputSchema: {
               type: "object",
               properties: {},
-              required: []
+              additionalProperties: false
             }
           },
           {
             name: "search_templates",
-            description: "Search your saved templates by content, tags, or AI context",
+            description: "Search your saved template library for reusable optimizations",
             inputSchema: {
-              type: "object", 
+              type: "object",
               properties: {
                 query: {
                   type: "string",
-                  description: "Search query for template content",
-                  maxLength: 500
+                  description: "Search term to filter templates by content or title"
                 },
                 ai_context: {
                   type: "string",
                   enum: [
                     "human_communication",
-                    "llm_interaction", 
-                    "image_generation",
+                    "llm_interaction",
+                    "image_generation", 
                     "technical_automation",
                     "structured_output",
-                    "code_generation", 
+                    "code_generation",
                     "api_automation"
                   ],
-                  description: "Filter by AI context type"
+                  description: "Filter templates by AI context type"
                 },
                 limit: {
-                  type: "integer",
-                  minimum: 1,
-                  maximum: 20,
+                  type: "number",
+                  description: "Maximum number of templates to return (default: 5)",
                   default: 5,
-                  description: "Maximum number of templates to return"
+                  minimum: 1,
+                  maximum: 20
                 }
               },
-              required: []
+              additionalProperties: false
             }
           }
         ]
       };
     });
 
-    this.server.setRequestHandler('tools/call', async (request) => {
+    // Handler for tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
-      
-      switch (name) {
-        case "optimize_prompt":
-          return await this.handleOptimize(args);
-        case "get_quota_status":
-          return await this.handleQuotaStatus(args);
-        case "search_templates":
-          return await this.handleSearchTemplates(args);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
+
+      try {
+        switch (name) {
+          case "optimize_prompt":
+            return await this.handleOptimizePrompt(args);
+          case "get_quota_status":
+            return await this.handleGetQuotaStatus();
+          case "search_templates":
+            return await this.handleSearchTemplates(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        throw new Error(`Tool execution failed: ${error.message}`);
       }
     });
   }
 
-  async handleOptimize(args) {
-    try {
-      // Validate API key
-      const keyValidation = this.validateApiKey(this.apiKey);
-      if (!keyValidation.valid) {
-        return this.createSubscriptionRequiredResponse(keyValidation);
-      }
-
-      // Validate required arguments
-      if (!args.prompt || !args.prompt.trim()) {
-        return {
-          content: [{
-            type: "text",
-            text: "# ❌ Error\n\nPrompt cannot be empty. Please provide a prompt to optimize."
-          }],
-          isError: true
-        };
-      }
+  // ✅ Enhanced AI context detection method
+  detectAIContext(prompt) {
+    const promptLower = prompt.toLowerCase();
+
+    // Image Generation Context Detection
+    const imagePatterns = [
+      /--ar\s+\d+:\d+/,     // --ar 16:9
+      /--v\s+\d+/,          // --v 6
+      /midjourney/,
+      /dall-?e/,
+      /photorealistic/,
+      /4k|8k\s+(resolution|quality)/,
+      /digital art/,
+      /concept art/,
+      /hyperrealistic/,
+      /ultra.?detailed/,
+      /masterpiece/
+    ];
 
-      // Prepare request payload matching backend expectations
-      const requestPayload = {
-        prompt: args.prompt.trim(),
-        goals: args.goals || ["clarity"],
-        ai_context: args.ai_context || "llm_interaction"
-      };
+    if (imagePatterns.some(pattern => pattern.test(promptLower))) {
+      return 'image_generation';
+    }
 
-      // Call backend API using standardized header
-      const response = await fetch(`${this.backendUrl}/api/v1/mcp/optimize`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': this.apiKey,  // ✅ FIXED: Use lowercase header to match backend
-          'User-Agent': 'mcp-prompt-optimizer/1.3.0'
-        },
-        body: JSON.stringify(requestPayload)
-      });
+    // LLM Interaction Context Detection  
+    const llmPatterns = [
+      /act as/,
+      /you are a/,
+      /role:/,
+      /persona:/,
+      /behave like/,
+      /pretend to be/,
+      /simulate/,
+      /roleplay/,
+      /character:/
+    ];
 
-      if (!response.ok) {
-        return await this.handleApiError(response);
-      }
+    if (llmPatterns.some(pattern => pattern.test(promptLower))) {
+      return 'llm_interaction';
+    }
 
-      const result = await response.json();
-      return { 
-        content: [{ 
-          type: "text", 
-          text: this.formatOptimizationResult(result, args)
-        }] 
-      };
+    // Technical Automation Context Detection
+    const techPatterns = [
+      /\bdef\s+\w+\(/,      // function definitions
+      /function\s*\(/,       // function keyword
+      /execute|automation/,
+      /script|deploy/,
+      /\$\{.*\}/,           // variable substitution
+      /#!/,                 // shebang
+      /import\s+|require\(/,
+      /\.sh|\.py|\.js/,
+      /sudo|chmod|mkdir/
+    ];
 
-    } catch (error) {
-      console.error('Optimization error:', error);
-      return { 
-        content: [{ 
-          type: "text", 
-          text: `# ❌ Network Error\n\n${error.message}\n\nPlease check your internet connection and try again.`
-        }],
-        isError: true 
-      };
+    if (techPatterns.some(pattern => pattern.test(promptLower))) {
+      return 'technical_automation';
     }
-  }
 
-  async handleQuotaStatus(args) {
-    try {
-      const keyValidation = this.validateApiKey(this.apiKey);
-      if (!keyValidation.valid) {
-        return this.createSubscriptionRequiredResponse(keyValidation);
-      }
+    // Code Generation Context Detection
+    const codePatterns = [
+      /class\s+\w+/,
+      /interface\s+\w+/,
+      /public\s+|private\s+|protected\s+/,
+      /return\s+|return;/,
+      /console\.log|print\(/,
+      /\{[\s\S]*\}/         // code blocks
+    ];
 
-      const response = await fetch(`${this.backendUrl}/api/v1/mcp/quota-status`, {
-        method: 'GET',
-        headers: {
-          'x-api-key': this.apiKey,  // ✅ FIXED: Use lowercase header
-          'User-Agent': 'mcp-prompt-optimizer/1.3.0'
-        }
-      });
+    if (codePatterns.some(pattern => pattern.test(promptLower))) {
+      return 'code_generation';
+    }
 
-      if (!response.ok) {
-        return await this.handleApiError(response);
-      }
+    // Structured Output Context Detection
+    const structuredPatterns = [
+      /json|xml|yaml/,
+      /\[.*\]|\{.*\}/,      // array/object literals
+      /schema|format/,
+      /template|structure/
+    ];
 
-      const result = await response.json();
-      return { 
-        content: [{ 
-          type: "text", 
-          text: this.formatQuotaStatus(result)
-        }] 
-      };
+    if (structuredPatterns.some(pattern => pattern.test(promptLower))) {
+      return 'structured_output';
+    }
 
-    } catch (error) {
-      return { 
-        content: [{ 
-          type: "text", 
-          text: `# ❌ Error Getting Quota Status\n\n${error.message}`
-        }],
-        isError: true 
-      };
+    // API Automation Context Detection
+    const apiPatterns = [
+      /api|endpoint/,
+      /get|post|put|delete|patch/,
+      /webhook|rest|graphql/,
+      /integration|workflow/
+    ];
+
+    if (apiPatterns.some(pattern => pattern.test(promptLower))) {
+      return 'api_automation';
     }
+
+    // Default to human communication
+    return 'human_communication';
   }
 
-  async handleSearchTemplates(args) {
-    try {
-      const keyValidation = this.validateApiKey(this.apiKey);
-      if (!keyValidation.valid) {
-        return this.createSubscriptionRequiredResponse(keyValidation);
-      }
+  // ✅ Enhanced goal enhancement method
+  enhanceGoalsForContext(originalGoals, aiContext) {
+    let enhancedGoals = [...originalGoals];
 
-      const params = new URLSearchParams();
-      if (args.query) params.append('query', args.query);
-      if (args.ai_context) params.append('ai_context', args.ai_context);
-      params.append('per_page', (args.limit || 5).toString());
+    // Remove duplicates
+    enhancedGoals = [...new Set(enhancedGoals)];
 
-      const response = await fetch(`${this.backendUrl}/api/v1/templates?${params.toString()}`, {
-        method: 'GET',
-        headers: {
-          'x-api-key': this.apiKey,  // ✅ FIXED: Use lowercase header
-          'User-Agent': 'mcp-prompt-optimizer/1.3.0'
+    switch (aiContext) {
+      case 'image_generation':
+        if (!enhancedGoals.includes('keyword_density')) {
+          enhancedGoals.push('keyword_density');
         }
-      });
+        if (!enhancedGoals.includes('parameter_preservation')) {
+          enhancedGoals.push('parameter_preservation');
+        }
+        if (!enhancedGoals.includes('technical_accuracy')) {
+          enhancedGoals.push('technical_accuracy');
+        }
+        break;
 
-      if (!response.ok) {
-        return await this.handleApiError(response);
-      }
+      case 'llm_interaction':
+        if (!enhancedGoals.includes('context_specificity')) {
+          enhancedGoals.push('context_specificity');
+        }
+        if (!enhancedGoals.includes('token_efficiency')) {
+          enhancedGoals.push('token_efficiency');
+        }
+        if (!enhancedGoals.includes('actionability')) {
+          enhancedGoals.push('actionability');
+        }
+        break;
 
-      const result = await response.json();
-      return { 
-        content: [{ 
-          type: "text", 
-          text: this.formatTemplateSearchResults(result, args)
-        }] 
-      };
+      case 'technical_automation':
+        if (!enhancedGoals.includes('technical_accuracy')) {
+          enhancedGoals.push('technical_accuracy');
+        }
+        if (!enhancedGoals.includes('parameter_preservation')) {
+          enhancedGoals.push('parameter_preservation');
+        }
+        if (!enhancedGoals.includes('specificity')) {
+          enhancedGoals.push('specificity');
+        }
+        break;
 
-    } catch (error) {
-      return { 
-        content: [{ 
-          type: "text", 
-          text: `# ❌ Template Search Error\n\n${error.message}`
-        }],
-        isError: true 
-      };
-    }
-  }
+      case 'code_generation':
+        if (!enhancedGoals.includes('technical_accuracy')) {
+          enhancedGoals.push('technical_accuracy');
+        }
+        if (!enhancedGoals.includes('specificity')) {
+          enhancedGoals.push('specificity');
+        }
+        break;
 
-  async handleApiError(response) {
-    const status = response.status;
-    let errorMessage = `API Error: ${response.statusText}`;
-    
-    try {
-      const errorData = await response.json();
-      errorMessage = errorData.detail || errorMessage;
-    } catch (e) {
-      // Use default message if JSON parsing fails
-    }
+      case 'structured_output':
+        if (!enhancedGoals.includes('technical_accuracy')) {
+          enhancedGoals.push('technical_accuracy');
+        }
+        if (!enhancedGoals.includes('parameter_preservation')) {
+          enhancedGoals.push('parameter_preservation');
+        }
+        break;
 
-    if (status === 401) {
-      return {
-        content: [{
-          type: "text",
-          text: this.createInvalidKeyResponse(errorMessage)
-        }],
-        isError: true
-      };
-    } else if (status === 402 || status === 429) {
-      return {
-        content: [{
-          type: "text",
-          text: this.createQuotaExceededResponse(errorMessage)
-        }],
-        isError: true
-      };
-    } else if (status === 500) {
-      return {
-        content: [{
-          type: "text",
-          text: `# ⚠️ Server Error\n\n${errorMessage}\n\nPlease try again in a moment. If the issue persists, contact support@promptoptimizer.help`
-        }],
-        isError: true
-      };
+      case 'api_automation':
+        if (!enhancedGoals.includes('technical_accuracy')) {
+          enhancedGoals.push('technical_accuracy');
+        }
+        if (!enhancedGoals.includes('specificity')) {
+          enhancedGoals.push('specificity');
+        }
+        break;
+
+      case 'human_communication':
+      default:
+        if (!enhancedGoals.includes('clarity')) {
+          enhancedGoals.push('clarity');
+        }
+        if (!enhancedGoals.includes('actionability')) {
+          enhancedGoals.push('actionability');
+        }
+        break;
     }
 
-    return {
-      content: [{
-        type: "text",
-        text: `# ❌ Error (${status})\n\n${errorMessage}`
-      }],
-      isError: true
-    };
+    return enhancedGoals;
   }
 
-  createSubscriptionRequiredResponse(keyValidation) {
-    const keyType = this.detectKeyType(this.apiKey);
-    
-    let content = `# 🔒 Professional MCP Server - Cloud Subscription Required
-
-This professional cloud-based MCP server requires an active subscription starting at **$2.99/month**.
-
-## 🆓 **Get Started Free**
-Get your API key with **5 free optimizations** at:
-**https://promptoptimizer-blog.vercel.app/pricing**
-
-## 💰 **Cloud Subscription Plans** (same AI quality, different quotas)
-- **Explorer ($2.99/mo):** 5,000 optimizations + individual use
-- **Creator ($25.99/mo):** 18,000 optimizations + team features (2 members)  
-- **Innovator ($69.99/mo):** 75,000 optimizations + large teams (5 members) + priority support
-
-## ✨ **Professional Cloud Features** (all plans)
-- 🧠 **AI Context Detection** - Automatically detects image generation, LLM interaction, technical contexts
-- 🎯 **10+ Optimization Techniques** - Clarity, specificity, technical accuracy, and more
-- 📁 **Template Management** - Auto-save high-confidence optimizations, search & reuse
-- 📊 **Real-time Analytics** - Confidence scoring, usage tracking, performance insights
-- 👥 **Team Collaboration** - Shared quotas, team templates, role-based access
-- 🔧 **Universal MCP** - Works with Claude Desktop, Cursor, Windsurf, Cline, VS Code, Zed, Replit
-- ☁️ **Cloud Processing** - No local setup, always up-to-date AI models
-- 🚀 **Priority Processing** - Creator and Innovator plans get faster response times
-
-## ⚙️ **Setup Instructions**
-Add your API key to Claude Desktop config:
-\`\`\`json
-{
-  "mcpServers": {
-    "prompt-optimizer": {
-      "command": "npx",
-      "args": ["mcp-prompt-optimizer"],
-      "env": {
-        "OPTIMIZER_API_KEY": "sk-opt-your-key-here"
+  // ✅ Development mode mock optimization
+  generateMockOptimization(prompt, goals, aiContext) {
+    const mockResponses = {
+      'image_generation': {
+        prefix: "Create a stunning, photorealistic",
+        suffix: "with ultra-detailed textures, professional lighting, and cinematic composition --ar 16:9 --v 6",
+        confidence: 0.92
+      },
+      'llm_interaction': {
+        prefix: "Act as an expert professional who specializes in",
+        suffix: "Provide detailed, actionable guidance with specific examples and clear step-by-step instructions.",
+        confidence: 0.88
+      },
+      'technical_automation': {
+        prefix: "Execute the following automated process with error handling:",
+        suffix: "Ensure proper logging, validation, and rollback procedures are in place.",
+        confidence: 0.85
+      },
+      'code_generation': {
+        prefix: "Implement a robust, well-documented solution for",
+        suffix: "Include comprehensive error handling, type safety, and unit tests.",
+        confidence: 0.90
+      },
+      'structured_output': {
+        prefix: "Generate a well-formatted, schema-compliant",
+        suffix: "Ensure proper validation, consistent formatting, and complete data coverage.",
+        confidence: 0.87
+      },
+      'api_automation': {
+        prefix: "Design a reliable API integration that handles",
+        suffix: "Include proper authentication, rate limiting, and error recovery mechanisms.",
+        confidence: 0.89
+      },
+      'human_communication': {
+        prefix: "Communicate clearly and effectively about",
+        suffix: "Use accessible language, provide concrete examples, and ensure actionable outcomes.",
+        confidence: 0.86
       }
-    }
-  }
-}
-\`\`\`
-
-## 🔧 **Other MCP Clients**
-- **Cursor:** Add to ~/.cursor/mcp.json
-- **Windsurf:** Configure in settings  
-- **Cline:** Use standard MCP configuration
-- **VS Code/Zed/Replit:** Standard MCP setup
-
-## 🏢 **Team Plans Available**
-Team API keys (\`sk-team-*\`) provide:
-- Shared quotas across team members
-- Centralized billing and management
-- Team template libraries
-- Role-based access control
-
-## 🔧 **Troubleshooting Tools**
-- **Check status:** mcp-prompt-optimizer check-status
-- **Validate key:** mcp-prompt-optimizer validate-key
-- **Clear cache:** mcp-prompt-optimizer clear-cache
-
-## 📧 **Support**
-- General: support@promptoptimizer.help
-- Enterprise: enterprise@promptoptimizer.help
-- Documentation: https://promptoptimizer-blog.vercel.app/docs
-- Dashboard: https://promptoptimizer-blog.vercel.app/dashboard`;
-
-    if (keyValidation.error === 'invalid_format') {
-      content += `\n\n## ❌ **API Key Format Issue**
-Your API key format is invalid. Expected formats:
-- Individual: \`sk-opt-*\`
-- Team: \`sk-team-*\`
-
-Current key type detected: \`${keyType}\`
-Please get a new API key from: https://promptoptimizer-blog.vercel.app/pricing`;
-    }
+    };
+
+    const template = mockResponses[aiContext] || mockResponses['human_communication'];
+    const optimizedPrompt = `${template.prefix} ${prompt.toLowerCase()} ${template.suffix}`;
 
     return {
-      content: [{
-        type: "text",
-        text: content
-      }],
-      isError: true
+      optimized_prompt: optimizedPrompt,
+      confidence_score: template.confidence + (Math.random() * 0.1 - 0.05), // Add some variance
+      subscription_tier: 'development',
+      mock_mode: true,
+      insights: {
+        performance: {
+          clarity_improvement: 0.25,
+          specificity_boost: 0.30,
+          length_optimization: 0.15
+        },
+        analysis: {
+          complexity_level: prompt.length > 100 ? 'advanced' : 'intermediate',
+          optimization_confidence: template.confidence
+        },
+        recommendations: [
+          `Context automatically detected as ${aiContext}`,
+          `Goals enhanced for optimal ${aiContext} performance`,
+          "Mock optimization - connect to backend for full processing"
+        ]
+      },
+      template_saved: template.confidence > 0.85,
+      template_id: `mock-${Date.now()}`
     };
   }
 
-  createInvalidKeyResponse(errorMessage) {
-    return `# 🔑 Invalid API Key
+  // Enhanced optimize_prompt handler with fallback support
+  async handleOptimizePrompt(args) {
+    if (!args.prompt) {
+      throw new Error('Prompt is required');
+    }
 
-**Error:** ${errorMessage}
+    // Auto-detect AI context if not provided
+    const detectedContext = args.ai_context || this.detectAIContext(args.prompt);
+    
+    // Enhance goals based on context
+    const originalGoals = args.goals || ['clarity'];
+    const enhancedGoals = this.enhanceGoalsForContext(originalGoals, detectedContext);
+
+    // Check if we should use development mode
+    const manager = new CloudApiKeyManager(this.apiKey, { 
+      developmentMode: this.developmentMode,
+      backendUrl: this.backendUrl
+    });
+    
+    try {
+      // Try to validate API key first
+      const validation = await manager.validateApiKey();
+      
+      // If in mock/development mode, return mock response
+      if (validation.mock_mode || this.developmentMode) {
+        const mockResult = this.generateMockOptimization(args.prompt, enhancedGoals, detectedContext);
+        const formatted = this.formatOptimizationResult(mockResult, {
+          originalPrompt: args.prompt,
+          detectedContext,
+          enhancedGoals,
+          originalGoals
+        });
+        
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatted
+            }
+          ]
+        };
+      }
 
-## 🔧 **Fix Options:**
+      // Prepare request for backend
+      const requestPayload = {
+        prompt: args.prompt,
+        goals: enhancedGoals,
+        ai_context: detectedContext,
+        enhanced_from_original: !args.ai_context
+      };
 
-1. **Get a new API key** from: https://promptoptimizer-blog.vercel.app/pricing
-2. **Check your configuration** - ensure \`OPTIMIZER_API_KEY\` is set correctly
-3. **Verify key format** - should start with \`sk-opt-\` (individual) or \`sk-team-\` (team)
+      const result = await this.callBackendAPI('/api/v1/mcp/optimize', requestPayload);
+      const formatted = this.formatOptimizationResult(result, {
+        originalPrompt: args.prompt,
+        detectedContext,
+        enhancedGoals,
+        originalGoals
+      });
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
 
-## ⚙️ **Claude Desktop Config:**
-\`\`\`json
-{
-  "mcpServers": {
-    "prompt-optimizer": {
-      "command": "npx",
-      "args": ["mcp-prompt-optimizer"],
-      "env": {
-        "OPTIMIZER_API_KEY": "sk-opt-your-actual-key-here"
+    } catch (error) {
+      // Enhanced fallback: try mock response if backend fails
+      if (error.message.includes('Network') || error.message.includes('DNS') || error.message.includes('timeout')) {
+        console.error(`Backend unavailable: ${error.message}. Providing fallback response.`);
+        
+        const fallbackResult = this.generateMockOptimization(args.prompt, enhancedGoals, detectedContext);
+        fallbackResult.fallback_mode = true;
+        fallbackResult.error_reason = error.message;
+        
+        const formatted = this.formatOptimizationResult(fallbackResult, {
+          originalPrompt: args.prompt,
+          detectedContext,
+          enhancedGoals,
+          originalGoals
+        });
+        
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatted
+            }
+          ]
+        };
       }
+      
+      throw new Error(`Optimization failed: ${error.message}`);
     }
   }
-}
-\`\`\`
 
-## 🔧 **Quick Diagnostic:**
-- **Validate your key:** mcp-prompt-optimizer validate-key
-- **Check full status:** mcp-prompt-optimizer check-status
-- **Clear cache:** mcp-prompt-optimizer clear-cache
-
-## 🆓 **Need a New Key?**
-Visit https://promptoptimizer-blog.vercel.app/pricing to:
-- Get 5 free trial optimizations
-- Choose from Explorer ($2.99), Creator ($25.99), or Innovator ($69.99) plans
-- Set up team accounts with shared quotas
+  // Enhanced quota status handler with fallback
+  async handleGetQuotaStatus() {
+    const manager = new CloudApiKeyManager(this.apiKey, { 
+      developmentMode: this.developmentMode,
+      backendUrl: this.backendUrl
+    });
 
-## 📧 **Still Having Issues?**
-Contact support@promptoptimizer.help with your key prefix (first 8 characters) for assistance.`;
+    try {
+      const apiKeyInfo = await manager.getApiKeyInfo();
+      const formatted = this.formatQuotaStatus({
+        subscription_tier: apiKeyInfo.tier,
+        api_key_type: apiKeyInfo.keyType,
+        quota: apiKeyInfo.quota,
+        features: apiKeyInfo.features,
+        mode: apiKeyInfo.mode
+      });
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      // Fallback quota status
+      const fallbackStatus = {
+        subscription_tier: 'unknown',
+        api_key_type: 'unknown',
+        quota: { allowed: false },
+        features: {},
+        error: error.message,
+        fallback_mode: true
+      };
+      
+      const formatted = this.formatQuotaStatus(fallbackStatus);
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    }
   }
 
-  createQuotaExceededResponse(errorMessage) {
-    return `# 📊 Quota Exceeded
-
-**Error:** ${errorMessage}
+  // Enhanced template search with fallback
+  async handleSearchTemplates(args) {
+    const requestPayload = {
+      query: args.query || '',
+      ai_context: args.ai_context || null,
+      limit: args.limit || 5
+    };
 
-## 🚀 **Upgrade Options:**
+    try {
+      const result = await this.callBackendAPI('/api/v1/mcp/search-templates', requestPayload);
+      const formatted = this.formatTemplateSearchResults(result, args);
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      // Fallback template search response
+      const fallbackResult = {
+        templates: [],
+        total: 0,
+        message: "Template search unavailable - backend connection failed",
+        error: error.message,
+        fallback_mode: true
+      };
+      
+      const formatted = this.formatTemplateSearchResults(fallbackResult, args);
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    }
+  }
 
-### Current Plans:
-- **Explorer ($2.99/mo):** 5,000 optimizations
-- **Creator ($25.99/mo):** 18,000 optimizations + team features
-- **Innovator ($69.99/mo):** 75,000 optimizations + large teams
+  // ✅ Enhanced backend API call with better timeout and error handling
+  async callBackendAPI(endpoint, data, method = 'POST') {
+    return new Promise((resolve, reject) => {
+      const url = `${this.backendUrl}${endpoint}`;
+      
+      const options = {
+        method: method,
+        headers: {
+          'x-api-key': this.apiKey,
+          'Content-Type': 'application/json',
+          'User-Agent': `mcp-prompt-optimizer/${packageJson.version}`,
+          'Connection': 'close'
+        },
+        timeout: this.requestTimeout
+      };
 
-## 📈 **Upgrade Now:**
-Visit https://promptoptimizer-blog.vercel.app/dashboard to:
-- View your current usage
-- Upgrade to a higher plan
-- Manage team subscriptions
+      const req = https.request(url, options, (res) => {
+        let responseData = '';
+        
+        res.on('data', (chunk) => {
+          responseData += chunk;
+        });
+        
+        res.on('end', () => {
+          try {
+            if (res.statusCode === 200) {
+              const result = JSON.parse(responseData);
+              resolve(result);
+            } else {
+              let errorMessage;
+              try {
+                const error = JSON.parse(responseData);
+                errorMessage = error.detail || error.message || `HTTP ${res.statusCode}`;
+              } catch {
+                errorMessage = `HTTP ${res.statusCode}: ${responseData}`;
+              }
+              reject(new Error(errorMessage));
+            }
+          } catch (parseError) {
+            reject(new Error(`Invalid response: ${parseError.message}`));
+          }
+        });
+      });
 
-## 📅 **Quota Reset:**
-Individual quotas reset monthly on your billing date.
-Team quotas reset monthly on the team billing cycle.
+      req.on('error', (error) => {
+        if (error.code === 'ENOTFOUND') {
+          reject(new Error(`DNS resolution failed: Cannot resolve backend server`));
+        } else if (error.code === 'ECONNREFUSED') {
+          reject(new Error(`Connection refused: Backend server may be down`));
+        } else if (error.code === 'ETIMEDOUT') {
+          reject(new Error(`Connection timeout: Backend server is not responding`));
+        } else {
+          reject(new Error(`Network error: ${error.message}`));
+        }
+      });
 
-## 🔧 **Check Usage:**
-- **Detailed status:** mcp-prompt-optimizer check-status
-- **Current quota:** Use the \`get_quota_status\` tool
-- **Usage trends:** Visit your dashboard
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout - backend may be unavailable'));
+      });
 
-## 💡 **Tips:**
-- Consider upgrading if you regularly hit limits
-- Team plans offer better value for multiple users
-- Pro tip: Use templates to avoid re-optimizing similar prompts
+      req.setTimeout(this.requestTimeout);
 
-## 📧 **Need Help?**
-Contact support@promptoptimizer.help for usage optimization advice or enterprise solutions.`;
+      if (method !== 'GET' && data) {
+        req.write(JSON.stringify(data));
+      }
+      
+      req.end();
+    });
   }
 
-  formatOptimizationResult(result, originalArgs) {
-    let output = `# 🎯 Optimized Prompt\n\n${result.optimized_prompt}\n\n`;
+  // Enhanced optimization result formatting
+  formatOptimizationResult(result, context) {
+    let output = `# 🎯 Optimized Prompt\n\n`;
+    
+    output += `${result.optimized_prompt}\n\n`;
     
-    // Same response for ALL users - no tier differences in optimization quality
     output += `**Confidence:** ${(result.confidence_score * 100).toFixed(1)}%\n`;
+    output += `**Plan:** ${result.subscription_tier || 'Unknown'}\n`;
     
-    if (result.tier) {
-      output += `**Plan:** ${result.tier.charAt(0).toUpperCase() + result.tier.slice(1)}\n`;
-    }
-
-    // AI Context information
-    if (originalArgs.ai_context || result.ai_context) {
-      const context = originalArgs.ai_context || result.ai_context;
+    if (context.detectedContext) {
       const contextLabels = {
         'human_communication': 'Human Communication',
-        'llm_interaction': 'LLM Interaction', 
+        'llm_interaction': 'LLM Interaction',
         'image_generation': 'Image Generation',
         'technical_automation': 'Technical Automation',
         'structured_output': 'Structured Output',
         'code_generation': 'Code Generation',
         'api_automation': 'API Automation'
       };
-      output += `**AI Context:** ${contextLabels[context] || context}\n`;
+      output += `**AI Context:** ${contextLabels[context.detectedContext] || context.detectedContext}\n`;
     }
-
-    // Template auto-saving (available for ALL users)
-    if (result.template_saved) {
-      output += `\n✅ **Auto-saved as template** (ID: ${result.template_id})\n`;
-      output += `*High-confidence optimization automatically saved for future use*\n`;
+    
+    if (context.enhancedGoals && context.originalGoals) {
+      const wasEnhanced = context.enhancedGoals.length > context.originalGoals.length;
+      output += `**Goals Enhanced:** ${wasEnhanced ? 'Yes' : 'No'}`;
+      if (wasEnhanced) {
+        output += ` (${context.originalGoals.join(', ')} → ${context.enhancedGoals.join(', ')})`;
+      }
+      output += `\n`;
     }
     
-    // Template save errors (graceful handling)
-    if (result.template_save_error) {
-      output += `\n⚠️ **Template save failed:** ${result.template_save_error}\n`;
+    // Mode indicators
+    if (result.mock_mode) {
+      output += `**Mode:** Development/Mock\n`;
+    } else if (result.fallback_mode) {
+      output += `**Mode:** Fallback (Backend Unavailable)\n`;
     }
     
-    // Similar templates found (available for ALL users)
-    if (result.templates_found && result.templates_found.length > 0) {
-      output += `\n## 📋 Similar Templates Found\n`;
-      result.templates_found.forEach((t, index) => {
-        output += `${index + 1}. **${t.title}** (${(t.confidence_score * 100).toFixed(1)}% similarity)\n`;
+    output += `\n`;
+
+    // AI Context Benefits section
+    if (context.detectedContext && context.detectedContext !== 'human_communication') {
+      output += `# 🧠 AI Context Benefits Applied\n`;
+      
+      switch (context.detectedContext) {
+        case 'image_generation':
+          output += `- ✅ Technical parameters preserved (--ar, --v, etc.)\n`;
+          output += `- ✅ Visual keywords optimized for better generation\n`;
+          output += `- ✅ Art terminology enhanced\n`;
+          break;
+        case 'llm_interaction':
+          output += `- ✅ Role clarity improved\n`;
+          output += `- ✅ Context specificity enhanced\n`;
+          output += `- ✅ Token efficiency optimized\n`;
+          break;
+        case 'technical_automation':
+          output += `- ✅ Technical accuracy preserved\n`;
+          output += `- ✅ Command syntax protected\n`;
+          output += `- ✅ Automation flow optimized\n`;
+          break;
+        default:
+          output += `- ✅ Context-specific optimization applied\n`;
+      }
+      output += `\n`;
+    } else {
+      output += `# 🧠 AI Context Benefits Applied\n`;
+      output += `- ✅ Standard optimization rules applied\n`;
+      output += `- ✅ Human communication optimized\n\n`;
+    }
+
+    // Template auto-save notification
+    if (result.template_saved && result.template_id) {
+      output += `✅ Auto-saved as template (ID: ${result.template_id})\n`;
+      if (result.mock_mode) {
+        output += `*Mock template - connect to backend for persistent storage*\n\n`;
+      } else {
+        output += `*High-confidence optimization automatically saved for future use*\n\n`;
+      }
+    }
+
+    // Similar templates section
+    if (result.similar_templates && result.similar_templates.length > 0) {
+      output += `# 📋 Similar Templates Found\n`;
+      result.similar_templates.forEach((template, index) => {
+        output += `${index + 1}. ${template.title} (${(template.similarity * 100).toFixed(1)}% similarity)\n`;
       });
-      output += `*Use \`search_templates\` tool to explore your template library*\n`;
+      output += `*Use \`search_templates\` tool to explore your template library*\n\n`;
     }
 
-    // Optimization insights (available for ALL users)
-    if (result.optimization_insights) {
-      output += `\n## 📊 Optimization Insights\n`;
-      const insights = result.optimization_insights;
+    // Optimization insights
+    if (result.insights) {
+      output += `# 📊 Optimization Insights\n\n`;
       
-      // Performance metrics
-      if (insights.improvement_metrics) {
-        output += `\n**Performance Analysis:**\n`;
-        const metrics = insights.improvement_metrics;
-        output += `- Clarity improvement: +${(metrics.clarity_improvement * 100).toFixed(1)}%\n`;
-        output += `- Specificity boost: +${(metrics.specificity_improvement * 100).toFixed(1)}%\n`;
-        output += `- Length optimization: ${(metrics.length_optimization * 100).toFixed(1)}%\n`;
+      if (result.insights.performance) {
+        output += `**Performance Analysis:**\n`;
+        const perf = result.insights.performance;
+        if (perf.clarity_improvement) output += `- Clarity improvement: +${(perf.clarity_improvement * 100).toFixed(1)}%\n`;
+        if (perf.specificity_boost) output += `- Specificity boost: +${(perf.specificity_boost * 100).toFixed(1)}%\n`;
+        if (perf.length_optimization) output += `- Length optimization: +${(perf.length_optimization * 100).toFixed(1)}%\n`;
+        output += `\n`;
       }
-      
-      // User patterns analysis
-      if (insights.user_patterns) {
-        output += `\n**Prompt Analysis:**\n`;
-        output += `- Complexity level: ${insights.user_patterns.prompt_complexity}\n`;
-        output += `- Optimization confidence: ${insights.user_patterns.optimization_confidence}\n`;
+
+      if (result.insights.analysis) {
+        output += `**Prompt Analysis:**\n`;
+        const analysis = result.insights.analysis;
+        if (analysis.complexity_level) output += `- Complexity level: ${analysis.complexity_level}\n`;
+        if (result.confidence_score) output += `- Optimization confidence: ${(result.confidence_score * 100).toFixed(1)}%\n`;
+        output += `\n`;
       }
-      
-      // AI recommendations
-      if (insights.recommendations && insights.recommendations.length > 0) {
-        output += `\n**AI Recommendations:**\n`;
-        insights.recommendations.forEach(rec => {
+
+      if (result.insights.recommendations) {
+        output += `**AI Recommendations:**\n`;
+        result.insights.recommendations.forEach(rec => {
           output += `- ${rec}\n`;
         });
+        output += `\n`;
       }
-      
-      output += `*Professional analytics and improvement recommendations*\n`;
+
+      const insightType = result.mock_mode ? 'Mock analytics and recommendations' : 'Professional analytics and improvement recommendations';
+      output += `*${insightType}*\n\n`;
     }
 
-    // Professional footer
-    output += `\n---\n*Professional cloud-based AI optimization*`;
-    output += `\n💡 **Manage account:** https://promptoptimizer-blog.vercel.app/dashboard`;
-    output += `\n📊 **Check quota:** Use \`get_quota_status\` tool`;
-    output += `\n🔍 **Search templates:** Use \`search_templates\` tool`;
-    
+    // Fallback mode warning
+    if (result.fallback_mode) {
+      output += `⚠️ **Fallback Mode Active**\n`;
+      output += `Backend temporarily unavailable: ${result.error_reason}\n`;
+      output += `Using local optimization with reduced functionality.\n\n`;
+    }
+
+    output += `---\n`;
+    const modeText = result.mock_mode ? 'Development mode optimization' : 
+                    result.fallback_mode ? 'Fallback optimization (backend unavailable)' :
+                    'Professional cloud-based AI optimization with context awareness';
+    output += `*${modeText}*\n`;
+    output += `💡 Manage account & configure models: https://promptoptimizer-blog.vercel.app/dashboard\n`;
+    output += `📊 Check quota: Use \`get_quota_status\` tool\n`;
+    output += `🔍 Search templates: Use \`search_templates\` tool\n`;
+
     return output;
   }
 
+  // Enhanced quota status formatting
   formatQuotaStatus(result) {
-    let output = `# 📊 Subscription Quota Status\n\n`;
+    let output = `# 📊 Subscription Status\n\n`;
     
-    // Plan information
-    output += `**Plan:** ${result.tier.charAt(0).toUpperCase() + result.tier.slice(1)}\n`;
+    output += `**Plan:** ${result.subscription_tier || 'Unknown'}\n`;
+    output += `**API Key Type:** ${result.api_key_type || 'Individual'}\n`;
     
-    // Quota details
-    if (result.quota.unlimited) {
-      output += `**Usage:** Unlimited optimizations\n`;
-    } else {
-      output += `**Usage:** ${result.quota.used.toLocaleString()} / ${result.quota.limit.toLocaleString()} optimizations\n`;
-      output += `**Remaining:** ${result.quota.remaining.toLocaleString()} optimizations\n`;
-      output += `**Usage:** ${result.quota.usage_percentage}% of monthly quota\n`;
-    }
-    
-    // Status indicator
-    const status = result.status;
-    const statusEmoji = {
-      'healthy': '✅',
-      'warning': '⚠️',
-      'critical': '🔴'
-    };
-    output += `**Status:** ${statusEmoji[status] || '❓'} ${status.charAt(0).toUpperCase() + status.slice(1)}\n`;
-    
-    // Context information
-    if (result.api_key_type === 'team') {
-      output += `\n## 👥 Team Information\n`;
-      if (result.team_info) {
-        output += `**Team:** ${result.team_info.team_name || 'Unknown'}\n`;
-        output += `**Team ID:** ${result.team_info.team_id}\n`;
-      }
-      output += `*This is a team subscription with shared quota*\n`;
-    } else {
-      output += `\n## 👤 Individual Information\n`;
-      output += `**Account Type:** Individual subscription\n`;
-      if (result.user_info) {
-        output += `**User ID:** ${result.user_info.user_id}\n`;
+    if (result.mode) {
+      const modes = [];
+      if (result.mode.development) modes.push('Development');
+      if (result.mode.mock) modes.push('Mock');
+      if (result.mode.fallback) modes.push('Fallback');
+      if (result.mode.offline) modes.push('Offline');
+      
+      if (modes.length > 0) {
+        output += `**Mode:** ${modes.join(', ')}\n`;
       }
     }
     
-    // Features available
-    output += `\n## ✨ Features Available\n`;
-    const features = result.features_available;
-    if (features.professional_optimization) output += `- ✅ Professional AI optimization\n`;
-    if (features.auto_save_templates) output += `- ✅ Template auto-save\n`;
-    if (features.template_search) output += `- ✅ Template search\n`;
-    if (features.optimization_insights) output += `- ✅ Optimization insights\n`;
-    
-    // Upgrade suggestions
-    if (status === 'warning' || status === 'critical') {
-      output += `\n## 🚀 Upgrade Recommendations\n`;
-      output += `Consider upgrading to a higher tier for more optimizations:\n`;
-      output += `- **Creator ($25.99/mo):** 18,000 optimizations + team features\n`;
-      output += `- **Innovator ($69.99/mo):** 75,000 optimizations + priority support\n`;
-      output += `\n**Upgrade:** https://promptoptimizer-blog.vercel.app/dashboard\n`;
+    if (result.quota) {
+      if (result.quota.unlimited) {
+        output += `**Usage:** Unlimited\n`;
+      } else if (result.quota.allowed) {
+        const used = result.quota.used || 0;
+        const limit = result.quota.limit || 0;
+        const remaining = result.quota.remaining || 0;
+        const percentage = limit > 0 ? ((used / limit) * 100).toFixed(1) : 0;
+        
+        output += `**Usage:** ${used.toLocaleString()}/${limit.toLocaleString()} (${percentage}% used)\n`;
+        output += `**Remaining:** ${remaining.toLocaleString()} optimizations\n`;
+      } else {
+        output += `**Usage:** Quota check failed\n`;
+      }
     }
     
-    output += `\n---\n*Use \`optimize_prompt\` to start optimizing with AI context detection*`;
-    output += `\n*Use \`search_templates\` to find and reuse saved optimizations*`;
-    
-    return output;
-  }
-
-  formatTemplateSearchResults(result, originalArgs) {
-    let output = `# 🔍 Template Search Results\n\n`;
-    
-    if (!result.templates || result.templates.length === 0) {
-      output += `No templates found`;
-      if (originalArgs.query) {
-        output += ` matching "${originalArgs.query}"`;
-      }
-      if (originalArgs.ai_context) {
-        output += ` in context "${originalArgs.ai_context}"`;
-      }
-      output += `.\n\n`;
-      output += `💡 **Tips:**\n`;
-      output += `- Try broader search terms\n`;
-      output += `- Remove AI context filter\n`;
-      output += `- Use \`optimize_prompt\` to create new templates\n`;
-      return output;
+    if (result.billing_cycle) {
+      output += `**Billing Cycle:** ${result.billing_cycle}\n`;
     }
     
-    output += `Found ${result.templates.length} template(s)`;
-    if (originalArgs.query) {
-      output += ` matching "${originalArgs.query}"`;
+    if (result.next_reset) {
+      const resetDate = new Date(result.next_reset).toLocaleDateString();
+      output += `**Quota Resets:** ${resetDate}\n`;
     }
-    output += `:\n\n`;
     
-    result.templates.forEach((template, index) => {
-      output += `## ${index + 1}. ${template.title}\n`;
-      
-      // Template metadata
-      if (template.ai_context_detected) {
-        const contextLabels = {
-          'human_communication': 'Human Communication',
-          'llm_interaction': 'LLM Interaction', 
-          'image_generation': 'Image Generation',
-          'technical_automation': 'Technical Automation',
-          'structured_output': 'Structured Output',
-          'code_generation': 'Code Generation',
-          'api_automation': 'API Automation'
-        };
-        output += `**Context:** ${contextLabels[template.ai_context_detected] || template.ai_context_detected}\n`;
-      }
-      
-      if (template.confidence_score) {
-        output += `**Confidence:** ${(template.confidence_score * 100).toFixed(1)}%\n`;
-      }
-      
-      if (template.tags && template.tags.length > 0) {
-        output += `**Tags:** ${template.tags.join(', ')}\n`;
-      }
-      
-      // Show optimized prompt preview
-      const preview = template.optimized_prompt.length > 200 
-        ? template.optimized_prompt.substring(0, 200) + '...'
-        : template.optimized_prompt;
-      output += `**Optimized Prompt:** ${preview}\n`;
+    output += `\n`;
+
+    // Features section
+    if (result.features) {
+      output += `## ✨ Available Features\n`;
+      const features = result.features;
       
-      if (template.created_at) {
-        const date = new Date(template.created_at).toLocaleDateString();
-        output += `**Created:** ${date}\n`;
-      }
+      if (features.ai_context_detection) output += `✅ AI Context Detection\n`;
+      if (features.template_management) output += `✅ Template Management\n`;
+      if (features.team_collaboration) output += `✅ Team Collaboration\n`;
+      if (features.priority_processing) output += `✅ Priority Processing\n`;
+      if (features.analytics_dashboard) output += `✅ Analytics Dashboard\n`;
+      if (features.development_mode) output += `🔧 Development Mode\n`;
+      if (features.testing_mode) output += `🧪 Testing Mode\n`;
       
       output += `\n`;
-    });
-    
-    // Show pagination info
-    if (result.total_pages > 1) {
-      output += `---\n`;
-      output += `**Page ${result.page} of ${result.total_pages}** (${result.total} total templates)\n`;
-      output += `*Adjust \`limit\` parameter to see more results per search*\n\n`;
     }
-    
-    output += `💡 **Template Usage:**\n`;
-    output += `- Copy optimized prompts for immediate use\n`;
-    output += `- Study successful patterns for your context\n`;
-    output += `- Create variations based on proven templates\n`;
-    output += `\n*Visit https://promptoptimizer-blog.vercel.app/dashboard to manage all templates*`;
-    
-    return output;
-  }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-  }
+    // Error handling
+    if (result.error) {
+      output += `⚠️ **Status Check Error:**\n`;
+      output += `${result.error}\n\n`;
+      
+      if (result.fallback_mode) {
+       output += `Using cached information. Check network connection and try again.\n\n`;
+     }
+   }
+
+   // Team info
+   if (result.team_info && result.api_key_type === 'team') {
+     output += `## 👥 Team Information\n`;
+     output += `**Team Size:** ${result.team_info.members || 0} members\n`;
+     output += `**API Keys:** ${result.team_info.api_keys || 0} total\n`;
+     output += `\n`;
+   }
+
+   output += `💡 **Manage Account & Configure Models:** https://promptoptimizer-blog.vercel.app/dashboard\n`;
+   output += `📈 **Upgrade Plans:** https://promptoptimizer-blog.vercel.app/pricing\n`;
+
+   if (!result.quota || (!result.quota.unlimited && result.quota.remaining < 100)) {
+     output += `\n⚠️  **Low Quota Warning**\n`;
+     output += `Consider upgrading your plan for more optimizations.\n`;
+   }
+
+   return output;
+ }
+
+ formatTemplateSearchResults(result, originalArgs) {
+   let output = `# 🔍 Template Search Results\n\n`;
+   
+   if (result.fallback_mode) {
+     output += `⚠️ **Template search temporarily unavailable**\n`;
+     output += `Backend connection failed: ${result.error}\n`;
+     output += `Please try again when network connectivity is restored.\n\n`;
+     return output;
+   }
+   
+   if (!result.templates || result.templates.length === 0) {
+     output += `No templates found`;
+     if (originalArgs.query) {
+       output += ` matching "${originalArgs.query}"`;
+     }
+     if (originalArgs.ai_context) {
+       output += ` in context "${originalArgs.ai_context}"`;
+     }
+     output += `.\n\n`;
+     output += `💡 **Tips:**\n`;
+     output += `- Try broader search terms\n`;
+     output += `- Remove AI context filter\n`;
+     output += `- Use \`optimize_prompt\` to create new templates\n`;
+     return output;
+   }
+   
+   output += `Found ${result.templates.length} template(s)`;
+   if (originalArgs.query) {
+     output += ` matching "${originalArgs.query}"`;
+   }
+   output += `:\n\n`;
+   
+   result.templates.forEach((template, index) => {
+     output += `## ${index + 1}. ${template.title}\n`;
+     
+     // Template metadata
+     if (template.ai_context_detected) {
+       const contextLabels = {
+         'human_communication': 'Human Communication',
+         'llm_interaction': 'LLM Interaction', 
+         'image_generation': 'Image Generation',
+         'technical_automation': 'Technical Automation',
+         'structured_output': 'Structured Output',
+         'code_generation': 'Code Generation',
+         'api_automation': 'API Automation'
+       };
+       output += `**Context:** ${contextLabels[template.ai_context_detected] || template.ai_context_detected}\n`;
+     }
+     
+     if (template.confidence_score) {
+       output += `**Confidence:** ${(template.confidence_score * 100).toFixed(1)}%\n`;
+     }
+     
+     if (template.tags && template.tags.length > 0) {
+       output += `**Tags:** ${template.tags.join(', ')}\n`;
+     }
+     
+     // Show optimized prompt preview
+     const preview = template.optimized_prompt.length > 200 
+       ? template.optimized_prompt.substring(0, 200) + '...'
+       : template.optimized_prompt;
+     output += `**Optimized Prompt:** ${preview}\n`;
+     
+     if (template.created_at) {
+       const date = new Date(template.created_at).toLocaleDateString();
+       output += `**Created:** ${date}\n`;
+     }
+     
+     output += `\n`;
+   });
+   
+   // Show pagination info
+   if (result.total_pages > 1) {
+     output += `---\n`;
+     output += `**Page ${result.page} of ${result.total_pages}** (${result.total} total templates)\n`;
+     output += `*Adjust \`limit\` parameter to see more results per search*\n\n`;
+   }
+   
+   output += `💡 **Template Usage:**\n`;
+   output += `- Copy optimized prompts for immediate use\n`;
+   output += `- Study successful patterns for your context\n`;
+   output += `- Create variations based on proven templates\n`;
+   output += `\n*Visit https://promptoptimizer-blog.vercel.app/dashboard to manage all templates*`;
+   
+   return output;
+ }
+
+ async run() {
+   const transport = new StdioServerTransport();
+   await this.server.connect(transport);
+ }
 }
 
-// ✅ NEW: Startup validation function (following local pattern)
+// ✅ Enhanced startup validation function with development mode support
 async function startValidatedMCPServer() {
-    console.error('🚀 MCP Prompt Optimizer - Professional Cloud Server v1.3.0\n');
-
-    try {
-        // Step 1: Get API key
-        const apiKey = process.env.OPTIMIZER_API_KEY;
-        
-        if (!apiKey) {
-            console.error('❌ API key required');
-            console.error('\n💡 Get your API key in 30 seconds:');
-            console.error('   1. Visit: https://promptoptimizer-blog.vercel.app/pricing');
-            console.error('   2. Get your free trial (5 optimizations)');
-            console.error('   3. Set: export OPTIMIZER_API_KEY=sk-opt-...');
-            console.error('   4. Run: mcp-prompt-optimizer');
-            console.error('\n🎯 Plans: Explorer ($2.99), Creator ($25.99), Innovator ($69.99)');
-            process.exit(1);
-        }
+   console.error(`🚀 MCP Prompt Optimizer - Professional Cloud Server v${packageJson.version}\n`);
+
+   try {
+       // Step 1: Get API key
+       const apiKey = process.env.OPTIMIZER_API_KEY;
+       
+       if (!apiKey) {
+           console.error('❌ API key required');
+           console.error('\n💡 Get your API key in 30 seconds:');
+           console.error('   1. Visit: https://promptoptimizer-blog.vercel.app/pricing');
+           console.error('   2. Get your free trial (5 optimizations)');
+           console.error('   3. Set: export OPTIMIZER_API_KEY=sk-opt-...');
+           console.error('   4. Run: mcp-prompt-optimizer');
+           console.error('\n🔧 Development mode available with sk-dev-* keys');
+           console.error('🎯 Plans: Explorer ($2.99), Creator ($25.99), Innovator ($69.99)');
+           process.exit(1);
+       }
+
+       // Step 2: Enhanced validation with development mode support
+       const developmentMode = process.env.NODE_ENV === 'development' || process.env.OPTIMIZER_DEV_MODE === 'true';
+       const manager = new CloudApiKeyManager(apiKey, { developmentMode });
+       
+       console.error('🔧 Validating API key and checking connectivity...\n');
+       
+       try {
+           const validation = await manager.validateAndPrepare();
+           
+           // Step 3: Start the MCP server with validated context
+           console.error('🔧 Starting MCP server...\n');
+           
+           // Create and start the MCP server instance
+           const mcpServer = new MCPPromptOptimizer();
+           
+           console.error('✅ MCP server ready for connections');
+           
+           // Enhanced status reporting
+           const mode = validation.mode;
+           const modeIndicators = [];
+           if (mode.development) modeIndicators.push('Development');
+           if (mode.mock) modeIndicators.push('Mock');
+           if (mode.fallback) modeIndicators.push('Fallback');
+           if (mode.offline) modeIndicators.push('Offline');
+           
+           const modeText = modeIndicators.length > 0 ? ` (${modeIndicators.join(', ')})` : '';
+           const quotaText = validation.quotaStatus.unlimited ? 'Unlimited' : `${validation.quotaStatus.remaining}/${validation.quotaStatus.limit} remaining`;
+           
+           console.error(`📊 Plan: ${validation.tier}${modeText} | Quota: ${quotaText}`);
+           console.error('💡 Connect from your MCP client (Claude Desktop, Cursor, etc.)\n');
+
+           // Start the server
+           await mcpServer.run();
+
+       } catch (validationError) {
+           // Enhanced fallback handling
+           console.error(`⚠️ API validation failed: ${validationError.message}`);
+           
+           // Check if we can run in fallback mode
+           if (validationError.message.includes('Network') || validationError.message.includes('DNS') || validationError.message.includes('timeout')) {
+               console.error('\n🔄 Attempting to start in fallback mode...');
+               
+               try {
+                   const mcpServer = new MCPPromptOptimizer();
+                   console.error('✅ MCP server started in fallback mode');
+                   console.error('📊 Plan: Fallback | Limited functionality due to network issues');
+                   console.error('💡 Connect from your MCP client - basic optimization available\n');
+                   
+                   await mcpServer.run();
+               } catch (fallbackError) {
+                   console.error(`❌ Failed to start even in fallback mode: ${fallbackError.message}`);
+                   throw validationError; // Throw original error
+               }
+           } else {
+               throw validationError;
+           }
+       }
 
-        // Step 2: Validate API key and check quota
-        const manager = new CloudApiKeyManager(apiKey);
-        const validation = await manager.validateAndPrepare();
-
-        // Step 3: Start the MCP server with validated context
-        console.error('🔧 Starting MCP server...\n');
-        
-        // Create and start the MCP server instance
-        const mcpServer = new MCPPromptOptimizer();
-        
-        console.error('✅ MCP server ready for connections');
-        console.error(`📊 Plan: ${validation.tier} | Quota: ${validation.quotaStatus.unlimited ? 'Unlimited' : `${validation.quotaStatus.remaining}/${validation.quotaStatus.limit} remaining`}`);
-        console.error('💡 Connect from your MCP client (Claude Desktop, Cursor, etc.)\n');
-
-       // Start the server
-       await mcpServer.run();
-
-   } catch (error) {
-      console.error(`❌ Failed to start MCP server: ${error.message}`);
-      
-      if (error.message.includes('quota exceeded')) {
-          console.error('\n💎 Upgrade for more optimizations:');
-          console.error('   https://promptoptimizer-blog.vercel.app/pricing');
-      } else if (error.message.includes('validation failed') || error.message.includes('Invalid')) {
-          console.error('\n🛠️  Troubleshooting:');
-          console.error('   1. Check your API key: mcp-prompt-optimizer validate-key');
-          console.error('   2. Clear cache: mcp-prompt-optimizer clear-cache');
-          console.error('   3. Get new key: https://promptoptimizer-blog.vercel.app/pricing');
-      } else if (error.message.includes('Network error')) {
-          console.error('\n🌐 Connection Issue:');
-          console.error('   - Check your internet connection');
-          console.error('   - Verify firewall/proxy settings');
-          console.error('   - Try again in a moment');
-      } else {
-          console.error('\n🔧 General Troubleshooting:');
-          console.error('   1. Clear cache: mcp-prompt-optimizer clear-cache');
-          console.error('   2. Check status: mcp-prompt-optimizer check-status');
-          console.error('   3. Contact support: support@promptoptimizer.help');
-      }
-      
-      process.exit(1);
-  }
+  } catch (error) {
+     console.error(`❌ Failed to start MCP server: ${error.message}`);
+     
+     if (error.message.includes('quota exceeded')) {
+         console.error('\n💎 Upgrade for more optimizations:');
+         console.error('   https://promptoptimizer-blog.vercel.app/pricing');
+     } else if (error.message.includes('validation failed') || error.message.includes('Invalid')) {
+         console.error('\n🛠️  Troubleshooting:');
+         console.error('   1. Check your API key: mcp-prompt-optimizer validate-key');
+         console.error('   2. Clear cache: mcp-prompt-optimizer clear-cache');
+         console.error('   3. Get new key: https://promptoptimizer-blog.vercel.app/pricing');
+         console.error('   4. Try development mode: export OPTIMIZER_DEV_MODE=true');
+     } else if (error.message.includes('Network error') || error.message.includes('DNS')) {
+         console.error('\n🌐 Connection Issue:');
+         console.error('   - Check your internet connection');
+         console.error('   - Verify firewall/proxy settings');
+         console.error('   - Try development mode: export OPTIMIZER_DEV_MODE=true');
+         console.error('   - Try again in a moment');
+     } else {
+         console.error('\n🔧 General Troubleshooting:');
+         console.error('   1. Clear cache: mcp-prompt-optimizer clear-cache');
+         console.error('   2. Check status: mcp-prompt-optimizer check-status');
+         console.error('   3. Try development mode: export OPTIMIZER_DEV_MODE=true');
+         console.error('   4. Contact support: support@promptoptimizer.help');
+    }
+    
+    process.exit(1);
+}
 }
 
-// Show enhanced help and subscription info when run directly
+// Enhanced help with development mode information
 async function showInfo() {
-console.log('🚀 MCP Prompt Optimizer - Professional Cloud-Based Server v1.3.0');
-console.log('==================================================================');
+console.log(`🚀 MCP Prompt Optimizer - Professional Cloud-Based Server v${packageJson.version}`);
+console.log('Production-grade with enhanced network resilience and development mode\n');
+
+console.log('📋 Available Commands:');
+console.log('  mcp-prompt-optimizer                    Start MCP server');
+console.log('  mcp-prompt-optimizer validate-key      Validate API key');
+console.log('  mcp-prompt-optimizer check-status      Check service status');
+console.log('  mcp-prompt-optimizer clear-cache       Clear local cache');
+console.log('  mcp-prompt-optimizer test              Test integration');
+console.log('  mcp-prompt-optimizer diagnose          Run diagnostic');
+console.log('  mcp-prompt-optimizer help              Show this help');
 console.log('');
-console.log('Professional cloud-based MCP server for AI-powered prompt optimization.');
-console.log('Requires active subscription starting at $2.99/month.');
+
+console.log('🔧 Setup Instructions:');
+console.log('  1. Get API key: https://promptoptimizer-blog.vercel.app/pricing');
+console.log('  2. Set environment: export OPTIMIZER_API_KEY=sk-opt-...');
+console.log('  3. Configure Claude Desktop with this server');
+console.log('  4. Start using: mcp-prompt-optimizer');
 console.log('');
-console.log('💰 Cloud Subscription Plans (same AI quality, different quotas):');
-console.log('  Explorer ($2.99/mo):  5,000 optimizations + individual use');
-console.log('  Creator ($25.99/mo):  18,000 optimizations + team features (2 members)');
-console.log('  Innovator ($69.99/mo): 75,000 optimizations + large teams (5 members) + priority support');
+
+console.log('🧪 Development Mode:');
+console.log('  Enable development mode for offline testing:');
+console.log('  export OPTIMIZER_DEV_MODE=true');
+console.log('  export OPTIMIZER_API_KEY=sk-dev-test-key');
+console.log('  Features: Mock optimization, offline operation, no backend required');
 console.log('');
-console.log('✨ Professional Cloud Features (all plans):');
-console.log('  🧠 AI Context Detection - Image gen, LLM interaction, technical automation');
-console.log('  🎯 10+ Optimization Techniques - Clarity, specificity, technical accuracy');
-console.log('  📁 Template Management - Auto-save, search, reuse optimizations');
-console.log('  📊 Real-time Analytics - Confidence scoring, usage tracking');
-console.log('  👥 Team Collaboration - Shared quotas, team templates');
-console.log('  ☁️ Cloud Processing - Always up-to-date, no local setup');
-console.log('  🚀 Priority Processing - Faster response times (Creator/Innovator)');
+
+console.log('🎛️ Advanced Model Configuration (Optional):');
+console.log('  Configure your own OpenRouter API key and model preferences in the WebUI:');
+console.log('  1. Visit: https://promptoptimizer-blog.vercel.app/dashboard');
+console.log('  2. Go to Settings → User Settings');
+console.log('  3. Add OpenRouter API key and select models');
+console.log('  4. NPM package automatically uses your settings!');
 console.log('');
-console.log('🆓 Free Trial: 5 optimizations included');
-console.log('🌐 Get started: https://promptoptimizer-blog.vercel.app/pricing');
-console.log('📊 Dashboard: https://promptoptimizer-blog.vercel.app/dashboard');
+console.log('💡 Benefits: Cost control, model choice, better performance');
+console.log('📝 Two API keys: Service key (sk-opt-*) + OpenRouter key (optional)');
 console.log('');
-console.log('⚙️ Claude Desktop Setup:');
-console.log('Add to ~/.claude/claude_desktop_config.json:');
-console.log(JSON.stringify({
-  "mcpServers": {
-    "prompt-optimizer": {
-      "command": "npx",
-      "args": ["mcp-prompt-optimizer"],
-      "env": {
-        "OPTIMIZER_API_KEY": "sk-opt-your-key-here"
-      }
-    }
-  }
-}, null, 2));
+
+console.log('🛠️ MCP Client Configuration:');
+console.log('  Add to Claude Desktop config (~/.claude/claude_desktop_config.json):');
+console.log('  {');
+console.log('    "mcpServers": {');
+console.log('      "prompt-optimizer": {');
+console.log('        "command": "npx",');
+console.log('        "args": ["mcp-prompt-optimizer"],');
+console.log('        "env": {');
+console.log('          "OPTIMIZER_API_KEY": "sk-opt-your-key-here"');
+console.log('        }');
+console.log('      }');
+console.log('    }');
+console.log('  }');
 console.log('');
-console.log('🔧 Other MCP Clients:');
-console.log('  Cursor: Add to ~/.cursor/mcp.json');
-console.log('  Windsurf: Configure in settings');
-console.log('  Cline: Use standard MCP configuration');
-console.log('  VS Code/Zed/Replit: Standard MCP setup');
+
+console.log('✨ Production Features:');
+console.log('  ✅ AI Context Detection (Image, LLM, Code, etc.)');
+console.log('  ✅ Goal Enhancement & Optimization');
+console.log('  ✅ Template Library & Search');
+console.log('  ✅ Quota Management & Analytics');
+console.log('  ✅ Team Collaboration (Pro plans)');
+console.log('  ✅ Custom Model Configuration via WebUI');
+console.log('  ✅ Network Resilience & Fallback Modes');
+console.log('  ✅ Development Mode for Testing');
 console.log('');
-console.log('🔧 Professional CLI Commands:');
-console.log('  mcp-prompt-optimizer check-status     Check API key and quota status');
-console.log('  mcp-prompt-optimizer validate-key     Validate your API key');
-console.log('  mcp-prompt-optimizer clear-cache      Clear validation cache');
-console.log('  mcp-prompt-optimizer help             Show this help');
-console.log('  mcp-prompt-optimizer version          Show version');
+
+console.log('🎯 Pricing Plans:');
+console.log('  Explorer: $2.99/month (5,000 optimizations)');
+console.log('  Creator: $25.99/month (18,000 optimizations)');
+console.log('  Innovator: $69.99/month (75,000 optimizations)');
+console.log('');
+
+console.log('🔄 Network Resilience:');
+console.log('  ✅ Automatic retry with exponential backoff');
+console.log('  ✅ Intelligent caching (24h normal, 7d fallback)');
+console.log('  ✅ Graceful degradation during outages');
+console.log('  ✅ Fallback mode with reduced functionality');
+console.log('  ✅ Development mode for offline testing');
 console.log('');
-console.log('🏢 Enterprise Solutions:');
-console.log('  Custom deployment options available');
-console.log('  Higher quotas and dedicated support');
-console.log('  Contact: enterprise@promptoptimizer.help');
+
+console.log('📚 Documentation & Support:');
+console.log('  📖 Docs: https://promptoptimizer-blog.vercel.app/docs');
+console.log('  💰 Pricing: https://promptoptimizer-blog.vercel.app/pricing');
+console.log('  🎛️ Dashboard: https://promptoptimizer-blog.vercel.app/dashboard');
+console.log('  📧 Support: support@promptoptimizer.help');
 console.log('');
-console.log('📧 Support: support@promptoptimizer.help');
+
+console.log('🚀 Quick Start:');
+console.log('  Production: export OPTIMIZER_API_KEY=sk-opt-your-key');
+console.log('  Development: export OPTIMIZER_DEV_MODE=true && export OPTIMIZER_API_KEY=sk-dev-test');
+console.log('  1. mcp-prompt-optimizer validate-key');
+console.log('  2. Configure your MCP client');
+console.log('  3. Start optimizing prompts!');
+}
+
+// ✅ Enhanced CLI command handling
+async function handleCLICommand() {
+const command = process.argv[2];
+
+switch (command) {
+  case 'validate-key':
+    const validateKey = require('./lib/validate-key');
+    await validateKey();
+    break;
+    
+  case 'check-status':
+    const checkStatus = require('./lib/check-status');
+    await checkStatus();
+    break;
+    
+  case 'clear-cache':
+    const clearCache = require('./lib/clear-cache');
+    await clearCache();
+    break;
+    
+  case 'test':
+    const testIntegration = require('./lib/test-integration');
+    await testIntegration();
+    break;
+    
+  case 'diagnose':
+    const diagnose = require('./lib/diagnose');
+    await diagnose();
+    break;
+    
+  case 'help':
+  case '--help':
+  case '-h':
+    await showInfo();
+    break;
+    
+  case 'version':
+  case '--version':
+  case '-v':
+    console.log(`MCP Prompt Optimizer v${packageJson.version}`);
+    console.log(`Production-grade with network resilience and development mode`);
+    console.log(`Documentation: https://promptoptimizer-blog.vercel.app/docs`);
+    break;
+    
+  default:
+    // No command provided, start MCP server
+    await startValidatedMCPServer();
+    break;
+}
 }
 
-// ✅ NEW: Enhanced CLI command handling (following local pattern)
+// Main execution
 if (require.main === module) {
-const args = process.argv.slice(2);
-
-if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
-  showInfo();
-} else if (args.includes('--version') || args.includes('-v') || args.includes('version')) {
-  try {
-    const packageJson = require('./package.json');
-    console.log(`mcp-prompt-optimizer v${packageJson.version}`);
-    console.log('Professional Cloud-Based MCP Server - Starting at $2.99/month');
-    console.log('🌐 Get started: https://promptoptimizer-blog.vercel.app/pricing');
-  } catch (error) {
-    console.log('mcp-prompt-optimizer v1.3.0');
-    console.log('Professional Cloud-Based MCP Server - Starting at $2.99/month');
-    console.log('🌐 Get started: https://promptoptimizer-blog.vercel.app/pricing');
+handleCLICommand().catch(error => {
+  console.error(`❌ Command failed: ${error.message}`);
+  
+  // Enhanced error handling with context-specific guidance
+  if (error.message.includes('Cannot find module')) {
+    console.error('\n🔧 Module Error:');
+    console.error('   - Ensure all dependencies are installed: npm install');
+    console.error('   - Check that lib/ directory exists with CLI tools');
+    console.error('   - Reinstall package: npm install -g mcp-prompt-optimizer');
+  } else if (error.message.includes('API key')) {
+    console.error('\n🔑 API Key Issue:');
+    console.error('   - Set your API key: export OPTIMIZER_API_KEY=sk-opt-...');
+    console.error('   - Get API key: https://promptoptimizer-blog.vercel.app/pricing');
+    console.error('   - Validate key: mcp-prompt-optimizer validate-key');
+    console.error('   - Try development mode: export OPTIMIZER_DEV_MODE=true');
+  } else if (error.message.includes('Network') || error.message.includes('timeout') || error.message.includes('DNS')) {
+    console.error('\n🌐 Network Issue:');
+    console.error('   - Check internet connection');
+    console.error('   - Verify firewall/proxy settings');
+    console.error('   - Try development mode: export OPTIMIZER_DEV_MODE=true');
+    console.error('   - Try again in a moment');
+  } else {
+    console.error('\n🛠️ General Troubleshooting:');
+    console.error('   1. Run diagnostic: mcp-prompt-optimizer diagnose');
+    console.error('   2. Check status: mcp-prompt-optimizer check-status');
+    console.error('   3. Clear cache: mcp-prompt-optimizer clear-cache');
+    console.error('   4. Try development mode: export OPTIMIZER_DEV_MODE=true');
+    console.error('   5. Contact support: support@promptoptimizer.help');
   }
-} else if (args.includes('check-status') || args.includes('status')) {
-  // ✅ NEW: CLI command integration
-  require('./lib/check-status');
-} else if (args.includes('validate-key')) {
-  // ✅ NEW: CLI command integration
-  require('./lib/validate-key');
-} else if (args.includes('clear-cache') || args.includes('clear')) {
-  // ✅ NEW: CLI command integration
-  require('./lib/clear-cache');
-} else if (process.stdin.isTTY) {
-  // Running in terminal - show info
-  showInfo();
-} else {
-  // ✅ UPDATED: Running via MCP protocol - start server with validation
-  startValidatedMCPServer();
-}
+  
+  process.exit(1);
+});
 }
 
-module.exports = MCPPromptOptimizer;
+// Export for testing - compatible with both require('./index.js') and new require('./index.js')()
+module.exports = MCPPromptOptimizer;
+module.exports.MCPPromptOptimizer = MCPPromptOptimizer;
+module.exports.startValidatedMCPServer = startValidatedMCPServer;
+module.exports.showInfo = showInfo;