polydev-ai 1.7.0 → 1.8.1

package/mcp/stdio-wrapper.js

@@ -513,6 +513,11 @@ class StdioMCPWrapper {
         }
       }
 
+      // Report CLI results to server for dashboard storage (non-blocking)
+      this.reportCliResultsToServer(prompt, localResults, args).catch(err => {
+        console.error('[Stdio Wrapper] CLI results reporting failed (non-critical):', err.message);
+      });
+
       // Get remote perspectives (only for models not covered by local CLIs)
       const perspectivesResult = await this.callPerspectivesForCli(args, localResults);
 
@@ -565,11 +570,124 @@ class StdioMCPWrapper {
     }
   }
 
+  /**
+   * Report CLI results to server for dashboard storage
+   * This stores CLI results in Supabase so they appear in the dashboard
+   */
+  async reportCliResultsToServer(prompt, localResults, args = {}) {
+    // Only report if we have successful CLI results
+    const successfulResults = localResults.filter(r => r.success);
+    if (successfulResults.length === 0) {
+      console.error('[Stdio Wrapper] No successful CLI results to report');
+      return;
+    }
+
+    if (!this.userToken) {
+      console.error('[Stdio Wrapper] No user token available for CLI results reporting');
+      return;
+    }
+
+    try {
+      const cliResults = localResults.map(result => ({
+        provider_id: result.provider_id,
+        model: result.model || this.getDefaultModelForCli(result.provider_id),
+        content: result.content || '',
+        tokens_used: result.tokens_used || 0,
+        latency_ms: result.latency_ms || 0,
+        success: result.success || false,
+        error: result.error || null
+      }));
+
+      const reportPayload = {
+        prompt: prompt,
+        cli_results: cliResults,
+        temperature: args.temperature || 0.7,
+        max_tokens: args.max_tokens || 20000
+      };
+
+      const response = await fetch(`${this.serverUrl.replace('/mcp', '')}/api/mcp/report-cli-results`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.userToken}`,
+          'Content-Type': 'application/json',
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        },
+        body: JSON.stringify(reportPayload)
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error('[Stdio Wrapper] Failed to report CLI results:', response.status, errorText);
+        return;
+      }
+
+      const result = await response.json();
+      console.error(`[Stdio Wrapper] CLI results reported to dashboard: ${result.stored} results stored`);
+      
+    } catch (error) {
+      // Non-critical - log and continue
+      console.error('[Stdio Wrapper] Error reporting CLI results (non-critical):', error.message);
+    }
+  }
+
+  /**
+   * Get default model name for a CLI tool (used when model not specified in result)
+   */
+  getDefaultModelForCli(providerId) {
+    const defaults = {
+      'claude_code': 'claude-sonnet-4-20250514',
+      'codex_cli': 'gpt-4.1',
+      'gemini_cli': 'gemini-2.5-pro'
+    };
+    return defaults[providerId] || providerId;
+  }
+
   /**
    * Call remote perspectives for CLI prompts
+   * Only calls remote APIs for providers NOT covered by successful local CLIs
    */
   async callPerspectivesForCli(args, localResults) {
-    console.error(`[Stdio Wrapper] Calling remote perspectives for CLI prompt`);
+    // Determine which providers succeeded locally
+    const successfulLocalProviders = localResults
+      .filter(r => r.success)
+      .map(r => r.provider_id);
+    
+    // Map CLI provider IDs to API provider names for exclusion
+    const cliToApiProvider = {
+      'claude_code': 'anthropic',
+      'codex_cli': 'openai', 
+      'gemini_cli': 'google'
+    };
+    
+    const excludeProviders = successfulLocalProviders
+      .map(cli => cliToApiProvider[cli])
+      .filter(Boolean);
+    
+    // If all major providers are covered locally, skip remote call entirely
+    if (excludeProviders.length >= 3 || 
+        (excludeProviders.includes('anthropic') && excludeProviders.includes('openai') && excludeProviders.includes('google'))) {
+      console.error(`[Stdio Wrapper] All providers covered by local CLIs, skipping remote perspectives`);
+      return {
+        success: true,
+        content: '',
+        skipped: true,
+        reason: 'All providers covered by local CLIs',
+        timestamp: new Date().toISOString()
+      };
+    }
+    
+    console.error(`[Stdio Wrapper] Calling remote perspectives (excluding: ${excludeProviders.join(', ') || 'none'})`);
+    
+    // Format CLI responses for logging on the server
+    const cliResponses = localResults.map(result => ({
+      provider_id: result.provider_id,
+      model: result.model || this.getDefaultModelForCli(result.provider_id),
+      content: result.content || '',
+      tokens_used: result.tokens_used || 0,
+      latency_ms: result.latency_ms || 0,
+      success: result.success || false,
+      error: result.error || null
+    }));
     
     try {
       const perspectivesRequest = {
@@ -580,11 +698,13 @@ class StdioMCPWrapper {
           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
+            // Exclude providers that succeeded locally
+            exclude_providers: excludeProviders,
+            // Pass CLI responses for dashboard logging
+            cli_responses: cliResponses,
             project_memory: 'none',
             temperature: 0.7,
-            max_tokens: 2000
+            max_tokens: 20000
           }
         },
         id: `perspectives-${Date.now()}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",