polydev-ai 1.0.0 → 1.0.1

package/mcp/manifest.json

@@ -441,6 +441,232 @@
           }
         }
       ]
+    },
+    {
+      "name": "polydev.detect_memory_sources",
+      "description": "Detect all available memory sources across CLI tools (Claude Code, Cline, Codex, Cursor, Continue, Aider). Returns file paths for global memory, project memory, and recent conversations.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "project_path": {
+            "type": "string",
+            "description": "Project directory path to scan for memory sources",
+            "default": "."
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["claude_code", "cline", "codex_cli", "cursor", "continue", "aider", "generic", "all"]
+            },
+            "description": "CLI tools to detect memory for",
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array", 
+            "items": {
+              "type": "string",
+              "enum": ["global", "project", "conversation", "config"]
+            },
+            "description": "Types of memory to detect",
+            "default": ["global", "project", "conversation"]
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": { "type": "boolean" },
+          "sources": {
+            "type": "array",
+            "items": {
+              "type": "object", 
+              "properties": {
+                "cli_tool": { "type": "string" },
+                "memory_type": { "type": "string" },
+                "file_path": { "type": "string" },
+                "exists": { "type": "boolean" },
+                "size_bytes": { "type": "number" },
+                "last_modified": { "type": "string" }
+              }
+            }
+          },
+          "summary": {
+            "type": "object",
+            "properties": {
+              "total_sources": { "type": "number" },
+              "sources_by_tool": { "type": "object" },
+              "sources_by_type": { "type": "object" }
+            }
+          }
+        }
+      }
+    },
+    {
+      "name": "polydev.extract_memory", 
+      "description": "Extract and optionally encrypt memory content from detected CLI tool sources. Provides TF-IDF relevance scoring and content analysis.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token for server storage",
+            "minLength": 1
+          },
+          "project_path": {
+            "type": "string", 
+            "description": "Project directory path",
+            "default": "."
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["global", "project", "conversation"]
+          },
+          "encryption_enabled": { 
+            "type": "boolean", 
+            "description": "Enable zero-knowledge encryption for extracted content",
+            "default": true 
+          },
+          "max_file_size_kb": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 1000,
+            "default": 500
+          },
+          "relevance_threshold": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1,
+            "default": 0.3
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.get_recent_conversations",
+      "description": "Get recent conversations from CLI tools with TF-IDF relevance scoring against query context. Supports encrypted storage and retrieval.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token",
+            "minLength": 1
+          },
+          "query_context": { 
+            "type": "string", 
+            "description": "Current query for relevance scoring and context matching"
+          },
+          "limit": { 
+            "type": "integer", 
+            "minimum": 1, 
+            "maximum": 50, 
+            "default": 6 
+          },
+          "cli_tools": { 
+            "type": "array", 
+            "items": { "type": "string" },
+            "default": ["all"] 
+          },
+          "time_range_hours": { 
+            "type": "integer", 
+            "minimum": 1, 
+            "maximum": 168, 
+            "default": 24 
+          },
+          "project_path": {
+            "type": "string",
+            "default": "."
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.get_memory_context",
+      "description": "Get formatted memory and conversation context for injection into prompts. Automatically handles decryption and relevance scoring.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token", 
+            "minLength": 1
+          },
+          "query_context": {
+            "type": "string",
+            "description": "Query to find relevant memory and conversations for"
+          },
+          "max_memory_kb": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 200,
+            "default": 50
+          },
+          "max_conversations": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 20,
+            "default": 6
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["project", "conversation"]
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.manage_memory_preferences", 
+      "description": "Configure memory extraction and privacy preferences. Control which CLI tools and memory types are enabled, encryption settings, and context injection behavior.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token",
+            "minLength": 1
+          },
+          "action": {
+            "type": "string",
+            "enum": ["get", "update"],
+            "description": "Action to perform",
+            "default": "get"
+          },
+          "preferences": {
+            "type": "object",
+            "description": "Memory preferences to update",
+            "properties": {
+              "memory_enabled": { "type": "boolean" },
+              "privacy_mode": { "type": "boolean" },
+              "auto_extraction": { "type": "boolean" },
+              "cli_tools_enabled": { "type": "object" },
+              "memory_types_enabled": { "type": "object" },
+              "auto_inject_context": { "type": "boolean" },
+              "context_relevance_threshold": { "type": "number", "minimum": 0, "maximum": 1 },
+              "max_conversations_inject": { "type": "integer" },
+              "max_memory_inject_kb": { "type": "integer" },
+              "key_rotation_days": { "type": "integer" },
+              "cache_ttl_minutes": { "type": "integer" }
+            }
+          }
+        },
+        "required": ["user_token"]
+      }
     }
   ],
   "configuration": {

package/mcp/server.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const CLIManager = require('../lib/cliManager').default;
+const UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
 
 class MCPServer {
   constructor() {
@@ -14,6 +15,7 @@ class MCPServer {
     
     this.tools = new Map();
     this.cliManager = new CLIManager();
+    this.memoryExtractor = new UniversalMemoryExtractor();
     this.loadManifest();
   }
 
@@ -136,6 +138,26 @@ class MCPServer {
           result = await this.sendCliPrompt(args);
           break;
         
+        case 'polydev.detect_memory_sources':
+          result = await this.detectMemorySources(args);
+          break;
+        
+        case 'polydev.extract_memory':
+          result = await this.extractMemory(args);
+          break;
+        
+        case 'polydev.get_recent_conversations':
+          result = await this.getRecentConversations(args);
+          break;
+        
+        case 'polydev.get_memory_context':
+          result = await this.getMemoryContext(args);
+          break;
+        
+        case 'polydev.manage_memory_preferences':
+          result = await this.manageMemoryPreferences(args);
+          break;
+        
         default:
           throw new Error(`Tool ${name} not implemented`);
       }
@@ -172,6 +194,30 @@ class MCPServer {
       throw new Error('prompt is required and must be a string');
     }
 
+    // Auto-inject memory context if enabled and not already provided
+    let enhancedPrompt = args.prompt;
+    if (!args.project_memory && args.auto_inject_memory !== false) {
+      try {
+        console.error('[Polydev MCP] Attempting to inject memory context...');
+        const memoryContext = await this.getMemoryContext({
+          prompt: args.prompt,
+          cli_tools: ['all'],
+          max_entries: 3
+        });
+        
+        if (memoryContext.success && memoryContext.context.entries.length > 0) {
+          const contextText = memoryContext.context.entries
+            .map(entry => `[${entry.source}] ${entry.content.substring(0, 500)}`)
+            .join('\n\n');
+          
+          enhancedPrompt = `Context from previous work:\n${contextText}\n\nCurrent request:\n${args.prompt}`;
+          console.error(`[Polydev MCP] Injected ${memoryContext.context.entries.length} memory entries`);
+        }
+      } catch (error) {
+        console.error('[Polydev MCP] Memory injection failed, continuing without:', error.message);
+      }
+    }
+
     // Support both parameter token (Claude Code) and environment token (Cline)
     const userToken = args.user_token || process.env.POLYDEV_USER_TOKEN;
     
@@ -204,7 +250,11 @@ class MCPServer {
         method: 'tools/call',
         params: {
           name: 'get_perspectives',
-          arguments: args
+          arguments: {
+            ...args,
+            prompt: enhancedPrompt,
+            project_memory: enhancedPrompt !== args.prompt ? 'auto-injected' : args.project_memory
+          }
         },
         id: 1
       })
@@ -257,6 +307,13 @@ class MCPServer {
       case 'polydev.send_cli_prompt':
         return this.formatCliPromptResponse(result);
       
+      case 'polydev.detect_memory_sources':
+      case 'polydev.extract_memory':
+      case 'polydev.get_recent_conversations':
+      case 'polydev.get_memory_context':
+      case 'polydev.manage_memory_preferences':
+        return this.formatMemoryResponse(result);
+      
       default:
         return JSON.stringify(result, null, 2);
     }
@@ -536,6 +593,281 @@ class MCPServer {
     }
   }
 
+  /**
+   * Detect available memory sources across CLI tools
+   */
+  async detectMemorySources(args) {
+    console.log('[MCP Server] Detect memory sources requested');
+    
+    try {
+      const { cli_tools = ['all'] } = args;
+      
+      const sources = await this.memoryExtractor.detectMemorySources(cli_tools);
+      
+      return {
+        success: true,
+        sources,
+        message: `Detected ${Object.keys(sources).length} memory sources`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Memory detection error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Extract memory from detected sources
+   */
+  async extractMemory(args) {
+    console.log('[MCP Server] Extract memory requested');
+    
+    try {
+      const { cli_tools = ['all'], memory_types = ['all'], project_path } = args;
+      
+      const extractedMemory = await this.memoryExtractor.extractMemory({
+        cliTools: cli_tools,
+        memoryTypes: memory_types,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        memory: extractedMemory,
+        message: `Extracted ${extractedMemory.totalEntries} memory entries`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Memory extraction error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get recent conversations from CLI tools
+   */
+  async getRecentConversations(args) {
+    console.log('[MCP Server] Get recent conversations requested');
+    
+    try {
+      const { cli_tools = ['all'], limit = 10, project_path } = args;
+      
+      const conversations = await this.memoryExtractor.getRecentConversations({
+        cliTools: cli_tools,
+        limit,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        conversations,
+        message: `Retrieved ${conversations.length} recent conversations`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Conversation retrieval error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get relevant memory context for current prompt
+   */
+  async getMemoryContext(args) {
+    console.log('[MCP Server] Get memory context requested');
+    
+    try {
+      const { prompt, cli_tools = ['all'], max_entries = 5, project_path } = args;
+      
+      if (!prompt) {
+        throw new Error('prompt is required for context retrieval');
+      }
+      
+      const context = await this.memoryExtractor.getRelevantContext({
+        prompt,
+        cliTools: cli_tools,
+        maxEntries: max_entries,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        context,
+        message: `Found ${context.entries.length} relevant context entries`,
+        relevanceScore: context.averageRelevance,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Context retrieval error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Manage memory preferences and settings
+   */
+  async manageMemoryPreferences(args) {
+    console.log('[MCP Server] Manage memory preferences requested');
+    
+    try {
+      const { action = 'get', preferences = {} } = args;
+      
+      let result;
+      
+      switch (action) {
+        case 'get':
+          result = await this.memoryExtractor.getPreferences();
+          break;
+        
+        case 'set':
+          result = await this.memoryExtractor.updatePreferences(preferences);
+          break;
+        
+        case 'reset':
+          result = await this.memoryExtractor.resetPreferences();
+          break;
+        
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      
+      return {
+        success: true,
+        preferences: result,
+        message: `Memory preferences ${action} completed`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Preferences management error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Format memory tool responses
+   */
+  formatMemoryResponse(result) {
+    if (!result.success) {
+      return `❌ Memory Operation Failed: ${result.error}`;
+    }
+
+    let formatted = `# Memory Operation Results\n\n`;
+    formatted += `✅ ${result.message}\n`;
+    formatted += `⏰ ${result.timestamp}\n\n`;
+
+    // Format specific results based on operation type
+    if (result.sources) {
+      formatted += this.formatMemorySourcesResult(result.sources);
+    } else if (result.memory) {
+      formatted += this.formatExtractedMemoryResult(result.memory);
+    } else if (result.conversations) {
+      formatted += this.formatConversationsResult(result.conversations);
+    } else if (result.context) {
+      formatted += this.formatContextResult(result.context, result.relevanceScore);
+    } else if (result.preferences) {
+      formatted += this.formatPreferencesResult(result.preferences);
+    }
+
+    return formatted;
+  }
+
+  formatMemorySourcesResult(sources) {
+    let formatted = `## 📁 Memory Sources Detected\n\n`;
+    
+    Object.entries(sources).forEach(([cliTool, toolSources]) => {
+      formatted += `### ${cliTool.toUpperCase().replace('_', ' ')}\n`;
+      
+      Object.entries(toolSources).forEach(([memoryType, files]) => {
+        const icon = memoryType === 'global' ? '🌍' : memoryType === 'project' ? '📂' : '💬';
+        formatted += `${icon} **${memoryType}**: ${files.length} sources\n`;
+        
+        files.forEach(file => {
+          const status = file.exists ? '✅' : '❌';
+          formatted += `  ${status} \`${file.path}\`\n`;
+        });
+      });
+      
+      formatted += `\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatExtractedMemoryResult(memory) {
+    let formatted = `## 🧠 Extracted Memory\n\n`;
+    formatted += `📊 **Total Entries**: ${memory.totalEntries}\n`;
+    formatted += `💾 **Total Size**: ${(memory.totalSize / 1024).toFixed(1)}KB\n\n`;
+    
+    Object.entries(memory.byCliTool).forEach(([cliTool, toolMemory]) => {
+      formatted += `### ${cliTool.toUpperCase().replace('_', ' ')}\n`;
+      formatted += `- Global: ${toolMemory.global.length} entries\n`;
+      formatted += `- Project: ${toolMemory.project.length} entries\n`;
+      formatted += `- Conversations: ${toolMemory.conversations.length} entries\n\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatConversationsResult(conversations) {
+    let formatted = `## 💬 Recent Conversations\n\n`;
+    
+    conversations.forEach((conv, index) => {
+      formatted += `### ${index + 1}. ${conv.cliTool.toUpperCase().replace('_', ' ')}\n`;
+      formatted += `📅 ${new Date(conv.timestamp).toLocaleString()}\n`;
+      formatted += `💭 ${conv.messageCount} messages, ${(conv.size / 1024).toFixed(1)}KB\n`;
+      
+      if (conv.topics && conv.topics.length > 0) {
+        formatted += `🏷️ Topics: ${conv.topics.join(', ')}\n`;
+      }
+      
+      formatted += `\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatContextResult(context, relevanceScore) {
+    let formatted = `## 🎯 Relevant Context\n\n`;
+    formatted += `📊 **Average Relevance**: ${(relevanceScore * 100).toFixed(1)}%\n\n`;
+    
+    context.entries.forEach((entry, index) => {
+      formatted += `### ${index + 1}. ${entry.source} (${(entry.relevance * 100).toFixed(1)}%)\n`;
+      formatted += `${entry.content.substring(0, 200)}...\n\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatPreferencesResult(preferences) {
+    let formatted = `## ⚙️ Memory Preferences\n\n`;
+    
+    Object.entries(preferences).forEach(([key, value]) => {
+      formatted += `- **${key}**: ${typeof value === 'object' ? JSON.stringify(value) : value}\n`;
+    });
+    
+    return formatted;
+  }
+
   // CLI status and usage tracking is handled locally by CLIManager
   // No database integration needed - this MCP server runs independently
 

package/mcp/stdio-wrapper.js

@@ -3,7 +3,7 @@
 // Lightweight stdio wrapper with local CLI functionality and remote Polydev MCP server fallback
 const fs = require('fs');
 const path = require('path');
-const CLIManager = require('../lib/cliManager').default;
+const { CLIManager } = require('../lib/cliManager');
 
 class StdioMCPWrapper {
   constructor() {
@@ -204,7 +204,7 @@ class StdioMCPWrapper {
       const providerId = args.provider_id; // Optional - detect specific provider
       
       // Force detection using CLI Manager (no remote API calls)
-      const results = await this.cliManager.forceCliDetection(null, providerId);
+      const results = await this.cliManager.forceCliDetection(providerId);
       
       // Save status locally to file-based cache
       await this.saveLocalCliStatus(results);
@@ -241,13 +241,13 @@ class StdioMCPWrapper {
       if (providerId) {
         // Get specific provider status
         const status = await this.cliManager.getCliStatus(providerId);
-        results[providerId] = status;
+        results = status;
       } else {
         // Get all providers status
-        const providers = this.cliManager.getProviders();
+        const providers = this.cliManager.getAvailableProviders();
         for (const provider of providers) {
           const status = await this.cliManager.getCliStatus(provider.id);
-          results[provider.id] = status;
+          results[provider.id] = status[provider.id];
         }
       }
 
@@ -271,10 +271,10 @@ class StdioMCPWrapper {
   }
 
   /**
-   * Local CLI prompt sending
+   * Local CLI prompt sending with remote perspectives fallback/supplement
    */
   async localSendCliPrompt(args) {
-    console.error(`[Stdio Wrapper] Local CLI prompt sending`);
+    console.error(`[Stdio Wrapper] Local CLI prompt sending with perspectives`);
     
     try {
       const { provider_id, prompt, mode = 'args', timeout_ms = 30000 } = args;
@@ -283,29 +283,37 @@ class StdioMCPWrapper {
         throw new Error('provider_id and prompt are required');
       }
 
-      // Send prompt using CLI Manager (local execution)
-      const response = await this.cliManager.sendCliPrompt(
-        provider_id, 
-        prompt, 
-        mode, 
-        timeout_ms
-      );
-
-      // Record usage locally (file-based analytics)
-      await this.recordLocalUsage(provider_id, prompt, response);
+      // Use shorter timeout for faster fallback (5 seconds instead of 30)
+      const gracefulTimeout = Math.min(timeout_ms, 5000);
+      
+      // Start both operations concurrently for better performance
+      const [localResult, perspectivesResult] = await Promise.allSettled([
+        this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout),
+        this.callPerspectivesForCli(args, null)
+      ]);
+
+      // Process results
+      const localResponse = localResult.status === 'fulfilled' ? localResult.value : {
+        success: false,
+        error: `CLI check failed: ${localResult.reason?.message || 'Unknown error'}`,
+        latency_ms: gracefulTimeout,
+        timestamp: new Date().toISOString()
+      };
 
-      return {
-        success: response.success,
-        content: response.content,
-        error: response.error,
-        tokens_used: response.tokensUsed,
-        latency_ms: response.latencyMs,
-        provider: provider_id,
-        mode,
-        timestamp: new Date().toISOString(),
-        local_only: true
+      const perspectivesResponse = perspectivesResult.status === 'fulfilled' ? perspectivesResult.value : {
+        success: false,
+        error: `Perspectives failed: ${perspectivesResult.reason?.message || 'Unknown error'}`,
+        timestamp: new Date().toISOString()
       };
 
+      // Record usage locally (file-based analytics) - non-blocking
+      this.recordLocalUsage(provider_id, prompt, localResponse).catch(err => {
+        console.error('[Stdio Wrapper] Usage recording failed (non-critical):', err.message);
+      });
+
+      // Combine results
+      return this.combineCliAndPerspectives(localResponse, perspectivesResponse, args);
+
     } catch (error) {
       console.error('[Stdio Wrapper] Local CLI prompt error:', error);
       return {
@@ -317,6 +325,132 @@ class StdioMCPWrapper {
     }
   }
 
+  /**
+   * Call remote perspectives for CLI prompts
+   */
+  async callPerspectivesForCli(args, localResult) {
+    console.error(`[Stdio Wrapper] Calling remote perspectives for CLI prompt`);
+    
+    try {
+      const perspectivesRequest = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        params: {
+          name: 'get_perspectives',
+          arguments: {
+            prompt: args.prompt,
+            user_token: this.userToken,
+            // Let the remote server use user's configured preferences for models
+            // Don't specify models to use dashboard defaults
+            project_memory: 'none',
+            temperature: 0.7,
+            max_tokens: 2000
+          }
+        },
+        id: `perspectives-${Date.now()}`
+      };
+
+      const remoteResponse = await this.forwardToRemoteServer(perspectivesRequest);
+      
+      if (remoteResponse.result && remoteResponse.result.content && remoteResponse.result.content[0]) {
+        return {
+          success: true,
+          content: remoteResponse.result.content[0].text,
+          timestamp: new Date().toISOString()
+        };
+      } else if (remoteResponse.error) {
+        return {
+          success: false,
+          error: remoteResponse.error.message || 'Remote perspectives failed',
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        return {
+          success: false,
+          error: 'Unexpected remote response format',
+          timestamp: new Date().toISOString()
+        };
+      }
+    } catch (error) {
+      console.error('[Stdio Wrapper] Perspectives call error:', error);
+      return {
+        success: false,
+        error: `Perspectives request failed: ${error.message}`,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Combine local CLI and remote perspectives results
+   */
+  combineCliAndPerspectives(localResult, perspectivesResult, args) {
+    const combinedResult = {
+      success: true,
+      timestamp: new Date().toISOString(),
+      provider: args.provider_id,
+      mode: args.mode,
+      sections: {
+        local: localResult,
+        remote: perspectivesResult
+      }
+    };
+
+    // Determine overall success and fallback status
+    if (localResult.success && perspectivesResult.success) {
+      combinedResult.content = this.formatCombinedResponse(localResult, perspectivesResult, false);
+      combinedResult.tokens_used = localResult.tokens_used || 0;
+      combinedResult.latency_ms = localResult.latency_ms || 0;
+    } else if (!localResult.success && perspectivesResult.success) {
+      // Fallback case
+      combinedResult.content = this.formatCombinedResponse(localResult, perspectivesResult, true);
+      combinedResult.fallback_used = true;
+      combinedResult.tokens_used = 0; // No local tokens used
+    } else if (localResult.success && !perspectivesResult.success) {
+      // Local succeeded, remote failed
+      combinedResult.content = this.formatCombinedResponse(localResult, perspectivesResult, false);
+      combinedResult.tokens_used = localResult.tokens_used || 0;
+      combinedResult.latency_ms = localResult.latency_ms || 0;
+    } else {
+      // Both failed
+      combinedResult.success = false;
+      combinedResult.error = `Local CLI failed: ${localResult.error}; Perspectives also failed: ${perspectivesResult.error}`;
+    }
+
+    return combinedResult;
+  }
+
+  /**
+   * Format combined response text
+   */
+  formatCombinedResponse(localResult, perspectivesResult, isFallback) {
+    let formatted = '';
+
+    if (localResult.success) {
+      // Local CLI succeeded
+      formatted += `🟢 **Local CLI Response** (${localResult.provider} - ${localResult.mode} mode)\n\n`;
+      formatted += `${localResult.content}\n\n`;
+      formatted += `*Latency: ${localResult.latency_ms || 0}ms | Tokens: ${localResult.tokens_used || 0}*\n\n`;
+      formatted += `---\n\n`;
+    } else if (isFallback) {
+      // Local CLI failed, using fallback
+      formatted += `⚠️ **Local CLI unavailable**: ${localResult.error}\n`;
+      formatted += `Using perspectives fallback.\n\n`;
+      formatted += `---\n\n`;
+    }
+
+    if (perspectivesResult.success) {
+      const title = isFallback ? '🧠 **Perspectives Fallback**' : '🧠 **Supplemental Multi-Model Perspectives**';
+      formatted += `${title}\n\n`;
+      formatted += `${perspectivesResult.content}\n\n`;
+    } else if (!isFallback) {
+      // Show remote error only if not in fallback mode
+      formatted += `❌ **Perspectives request failed**: ${perspectivesResult.error}\n\n`;
+    }
+
+    return formatted.trim();
+  }
+
   /**
    * Save CLI status to local file cache
    */
@@ -354,10 +488,20 @@ class StdioMCPWrapper {
       const polydevevDir = path.join(homeDir, '.polydev');
       const usageFile = path.join(polydevevDir, 'cli-usage.json');
 
+      // Ensure directory exists
+      if (!fs.existsSync(polydevevDir)) {
+        fs.mkdirSync(polydevevDir, { recursive: true });
+      }
+
       // Load existing usage data
       let usageData = [];
       if (fs.existsSync(usageFile)) {
-        usageData = JSON.parse(fs.readFileSync(usageFile, 'utf8'));
+        try {
+          usageData = JSON.parse(fs.readFileSync(usageFile, 'utf8'));
+        } catch (parseError) {
+          console.error('[Stdio Wrapper] Failed to parse existing usage file, starting fresh:', parseError);
+          usageData = [];
+        }
       }
 
       // Add new usage record
@@ -366,8 +510,8 @@ class StdioMCPWrapper {
         provider: providerId,
         prompt_length: prompt.length,
         success: response.success,
-        latency_ms: response.latencyMs,
-        tokens_used: response.tokensUsed || 0
+        latency_ms: response.latency_ms || response.latencyMs || 0,
+        tokens_used: response.tokens_used || response.tokensUsed || 0
       });
 
       // Keep only last 1000 records
@@ -379,7 +523,8 @@ class StdioMCPWrapper {
       console.error(`[Stdio Wrapper] Usage recorded locally`);
 
     } catch (error) {
-      console.error('[Stdio Wrapper] Failed to record local usage:', error);
+      console.error('[Stdio Wrapper] Failed to record local usage (non-critical):', error.message);
+      // Don't throw - this is non-critical functionality
     }
   }
 
@@ -391,8 +536,13 @@ class StdioMCPWrapper {
       return `❌ **CLI Error**\n\n${result.error}\n\n*Timestamp: ${result.timestamp}*`;
     }
 
+    // Handle combined CLI + perspectives response
+    if (result.sections) {
+      return result.content;
+    }
+
     if (result.content) {
-      // Prompt response
+      // Standard prompt response
       return `✅ **CLI Response** (${result.provider || 'Unknown'} - ${result.mode || 'unknown'} mode)\n\n${result.content}\n\n*Latency: ${result.latency_ms || 0}ms | Tokens: ${result.tokens_used || 0} | ${result.timestamp}*`;
     } else {
       // Status/detection response

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",
@@ -59,6 +59,7 @@
     "lucide-react": "^0.542.0",
     "marked": "^16.2.1",
     "next": "15.0.0",
+    "polydev-ai": "^1.0.0",
     "posthog-js": "^1.157.2",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",