polydev-ai 1.8.99 → 1.9.1

package/mcp/stdio-wrapper.js

@@ -438,16 +438,14 @@ Token will be saved automatically after login.`
         result: {
           content: [{
             type: 'text',
-            text: `╭─────────────────────────────────────────╮
-│        ALREADY AUTHENTICATED ✓          │
-╰─────────────────────────────────────────╯
+            text: `ALREADY AUTHENTICATED
+=====================
 
-🔐 Your token is configured and ready.
+Your token is configured and ready.
 
-🤖 Available commands:
-  • /polydev:ask - Query multiple AI models
-  • /polydev:auth - Check status & credits
-  • get_perspectives - Direct tool call
+Available commands:
+  /polydev:ask   Query multiple AI models
+  /polydev:auth  Check status & credits
 
 To re-login: npx polydev-ai`
           }]
@@ -507,19 +505,20 @@ To re-login: npx polydev-ai`
         result: {
           content: [{
             type: 'text',
-            text: `╭─────────────────────────────────────────╮
-│     BROWSER OPENED FOR LOGIN 🌐        │
-╰─────────────────────────────────────────╯
+            text: `LOGIN SUCCESSFUL
+================
 
-📱 Complete authentication in your browser.
+Token saved to:
+  ~/.polydev.env
+  ~/.zshrc
 
-After login:
-  • Token will be saved automatically
-  • You can safely reconnect MCP or restart IDE
-  • Use /polydev:auth to check status
+IMPORTANT: Restart your IDE to activate.
 
-⏳ Polling for authentication completion...
-   (Session expires in 10 minutes)`
+After restart, you can:
+  /polydev:ask   Query multiple AI models
+  /polydev:auth  Check status & credits
+
+Dashboard: https://polydev.ai/dashboard`
           }]
         }
       };
@@ -569,7 +568,7 @@ After login:
           this.isAuthenticated = true;
           this._freshLogin = true;
           
-          console.error('[Polydev] ✓ Login successful! Token saved.');
+          console.error('[Polydev] Login successful! Token saved.');
           console.error('[Polydev] You can now use Polydev tools.');
           console.error('[Polydev] No restart required - token is active immediately.');
           return; // Stop polling
@@ -1096,7 +1095,7 @@ Error: ${error.message}`
     </a>
     <button onclick="window.close()" class="secondary-btn">Close Window</button>
     
-    <p class="note">✓ Token saved. Restart your IDE to activate.</p>
+    <p class="note">Token saved. Restart your IDE to activate.</p>
     <div class="countdown" id="countdown">
       <div class="countdown-spinner"></div>
       <span>Closing in <strong id="seconds">5</strong>s...</span>
@@ -1407,93 +1406,129 @@ Error: ${error.message}`
         const result = await this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout, model);
         localResults = [{ provider_id, ...result }];
       } else {
-        // No specific provider - use allProviders from dashboard in order
-        // For each provider: try CLI first if available, otherwise use API
-        console.error(`[Stdio Wrapper] Using allProviders from dashboard (max: ${maxPerspectives})`);
+        // No specific provider - SMART ROUTING: CLIs first (free), then API/credits
+        // Priority order: Available CLIs > User's API keys > Credits tier models
+        // If a configured API/credits model can be accessed through an available CLI, use CLI
+        console.error(`[Stdio Wrapper] Smart routing: CLIs first, then API/credits (max: ${maxPerspectives})`);
         
         // Get available CLIs for checking
         const { available: availableClis } = await this.getAllAvailableProviders();
         console.error(`[Stdio Wrapper] Available CLIs: ${availableClis.join(', ') || 'none'}`);
         
-        // Use allProviders from API (full list including API-only providers)
-        // Falls back to CLI-only providers if allProviders not available
+        // Use allProviders from API (user's configured providers from dashboard)
         const allProviders = this.allProviders || [];
         
-        if (allProviders.length === 0) {
-          // Fallback: use legacy CLI-only flow
-          console.error(`[Stdio Wrapper] No allProviders, using legacy CLI-only flow`);
-          // NOTE: Use length check because empty array [] is truthy in JS
-          const userOrder = (this.userProviderOrder && this.userProviderOrder.length > 0) 
-            ? this.userProviderOrder 
-            : ['claude_code', 'codex_cli', 'gemini_cli'];
-          const cliProviders = userOrder.slice(0, maxPerspectives).filter(p => availableClis.includes(p));
+        // CLI to provider name mapping
+        const cliToProviderMap = {
+          'claude_code': 'anthropic',
+          'gemini_cli': 'google',
+          'codex_cli': 'openai'
+        };
+        
+        // Provider name normalization (matches model-preferences API)
+        const normalizeProvider = (provider) => {
+          const map = {
+            'gemini': 'google',
+            'google-ai': 'google',
+            'x-ai': 'xai',
+            'open-ai': 'openai',
+            'anthropic-ai': 'anthropic'
+          };
+          const lower = provider.toLowerCase();
+          return map[lower] || lower;
+        };
+        
+        // CLI priority order: Claude Code first, then Gemini, then Codex
+        const cliPriorityOrder = ['claude_code', 'gemini_cli', 'codex_cli'];
+        
+        // Build merged provider list: CLIs first, then API-only
+        const finalProviders = [];
+        const usedProviderNames = new Set();
+        
+        // STEP 1: Add ALL available CLIs first (in priority order) - they're FREE
+        for (const cliId of cliPriorityOrder) {
+          if (finalProviders.length >= maxPerspectives) break;
+          if (!availableClis.includes(cliId)) continue;
+          
+          const providerName = cliToProviderMap[cliId];
+          usedProviderNames.add(providerName);
+          
+          // Check if user has a configured model for this provider (from API keys or credits)
+          // If so, use that model through CLI instead of burning API credits
+          const configuredProvider = allProviders.find(p => {
+            const normalized = normalizeProvider(p.provider);
+            return normalized === providerName;
+          });
+          
+          finalProviders.push({
+            provider: providerName,
+            model: configuredProvider?.model || null,
+            cliId: cliId,
+            source: 'cli',
+            tier: configuredProvider?.tier || null
+          });
+          
+          console.error(`[Stdio Wrapper] [CLI-FIRST] Added CLI: ${cliId} (${providerName})${configuredProvider ? ` with configured model: ${configuredProvider.model}` : ' with CLI default'}`);
+        }
+        
+        // STEP 2: Fill remaining slots with API/credits providers (skip those already covered by CLI)
+        for (const p of allProviders) {
+          if (finalProviders.length >= maxPerspectives) break;
+          
+          const normalizedProvider = normalizeProvider(p.provider);
+          if (usedProviderNames.has(normalizedProvider)) {
+            console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${normalizedProvider} (already covered by CLI)`);
+            continue;
+          }
+          
+          usedProviderNames.add(normalizedProvider);
+          finalProviders.push({
+            ...p,
+            provider: normalizedProvider,
+            source: 'api'
+          });
           
-          const cliPromises = cliProviders.map(async (providerId) => {
+          console.error(`[Stdio Wrapper] [CLI-FIRST] Added API/credits: ${normalizedProvider} (${p.model})${p.tier ? ` [${p.tier}]` : ''}`);
+        }
+        
+        console.error(`[Stdio Wrapper] Final provider list (${finalProviders.length}/${maxPerspectives}): ${finalProviders.map(p => `${p.provider}[${p.source}]`).join(', ')}`);
+        
+        // Separate into CLI entries (local execution) vs API entries (remote execution)
+        const cliProviderEntries = finalProviders.filter(p => p.source === 'cli');
+        const apiOnlyProviders = finalProviders.filter(p => p.source === 'api');
+        
+        console.error(`[Stdio Wrapper] Provider breakdown: CLI=${cliProviderEntries.map(p => p.cliId).join(', ') || 'none'}, API-only=${apiOnlyProviders.map(p => p.provider).join(', ') || 'none'}`);
+        
+        // Run all CLI prompts concurrently
+        if (cliProviderEntries.length > 0) {
+          const cliPromises = cliProviderEntries.map(async (providerEntry) => {
             try {
-              const model = modelPreferences[providerId] || null;
-              const result = await this.cliManager.sendCliPrompt(providerId, prompt, mode, gracefulTimeout, model);
+              const model = providerEntry.model || modelPreferences[providerEntry.cliId] || null;
+              if (model) {
+                console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
+              }
+              const result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, model);
               return { 
-                provider_id: providerId, 
-                original_provider: providerId,
+                provider_id: providerEntry.cliId, 
+                original_provider: providerEntry.provider,
                 ...result 
               };
             } catch (error) {
-              return { provider_id: providerId, success: false, error: error.message };
+              console.error(`[Stdio Wrapper] CLI ${providerEntry.cliId} failed:`, error.message);
+              return {
+                provider_id: providerEntry.cliId,
+                original_provider: providerEntry.provider,
+                success: false,
+                error: error.message,
+                latency_ms: gracefulTimeout
+              };
             }
           });
           localResults = await Promise.all(cliPromises);
-        } else {
-          // NEW: Use allProviders list (includes CLI + API-only providers)
-          const providersToUse = allProviders.slice(0, maxPerspectives);
-          console.error(`[Stdio Wrapper] Using ${providersToUse.length} providers from dashboard`);
-          
-          // Separate into CLI providers vs API-only providers
-          const cliProviderEntries = [];
-          const apiOnlyProviders = [];
-          
-          for (const p of providersToUse) {
-            if (p.cliId && availableClis.includes(p.cliId)) {
-              // Has CLI and CLI is available
-              cliProviderEntries.push(p);
-            } else {
-              // No CLI or CLI unavailable - needs API
-              apiOnlyProviders.push(p);
-            }
-          }
-          
-          console.error(`[Stdio Wrapper] Provider breakdown: CLI=${cliProviderEntries.map(p => p.cliId).join(', ') || 'none'}, API-only=${apiOnlyProviders.map(p => p.provider).join(', ') || 'none'}`);
-          
-          // Run all CLI prompts concurrently
-          if (cliProviderEntries.length > 0) {
-            const cliPromises = cliProviderEntries.map(async (providerEntry) => {
-              try {
-                const model = providerEntry.model || modelPreferences[providerEntry.cliId] || null;
-                if (model) {
-                  console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
-                }
-                const result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, model);
-                return { 
-                  provider_id: providerEntry.cliId, 
-                  original_provider: providerEntry.provider,
-                  ...result 
-                };
-              } catch (error) {
-                console.error(`[Stdio Wrapper] CLI ${providerEntry.cliId} failed:`, error.message);
-                return {
-                  provider_id: providerEntry.cliId,
-                  original_provider: providerEntry.provider,
-                  success: false,
-                  error: error.message,
-                  latency_ms: gracefulTimeout
-                };
-              }
-            });
-            localResults = await Promise.all(cliPromises);
-          }
-          
-          // Store API-only providers info for remote API call
-          this._apiOnlyProviders = apiOnlyProviders;
         }
+        
+        // Store API-only providers info for remote API call
+        this._apiOnlyProviders = apiOnlyProviders;
       }
 
       // Calculate how many successful local perspectives we got
@@ -1957,16 +1992,16 @@ Error: ${error.message}`
         const modelDisplay = cliResult.model_used && cliResult.model_used !== 'cli_default' && cliResult.model_used !== 'cli_default_fallback'
           ? cliResult.model_used 
           : cliResult.provider_id;
-        formatted += `🟢 **Local CLI Response** (${modelDisplay})\n\n`;
+        formatted += `Local CLI Response (${modelDisplay})\n\n`;
         formatted += `${cleanCliResponse(cliResult.content)}\n\n`;
-        formatted += `*Latency: ${cliResult.latency_ms || 0}ms | Tokens: ${cliResult.tokens_used || 0}*\n\n`;
+        formatted += `Latency: ${cliResult.latency_ms || 0}ms | Tokens: ${cliResult.tokens_used || 0}\n\n`;
         formatted += `---\n\n`;
       }
     }
 
     if (failedClis.length > 0 && successfulClis.length === 0) {
       // All local CLIs failed
-      formatted += `⚠️ **All Local CLIs Unavailable**\n`;
+      formatted += `[Warning] All Local CLIs Unavailable\n`;
       for (const cliResult of failedClis) {
         formatted += `- ${cliResult.provider_id}: ${cliResult.error}\n`;
       }
@@ -1974,7 +2009,7 @@ Error: ${error.message}`
       formatted += `---\n\n`;
     } else if (failedClis.length > 0) {
       // Some CLIs failed, some succeeded
-      formatted += `⚠️ **Some CLIs Failed**\n`;
+      formatted += `[Warning] Some CLIs Failed\n`;
       for (const cliResult of failedClis) {
         formatted += `- ${cliResult.provider_id}: ${cliResult.error}\n`;
       }
@@ -1988,13 +2023,13 @@ Error: ${error.message}`
         formatted += `${safePersp.content}\n\n`;
       } else {
         // Legacy formatting
-        const title = (successfulClis.length === 0) ? '🧠 **Perspectives Fallback**' : '🧠 **Supplemental Multi-Model Perspectives**';
+        const title = (successfulClis.length === 0) ? 'Perspectives Fallback' : 'Supplemental Multi-Model Perspectives';
         formatted += `${title}\n\n`;
         formatted += `${safePersp.content}\n\n`;
       }
     } else if (successfulClis.length > 0) {
       // Show remote error only if we have local success
-      formatted += `❌ **Perspectives request failed**: ${safePersp.error || 'Unknown error'}\n\n`;
+      formatted += `❌ Perspectives request failed: ${safePersp.error || 'Unknown error'}\n\n`;
     }
 
     return formatted.trim();
@@ -2257,28 +2292,28 @@ Error: ${error.message}`
       const cliCount = result.local_cli_count || 1;
       
       if (cliCount > 1) {
-        return `✅ **Multi-CLI Response** (${cliCount} local CLIs + perspectives)\n\n${result.content}\n\n*Total Latency: ${result.latency_ms || 0}ms | Total Tokens: ${result.tokens_used || 0} | ${result.timestamp}*`;
+        return `Multi-CLI Response (${cliCount} local CLIs + perspectives)\n\n${result.content}\n\nTotal Latency: ${result.latency_ms || 0}ms | Total Tokens: ${result.tokens_used || 0} | ${result.timestamp}`;
       } else {
-        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}*`;
+        return `CLI Response (${result.provider || 'Unknown'} - ${result.mode || 'unknown'} mode)\n\n${result.content}\n\nLatency: ${result.latency_ms || 0}ms | Tokens: ${result.tokens_used || 0} | ${result.timestamp}`;
       }
     } else {
       // Status/detection response
-      let formatted = `✅ **CLI Operation Success**\n\n`;
+      let formatted = `CLI Operation Success\n\n`;
       formatted += `${result.message}\n\n`;
       
       if (result.results) {
-        formatted += `**Results:**\n`;
+        formatted += `Results:\n`;
         for (const [providerId, status] of Object.entries(result.results)) {
-          const icon = status.available ? '🟢' : '🔴';
-          const authIcon = status.authenticated ? '🔐' : '🔓';
-          formatted += `- ${icon} ${authIcon} **${providerId}**: ${status.available ? 'Available' : 'Not Available'}`;
+          const icon = status.available ? '[+]' : '[-]';
+          const authStatus = status.authenticated ? '[auth]' : '[no-auth]';
+          formatted += `- ${icon} ${authStatus} ${providerId}: ${status.available ? 'Available' : 'Not Available'}`;
           if (status.version) formatted += ` (${status.version})`;
           if (status.error) formatted += ` - ${status.error}`;
           formatted += `\n`;
         }
       }
       
-      formatted += `\n*${result.local_only ? 'Local execution' : 'Remote execution'} | ${result.timestamp}*`;
+      formatted += `\n${result.local_only ? 'Local execution' : 'Remote execution'} | ${result.timestamp}`;
       return formatted;
     }
   }
@@ -2544,22 +2579,20 @@ Error: ${error.message}`
                 result: {
                   content: [{
                     type: 'text',
-                    text: `╭─────────────────────────────────────────╮
-│        LOGIN SUCCESSFUL! ✓              │
-╰─────────────────────────────────────────╯
+                    text: `LOGIN SUCCESSFUL
+================
 
-🔐 Token saved to:
-  • ~/.polydev.env
-  • ~/.zshrc
+Token saved to:
+  ~/.polydev.env
+  ~/.zshrc
 
-⚠️  IMPORTANT: Restart your IDE to activate.
+IMPORTANT: Restart your IDE to activate.
 
-🤖 After restart, you can:
-  • Use /polydev:ask to query multiple AI models
-  • Use /polydev:auth to check status & credits
-  • Use get_perspectives tool directly
+After restart, you can:
+  /polydev:ask   Query multiple AI models
+  /polydev:auth  Check status & credits
 
-📊 Dashboard: https://polydev.ai/dashboard`
+Dashboard: https://polydev.ai/dashboard`
                   }]
                 }
               });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.8.99",
+  "version": "1.9.1",
   "engines": {
     "node": ">=20.x <=22.x"
   },