polydev-ai 1.6.1 → 1.8.1

package/lib/cliManager.js

@@ -378,7 +378,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
     }
   }
 
-  async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null) {
+  async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null, model = null) {
     // Set provider-specific default timeouts (180s for all by default, complex prompts take time)
     if (timeoutMs === null) {
       timeoutMs = 180000; // 180 seconds default for all providers
@@ -424,6 +424,13 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
         };
       }
 
+      // Log model being used
+      if (model) {
+        console.log(`[Polydev CLI] Using model for ${providerId}: ${model}`);
+      } else {
+        console.log(`[Polydev CLI] No model specified for ${providerId}, using CLI default`);
+      }
+
       const promptVariants = [
         provider.subcommands?.test_prompt ? [...provider.subcommands.test_prompt] : []
       ];
@@ -437,7 +444,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
       if (providerId === 'codex_cli') {
         const execArgs = promptVariants.find(args => args.includes('exec')) || promptVariants[0];
         try {
-          const content = await this.executeCodexExec(provider.command, execArgs, prompt, timeoutMs);
+          const content = await this.executeCodexExec(provider.command, execArgs, prompt, timeoutMs, model);
           return {
             success: true,
             content,
@@ -445,6 +452,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
             latency_ms: Date.now() - startTime,
             provider: providerId,
             mode: 'args',
+            model_used: model || 'cli_default',
             timestamp: new Date()
           };
         } catch (error) {
@@ -462,7 +470,25 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
       let lastErrorMessage = null;
 
       for (const promptArgs of promptVariants) {
-        const args = Array.isArray(promptArgs) ? [...promptArgs, prompt] : [prompt];
+        // Build args with model flag if specified
+        let args = Array.isArray(promptArgs) ? [...promptArgs] : [];
+        
+        // Add model flag based on CLI type
+        if (model) {
+          if (providerId === 'claude_code') {
+            // Claude Code uses --model flag
+            args = ['--model', model, ...args, prompt];
+          } else if (providerId === 'gemini_cli') {
+            // Gemini CLI uses -m flag
+            args = ['-m', model, ...args, prompt];
+          } else {
+            // Default: just append prompt
+            args = [...args, prompt];
+          }
+        } else {
+          args = [...args, prompt];
+        }
+
         try {
           const result = await this.executeCliCommand(
             provider.command,
@@ -481,6 +507,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
               latency_ms: Date.now() - startTime,
               provider: providerId,
               mode: 'args',
+              model_used: model || 'cli_default',
               timestamp: new Date()
             };
           }
@@ -488,6 +515,37 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
           lastErrorMessage = result.error;
         } catch (error) {
           lastErrorMessage = error instanceof Error ? error.message : String(error);
+          
+          // If model was specified and command failed, retry without model (graceful fallback)
+          if (model && lastErrorMessage.includes('model')) {
+            console.log(`[Polydev CLI] Model ${model} may be invalid for ${providerId}, retrying without model flag`);
+            try {
+              const fallbackArgs = Array.isArray(promptArgs) ? [...promptArgs, prompt] : [prompt];
+              const fallbackResult = await this.executeCliCommand(
+                provider.command,
+                fallbackArgs,
+                'args',
+                timeoutMs,
+                undefined
+              );
+              
+              if (!fallbackResult.error) {
+                const content = this.cleanCliResponse(fallbackResult.stdout || '');
+                return {
+                  success: true,
+                  content,
+                  tokens_used: this.estimateTokens(prompt + content),
+                  latency_ms: Date.now() - startTime,
+                  provider: providerId,
+                  mode: 'args',
+                  model_used: 'cli_default_fallback',
+                  timestamp: new Date()
+                };
+              }
+            } catch (fallbackError) {
+              // Fallback also failed, continue with original error
+            }
+          }
         }
       }
 
@@ -609,7 +667,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
     });
   }
 
-  async executeCodexExec(executable, commandArgs, prompt, timeoutMs) {
+  async executeCodexExec(executable, commandArgs, prompt, timeoutMs, model = null) {
     if (!executable) {
       throw new Error('Missing Codex executable');
     }
@@ -619,15 +677,26 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
     }
 
     const workingDir = process.cwd();
-    const args = [
-      ...commandArgs,
+    
+    // Build args with optional model flag
+    // Codex CLI uses -m or --model flag
+    let args = [...commandArgs];
+    
+    // Add model flag if specified
+    if (model) {
+      args.push('-m', model);
+      console.log(`[CLI Debug] Codex using model: ${model}`);
+    }
+    
+    // Add standard flags and prompt
+    args.push(
       '--sandbox',
       'workspace-write',
       '--skip-git-repo-check',
       '--cd',
       workingDir,
       prompt
-    ];
+    );
 
     return new Promise((resolve, reject) => {
       const baseTmp = process.env.POLYDEV_CLI_TMPDIR || process.env.TMPDIR || os.tmpdir();

package/mcp/stdio-wrapper.js

@@ -116,6 +116,11 @@ class StdioMCPWrapper {
     
     // Smart refresh scheduler (will be started after initialization)
     this.refreshScheduler = null;
+    
+    // Cache for user model preferences (provider -> model)
+    this.userModelPreferences = null;
+    this.modelPreferencesCacheTime = null;
+    this.MODEL_PREFERENCES_CACHE_TTL = 5 * 60 * 1000; // 5 minutes cache
   }
 
   loadManifest() {
@@ -452,12 +457,26 @@ class StdioMCPWrapper {
       // Use reasonable timeout for CLI responses (180 seconds for complex prompts)
       const gracefulTimeout = Math.min(timeout_ms, 180000);
 
+      // Fetch user's model preferences (cached, non-blocking on failure)
+      let modelPreferences = {};
+      try {
+        modelPreferences = await this.fetchUserModelPreferences();
+      } catch (prefError) {
+        console.error('[Stdio Wrapper] Model preferences fetch failed (will use CLI defaults):', prefError.message);
+      }
+
       let localResults = [];
 
       if (provider_id) {
         // Specific provider requested - use only that one
         console.error(`[Stdio Wrapper] Using specific provider: ${provider_id}`);
-        const result = await this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout);
+        const model = modelPreferences[provider_id] || null;
+        if (model) {
+          console.error(`[Stdio Wrapper] Using user's preferred model for ${provider_id}: ${model}`);
+        } else {
+          console.error(`[Stdio Wrapper] No model preference for ${provider_id}, using CLI default`);
+        }
+        const result = await this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout, model);
         localResults = [{ provider_id, ...result }];
       } else {
         // No specific provider - use ALL available local CLIs
@@ -473,7 +492,11 @@ class StdioMCPWrapper {
           // Run all CLI prompts concurrently
           const cliPromises = availableProviders.map(async (providerId) => {
             try {
-              const result = await this.cliManager.sendCliPrompt(providerId, prompt, mode, gracefulTimeout);
+              const model = modelPreferences[providerId] || null;
+              if (model) {
+                console.error(`[Stdio Wrapper] Using user's preferred model for ${providerId}: ${model}`);
+              }
+              const result = await this.cliManager.sendCliPrompt(providerId, prompt, mode, gracefulTimeout, model);
               return { provider_id: providerId, ...result };
             } catch (error) {
               console.error(`[Stdio Wrapper] CLI ${providerId} failed:`, error.message);
@@ -490,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);
 
@@ -542,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 = {
@@ -557,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()}`
@@ -1020,6 +1163,87 @@ class StdioMCPWrapper {
     }
   }
 
+  /**
+   * Fetch user's model preferences from API keys
+   * Returns a map of CLI provider -> default_model
+   */
+  async fetchUserModelPreferences() {
+    // Check cache first
+    if (this.userModelPreferences && this.modelPreferencesCacheTime) {
+      const cacheAge = Date.now() - this.modelPreferencesCacheTime;
+      if (cacheAge < this.MODEL_PREFERENCES_CACHE_TTL) {
+        console.error('[Stdio Wrapper] Using cached model preferences');
+        return this.userModelPreferences;
+      }
+    }
+
+    console.error('[Stdio Wrapper] Fetching user model preferences from API...');
+    
+    try {
+      // Call the dedicated model-preferences endpoint
+      const response = await fetch('https://www.polydev.ai/api/model-preferences', {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${this.userToken}`,
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        }
+      });
+
+      if (!response.ok) {
+        console.error('[Stdio Wrapper] Failed to fetch model preferences:', response.status);
+        return this.userModelPreferences || {};
+      }
+
+      const result = await response.json();
+      
+      if (result.success && result.modelPreferences) {
+        // Cache the preferences
+        this.userModelPreferences = result.modelPreferences;
+        this.modelPreferencesCacheTime = Date.now();
+        
+        console.error('[Stdio Wrapper] Model preferences loaded:', JSON.stringify(result.modelPreferences));
+        return result.modelPreferences;
+      } else {
+        console.error('[Stdio Wrapper] No model preferences in response');
+        return this.userModelPreferences || {};
+      }
+
+    } catch (error) {
+      console.error('[Stdio Wrapper] Error fetching model preferences:', error.message);
+      return this.userModelPreferences || {};
+    }
+  }
+
+  /**
+   * Map provider name to CLI provider ID
+   */
+  mapProviderToCli(provider) {
+    const providerLower = (provider || '').toLowerCase().trim();
+    
+    // Map provider names to CLI tool IDs
+    const providerMap = {
+      'anthropic': 'claude_code',
+      'anthropic-ai': 'claude_code',
+      'claude': 'claude_code',
+      'openai': 'codex_cli',
+      'open-ai': 'codex_cli',
+      'gpt': 'codex_cli',
+      'google': 'gemini_cli',
+      'google-ai': 'gemini_cli',
+      'gemini': 'gemini_cli'
+    };
+    
+    return providerMap[providerLower] || null;
+  }
+
+  /**
+   * Get model for a specific CLI provider
+   */
+  async getModelForProvider(providerId) {
+    const preferences = await this.fetchUserModelPreferences();
+    return preferences[providerId] || null;
+  }
+
   async start() {
     console.log('Starting Polydev Stdio MCP Wrapper...');
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.6.1",
+  "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",