polydev-ai 1.2.3 → 1.2.5

package/README.md

@@ -1,6 +1,6 @@
 # Polydev AI Website
 
-Advanced Model Context Protocol platform with comprehensive multi-LLM integration, subscription-based CLI access, OAuth bridges, and advanced tooling for AI development.
+Advanced Model Context Protocol platform with comprehensive multi-LLM integrations, subscription-based CLI access, OAuth bridges, and advanced tooling for AI development.
 
 ## Features
 

package/lib/cliManager.ts

@@ -34,6 +34,9 @@ export interface CLIStatus {
   path?: string
   lastChecked: Date
   error?: string
+  default_model?: string
+  available_models?: string[]
+  model_detection_method?: 'interactive' | 'fallback'
 }
 
 export interface CLIResponse {
@@ -280,12 +283,30 @@ export class CLIManager {
       authenticated = true
     }
 
+    // Detect available models for this CLI tool
+    let default_model: string | undefined
+    let available_models: string[] | undefined
+    let model_detection_method: 'interactive' | 'fallback' | undefined
+
+    try {
+      const modelDetection = await this.detectDefaultModel(provider.id);
+      default_model = modelDetection.defaultModel;
+      available_models = modelDetection.availableModels;
+      model_detection_method = modelDetection.detectionMethod;
+    } catch (error) {
+      console.error(`[CLI Manager] Model detection failed for ${provider.name}:`, error);
+      // Continue without model info - fallback will be used
+    }
+
     return {
       available: true,
       authenticated,
       version,
       path: executablePath,
-      lastChecked: new Date()
+      lastChecked: new Date(),
+      default_model,
+      available_models,
+      model_detection_method
     }
   }
 
@@ -423,6 +444,127 @@ export class CLIManager {
   getProvider(providerId: string): CLIProvider | undefined {
     return this.providers.get(providerId)
   }
+
+  /**
+   * Detect available models for a CLI provider using interactive commands
+   */
+  async detectDefaultModel(providerId: string): Promise<{
+    defaultModel: string;
+    availableModels: string[];
+    detectionMethod: 'interactive' | 'fallback';
+  }> {
+    try {
+      // Try interactive detection using CLI commands
+      let command = '';
+      switch (providerId) {
+        case 'claude_code':
+          command = 'models'; // Claude Code model listing command
+          break;
+        case 'codex_cli':
+          command = 'list-models'; // Codex CLI model listing command
+          break;
+        case 'gemini_cli':
+          command = 'models'; // Gemini CLI model listing command
+          break;
+      }
+      
+      if (!command) {
+        throw new Error(`No model detection command for ${providerId}`);
+      }
+      
+      const result = await this.sendCliPrompt(providerId, command, 'args', 10000);
+      
+      if (result.success && result.content) {
+        const models = this.parseModelsFromOutput(providerId, result.content);
+        if (models.length > 0) {
+          return {
+            defaultModel: this.extractDefaultModel(providerId, models),
+            availableModels: models,
+            detectionMethod: 'interactive'
+          };
+        }
+      }
+    } catch (error) {
+      console.error(`Interactive model detection failed for ${providerId}:`, error);
+    }
+
+    // Fallback to known defaults if interactive detection fails
+    return {
+      defaultModel: this.getDefaultModelFallback(providerId),
+      availableModels: [this.getDefaultModelFallback(providerId)],
+      detectionMethod: 'fallback'
+    };
+  }
+
+  /**
+   * Parse model names from CLI output
+   */
+  private parseModelsFromOutput(providerId: string, output: string): string[] {
+    const models: string[] = [];
+    const lines = output.split('\n');
+    
+    switch (providerId) {
+      case 'claude_code':
+        // Parse Claude Code output format
+        lines.forEach(line => {
+          const matches = line.match(/claude-[\w\-.]+/gi);
+          if (matches) models.push(...matches);
+        });
+        break;
+      case 'codex_cli':
+        // Parse Codex CLI output format
+        lines.forEach(line => {
+          const matches = line.match(/gpt-[\w\-.]+|o1-[\w\-.]+/gi);
+          if (matches) models.push(...matches);
+        });
+        break;
+      case 'gemini_cli':
+        // Parse Gemini CLI output format
+        lines.forEach(line => {
+          const matches = line.match(/gemini-[\w\-.]+/gi);
+          if (matches) models.push(...matches);
+        });
+        break;
+    }
+    
+    return [...new Set(models)]; // Remove duplicates
+  }
+
+  /**
+   * Extract the default model from available models
+   */
+  private extractDefaultModel(providerId: string, models: string[]): string {
+    if (models.length === 0) return this.getDefaultModelFallback(providerId);
+    
+    switch (providerId) {
+      case 'claude_code':
+        // Prefer Claude 3.5 Sonnet, then Claude 3 Sonnet
+        return models.find(m => m.includes('claude-3-5-sonnet')) || 
+               models.find(m => m.includes('claude-3-sonnet')) || 
+               models[0];
+      case 'codex_cli':
+        // Prefer GPT-4, then GPT-3.5
+        return models.find(m => m.includes('gpt-4')) || models[0];
+      case 'gemini_cli':
+        // Prefer Gemini Pro, then Gemini Flash
+        return models.find(m => m.includes('gemini-1.5-pro')) || 
+               models.find(m => m.includes('gemini-pro')) || 
+               models[0];
+    }
+    return models[0];
+  }
+
+  /**
+   * Get fallback default model for a provider
+   */
+  private getDefaultModelFallback(providerId: string): string {
+    const fallbacks = {
+      'claude_code': 'claude-3-sonnet',
+      'codex_cli': 'gpt-4', 
+      'gemini_cli': 'gemini-pro'
+    };
+    return fallbacks[providerId as keyof typeof fallbacks] || 'unknown';
+  }
 }
 
-export default CLIManager
+export default CLIManager

package/lib/smartCliCache.ts

@@ -0,0 +1,189 @@
+/**
+ * Smart Cache for CLI Status Management
+ * Provides intelligent caching based on CLI reliability and status
+ */
+
+export class SmartCliCache {
+  private supabase: any;
+
+  constructor(supabase: any) {
+    this.supabase = supabase;
+  }
+
+  /**
+   * Get smart timeout based on CLI configuration
+   * Returns timeout in minutes
+   */
+  getSmartTimeout(cliConfig: any): number {
+    if (!cliConfig.available) {
+      return 2; // 2 minutes - check frequently for new installs
+    }
+    
+    if (!cliConfig.authenticated) {
+      return 3; // 3 minutes - check for authentication
+    }
+    
+    if (cliConfig.model_detection_method === 'fallback') {
+      return 5; // 5 minutes - retry interactive detection
+    }
+    
+    return 10; // 10 minutes - stable, working CLI
+  }
+
+  /**
+   * Check if CLI configuration is stale
+   */
+  isStale(cliConfig: any): boolean {
+    if (!cliConfig.last_checked_at) return true;
+    
+    const now = new Date();
+    const lastChecked = new Date(cliConfig.last_checked_at);
+    const minutesOld = (now.getTime() - lastChecked.getTime()) / (1000 * 60);
+    const timeout = this.getSmartTimeout(cliConfig);
+    
+    return minutesOld > timeout;
+  }
+
+  /**
+   * Get CLI status with smart caching
+   * Checks if data is stale and triggers refresh if needed
+   */
+  async getCliStatusWithCache(userId: string): Promise<any[]> {
+    // 1. Get current CLI configurations from database
+    const { data: cliConfigs, error } = await this.supabase
+      .from('cli_provider_configurations')
+      .select('*')
+      .eq('user_id', userId);
+
+    if (error || !cliConfigs) {
+      console.error('[Smart Cache] Failed to get CLI configs:', error);
+      return [];
+    }
+
+    if (cliConfigs.length === 0) {
+      return [];
+    }
+
+    // 2. Check which configurations are stale
+    const staleConfigs = cliConfigs.filter((config: any) => this.isStale(config));
+
+    // 3. If any are stale, trigger refresh (async, don't wait)
+    if (staleConfigs.length > 0) {
+      console.log(`[Smart Cache] ${staleConfigs.length} CLI configs are stale, triggering refresh for user ${userId}`);
+      this.refreshStaleConfigs(userId, staleConfigs).catch((error: any) => {
+        console.error('[Smart Cache] Refresh failed:', error);
+      });
+    }
+
+    // 4. Return current data (will be fresh after refresh)
+    return cliConfigs;
+  }
+
+  /**
+   * Refresh stale CLI configurations (called asynchronously)
+   */
+  private async refreshStaleConfigs(userId: string, staleConfigs: any[]): Promise<void> {
+    console.log(`[Smart Cache] Starting refresh for ${staleConfigs.length} stale CLI configs`);
+    
+    try {
+      // Trigger forced CLI detection via stdio-wrapper
+      for (const config of staleConfigs) {
+        await this.updateCliStatus(userId, config.provider);
+      }
+      
+      console.log('[Smart Cache] Successfully triggered refresh for stale CLI configs');
+    } catch (error) {
+      console.error('[Smart Cache] Failed to trigger refresh:', error);
+    }
+  }
+
+  /**
+   * Update CLI status for a specific provider
+   */
+  private async updateCliStatus(userId: string, provider: string): Promise<void> {
+    try {
+      const response = await fetch('/api/cli-status/refresh', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.getUserToken()}`
+        },
+        body: JSON.stringify({
+          user_id: userId,
+          provider: provider
+        })
+      });
+
+      if (!response.ok) {
+        console.error(`[Smart Cache] Failed to refresh ${provider}:`, response.status);
+      }
+    } catch (error) {
+      console.error(`[Smart Cache] Network error refreshing ${provider}:`, error);
+    }
+  }
+
+  /**
+   * Get current user token (helper method)
+   */
+  private getUserToken(): string {
+    // Try to get from environment or context
+    return process.env.POLYDEV_USER_TOKEN || '';
+  }
+
+  /**
+   * Format last checked time for display
+   */
+  formatLastCheckedTime(lastChecked: string): string {
+    if (!lastChecked) return 'Unknown';
+    
+    const lastCheckedDate = new Date(lastChecked);
+    const now = new Date();
+    const minutes = Math.floor((now.getTime() - lastCheckedDate.getTime()) / (1000 * 60));
+    
+    if (minutes < 1) return 'Just now';
+    if (minutes < 60) return `${minutes} min ago`;
+    if (minutes < 1440) return `${Math.floor(minutes / 60)} hours ago`;
+    return `${Math.floor(minutes / 1440)} days ago`;
+  }
+
+  /**
+   * Check if CLI should use local tools based on database status
+   */
+  shouldUseLocalCli(model: string, cliConfigs: any[]): boolean {
+    // Find CLI that supports this model
+    const cliMatch = cliConfigs.find((cli: any) => 
+      cli.status === 'available' && 
+      cli.authenticated &&
+      (cli.available_models?.includes(model) || cli.default_model === model)
+    );
+    
+    return !!cliMatch;
+  }
+
+  /**
+   * Get summary statistics for dashboard
+   */
+  getClimiStatusSummary(cliConfigs: any[]): {
+    total: number;
+    available: number;
+    authenticated: number;
+    stale: number;
+  } {
+    const now = new Date();
+    let staleCount = 0;
+    
+    // Count stale configs
+    cliConfigs.forEach(config => {
+      if (this.isStale(config)) {
+        staleCount++;
+      }
+    });
+    
+    return {
+      total: cliConfigs.length,
+      available: cliConfigs.filter(cli => cli.status === 'available').length,
+      authenticated: cliConfigs.filter(cli => cli.authenticated).length,
+      stale: staleCount
+    };
+  }
+}