polydev-ai 1.2.4 → 1.2.6

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
+    };
+  }
+}

package/mcp/README.md

@@ -0,0 +1,165 @@
+# Polydev AI MCP Server
+
+Get diverse AI perspectives from multiple LLMs via Model Context Protocol (MCP). Supports Cline, Claude Code, and other MCP clients with local CLI detection and remote AI perspectives.
+
+## Features
+
+- 🤖 **Multi-Model AI Perspectives**: Get responses from GPT-4, Claude, Gemini, and more
+- 🔧 **Local CLI Detection**: Automatically detect and use Claude Code, Codex CLI, Gemini CLI
+- ⚡ **Smart Caching**: Intelligent refresh intervals based on CLI status
+- 🔄 **Fallback Support**: Local CLI + remote perspectives for comprehensive responses
+- 🔐 **Secure**: Token-based authentication with your Polydev account
+
+## Installation
+
+### For Claude Code Users
+
+```bash
+# Install globally
+npm install -g polydev-ai
+
+# Or use directly with npx
+npx polydev-ai
+```
+
+### For Cline Users
+
+Add to your MCP settings (`.cline/mcp_servers.json`):
+
+```json
+{
+  "mcpServers": {
+    "polydev": {
+      "command": "npx",
+      "args": ["polydev-ai"],
+      "env": {
+        "POLYDEV_USER_TOKEN": "your_token_here"
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+### Get Your Token
+
+1. Sign up at [polydev.ai](https://polydev.ai)
+2. Go to your dashboard and copy your MCP token
+3. Set the environment variable:
+
+```bash
+export POLYDEV_USER_TOKEN="pd_your_token_here"
+```
+
+### Claude Code Integration
+
+Add to your Claude Code MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "polydev": {
+      "command": "npx",
+      "args": ["polydev-ai"],
+      "env": {
+        "POLYDEV_USER_TOKEN": "pd_your_token_here"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+- `get_perspectives` - Get AI responses from multiple models
+- `force_cli_detection` - Force detection of local CLI tools
+- `get_cli_status` - Check status of CLI tools (Claude Code, Codex, Gemini)
+- `send_cli_prompt` - Send prompts to local CLI with perspectives fallback
+
+## Usage Examples
+
+### Get Multi-Model Perspectives
+
+```typescript
+// Use the get_perspectives tool
+{
+  "prompt": "How do I optimize React performance?",
+  "models": ["gpt-4", "claude-3-sonnet", "gemini-pro"]
+}
+```
+
+### Check CLI Status
+
+```typescript
+// Check all CLI tools
+await get_cli_status({})
+
+// Check specific tool
+await get_cli_status({ provider_id: "claude_code" })
+```
+
+### Send CLI Prompt with Fallback
+
+```typescript
+await send_cli_prompt({
+  provider_id: "claude_code",
+  prompt: "Write a Python function to parse JSON",
+  mode: "args"
+})
+```
+
+## Supported CLI Tools
+
+- **Claude Code** (`claude`) - Anthropic's official CLI
+- **Codex CLI** (`codex`) - OpenAI's code CLI
+- **Gemini CLI** (`gemini`) - Google's Gemini CLI
+
+## Smart Refresh System
+
+The MCP server automatically detects CLI status changes:
+
+- **Unavailable CLIs**: Check every 2 minutes
+- **Unauthenticated CLIs**: Check every 3 minutes  
+- **Working CLIs**: Check every 10 minutes
+- **Fallback detection**: Check every 5 minutes
+
+## Environment Variables
+
+- `POLYDEV_USER_TOKEN` - Your Polydev authentication token (required)
+- `POLYDEV_CLI_DEBUG` - Enable CLI debugging output
+- `CLAUDE_CODE_PATH` - Custom path to Claude Code CLI
+- `CODEX_CLI_PATH` - Custom path to Codex CLI
+- `GEMINI_CLI_PATH` - Custom path to Gemini CLI
+
+## Troubleshooting
+
+### CLI Not Detected
+
+1. Ensure the CLI is installed and in your PATH
+2. Check authentication: `claude auth status` / `codex login status`
+3. Enable debugging: `export POLYDEV_CLI_DEBUG=1`
+
+### Token Issues
+
+1. Verify your token at [polydev.ai/dashboard](https://polydev.ai/dashboard)
+2. Ensure the token starts with `pd_`
+3. Check environment variable is set correctly
+
+### Permission Errors
+
+```bash
+# Fix npm permissions
+npm config set prefix '~/.npm-global'
+export PATH=~/.npm-global/bin:$PATH
+```
+
+## Support
+
+- 📧 Email: [support@polydev.ai](mailto:support@polydev.ai)
+- 📖 Docs: [polydev.ai/docs](https://polydev.ai/docs)
+- 🐛 Issues: [GitHub Issues](https://github.com/backspacevenkat/polydev-website/issues)
+
+## License
+
+MIT License - see LICENSE file for details.

package/mcp/package.json

@@ -1,10 +1,10 @@
 {
-  "name": "polydev-perspectives-mcp",
-  "version": "1.0.0",
+  "name": "polydev-ai",
+  "version": "1.2.6",
   "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
   "main": "stdio-wrapper.js",
   "bin": {
-    "polydev-mcp": "./stdio-wrapper.js"
+    "polydev-ai": "./stdio-wrapper.js"
   },
   "scripts": {
     "start": "node server.js",

package/mcp/stdio-wrapper.js

@@ -18,6 +18,9 @@ class StdioMCPWrapper {
     
     // Load manifest for tool definitions
     this.loadManifest();
+    
+    // Smart refresh scheduler (will be started after initialization)
+    this.refreshScheduler = null;
   }
 
   loadManifest() {
@@ -195,10 +198,10 @@ class StdioMCPWrapper {
   }
 
   /**
-   * Local CLI detection implementation
+   * Local CLI detection implementation with database updates
    */
   async localForceCliDetection(args) {
-    console.error(`[Stdio Wrapper] Local CLI detection started`);
+    console.error(`[Stdio Wrapper] Local CLI detection with model detection started`);
     
     try {
       const providerId = args.provider_id; // Optional - detect specific provider
@@ -209,6 +212,9 @@ class StdioMCPWrapper {
       // Save status locally to file-based cache
       await this.saveLocalCliStatus(results);
 
+      // NEW: Update database with CLI status
+      await this.updateCliStatusInDatabase(results);
+      
       return {
         success: true,
         results,
@@ -251,6 +257,9 @@ class StdioMCPWrapper {
         }
       }
 
+      // Update database with current status
+      await this.updateCliStatusInDatabase(results);
+
       return {
         success: true,
         results,
@@ -507,6 +516,70 @@ class StdioMCPWrapper {
     return formatted.trim();
   }
 
+  /**
+   * Update CLI status in database
+   */
+  async updateCliStatusInDatabase(results) {
+    console.error('[Stdio Wrapper] Updating CLI status in database...');
+    
+    try {
+      // Get user token from environment variables
+      const userToken = process.env.POLYDEV_MCP_TOKEN || this.userToken;
+      
+      if (!userToken) {
+        console.error('[Stdio Wrapper] No user token available for database updates');
+        return;
+      }
+      
+      console.error(`[Stdio Wrapper] Using token: ${userToken ? userToken.substring(0, 20) + '...' : 'MISSING'}`);
+      
+      for (const [providerId, result] of Object.entries(results)) {
+        const statusData = {
+          provider: providerId,
+          status: result.available ? 'available' : 'unavailable',
+          mcp_token: userToken,
+          cli_version: result.version || null,
+          cli_path: result.cli_path || null,
+          authenticated: result.authenticated || false,
+          last_used: result.last_checked || new Date().toISOString(),
+          message: result.error || `${providerId} is ${result.available ? 'available' : 'unavailable'}`,
+          additional_info: {
+            default_model: result.default_model || null,
+            available_models: result.available_models || [],
+            model_detection_method: result.model_detection_method || 'fallback',
+            model_detected_at: result.model_detected_at || new Date().toISOString()
+          }
+        };
+
+        console.error(`[Stdio Wrapper] Updating ${providerId} with data:`, JSON.stringify({
+          provider: statusData.provider,
+          status: statusData.status,
+          user_id: statusData.user_id,
+          authenticated: statusData.authenticated
+        }, null, 2));
+
+        const response = await fetch('https://www.polydev.ai/api/cli-status-update', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(statusData)
+        });
+
+        if (response.ok) {
+          const responseData = await response.json();
+          console.error(`[Stdio Wrapper] Successfully updated ${providerId} status in database`);
+        } else {
+          const errorText = await response.text();
+          console.error(`[Stdio Wrapper] Failed to update ${providerId}: ${response.status} - ${errorText}`);
+        }
+      }
+
+    } catch (error) {
+      console.error('[Stdio Wrapper] Error updating database:', error);
+    }
+  }
+
   /**
    * Save CLI status to local file cache
    */
@@ -535,6 +608,121 @@ class StdioMCPWrapper {
     }
   }
 
+  /**
+   * Load CLI status from local file cache
+   */
+  async loadLocalCliStatus() {
+    try {
+      const homeDir = require('os').homedir();
+      const statusFile = path.join(homeDir, '.polydev', 'cli-status.json');
+      
+      if (fs.existsSync(statusFile)) {
+        const data = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+        return data.results || {};
+      }
+    } catch (error) {
+      console.error('[Stdio Wrapper] Failed to load local status:', error);
+    }
+    return {};
+  }
+
+  /**
+   * Get smart timeout based on CLI status (same logic as SmartCliCache)
+   * Returns timeout in minutes
+   */
+  getSmartTimeout(cliStatus) {
+    if (!cliStatus.available) {
+      return 2; // 2 minutes - check frequently for new installs
+    }
+    
+    if (!cliStatus.authenticated) {
+      return 3; // 3 minutes - check for authentication
+    }
+    
+    if (cliStatus.model_detection_method === 'fallback') {
+      return 5; // 5 minutes - retry interactive detection
+    }
+    
+    return 10; // 10 minutes - stable, working CLI
+  }
+
+  /**
+   * Check if CLI status is stale based on smart timeout
+   */
+  isStale(cliStatus) {
+    if (!cliStatus.last_checked) return true;
+    
+    const now = new Date();
+    const lastChecked = new Date(cliStatus.last_checked);
+    const minutesOld = (now.getTime() - lastChecked.getTime()) / (1000 * 60);
+    const timeout = this.getSmartTimeout(cliStatus);
+    
+    return minutesOld > timeout;
+  }
+
+  /**
+   * Start smart refresh scheduler
+   * Checks every minute but only refreshes stale CLIs based on smart timeouts
+   */
+  startSmartRefreshScheduler() {
+    console.error('[Stdio Wrapper] Starting smart refresh scheduler...');
+    
+    // Check every 1 minute, but only refresh what's actually stale
+    this.refreshScheduler = setInterval(async () => {
+      try {
+        // Read current status from local cache
+        const currentStatus = await this.loadLocalCliStatus();
+        
+        if (!currentStatus || Object.keys(currentStatus).length === 0) {
+          console.error('[Stdio Wrapper] No local CLI status found, running initial detection...');
+          await this.localForceCliDetection({});
+          return;
+        }
+        
+        // Check which CLIs need refresh based on smart timeouts
+        const staleProviders = [];
+        for (const [providerId, status] of Object.entries(currentStatus)) {
+          if (this.isStale(status)) {
+            const minutesOld = Math.floor((new Date().getTime() - new Date(status.last_checked).getTime()) / (1000 * 60));
+            const timeout = this.getSmartTimeout(status);
+            staleProviders.push({ providerId, minutesOld, timeout });
+          }
+        }
+        
+        if (staleProviders.length > 0) {
+          console.error(`[Stdio Wrapper] Smart refresh: ${staleProviders.length} stale CLI providers detected`);
+          staleProviders.forEach(({ providerId, minutesOld, timeout }) => {
+            console.error(`[Stdio Wrapper] - ${providerId}: ${minutesOld} min old (timeout: ${timeout} min)`);
+          });
+          
+          // Only detect the stale providers
+          for (const { providerId } of staleProviders) {
+            console.error(`[Stdio Wrapper] Refreshing ${providerId}...`);
+            await this.localForceCliDetection({ provider_id: providerId });
+          }
+          
+          console.error('[Stdio Wrapper] Smart refresh completed');
+        }
+        
+      } catch (error) {
+        console.error('[Stdio Wrapper] Smart refresh error:', error);
+      }
+    }, 60000); // Check every minute
+    
+    console.error('[Stdio Wrapper] Smart refresh scheduler started (checks every 60 seconds)');
+  }
+
+  /**
+   * Stop smart refresh scheduler
+   */
+  stopSmartRefreshScheduler() {
+    if (this.refreshScheduler) {
+      clearInterval(this.refreshScheduler);
+      this.refreshScheduler = null;
+      console.error('[Stdio Wrapper] Smart refresh scheduler stopped');
+    }
+  }
+
   /**
    * Record local usage for analytics
    */
@@ -625,6 +813,18 @@ class StdioMCPWrapper {
   async start() {
     console.log('Starting Polydev Stdio MCP Wrapper...');
     
+    // Run initial CLI detection on startup
+    console.error('[Stdio Wrapper] Running initial CLI detection...');
+    try {
+      await this.localForceCliDetection({});
+      console.error('[Stdio Wrapper] Initial CLI detection completed');
+    } catch (error) {
+      console.error('[Stdio Wrapper] Initial CLI detection failed:', error);
+    }
+    
+    // Start smart refresh scheduler for automatic updates
+    this.startSmartRefreshScheduler();
+    
     process.stdin.setEncoding('utf8');
     let buffer = '';
     
@@ -649,17 +849,20 @@ class StdioMCPWrapper {
 
     process.stdin.on('end', () => {
       console.log('Stdio MCP Wrapper shutting down...');
+      this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 
     // Handle process signals
     process.on('SIGINT', () => {
       console.log('Received SIGINT, shutting down...');
+      this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 
     process.on('SIGTERM', () => {
       console.log('Received SIGTERM, shutting down...');
+      this.stopSmartRefreshScheduler();
       process.exit(0);
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",
@@ -47,6 +47,7 @@
     "@hello-pangea/dnd": "^18.0.1",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-progress": "^1.1.7",
+    "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.3",
     "@radix-ui/react-tabs": "^1.1.13",
     "@supabase/ssr": "^0.4.0",
@@ -56,6 +57,7 @@
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
     "dotenv": "^17.2.2",
+    "framer-motion": "^12.23.22",
     "lucide-react": "^0.542.0",
     "marked": "^16.2.1",
     "next": "15.0.0",
@@ -70,6 +72,7 @@
     "stripe": "^18.5.0",
     "tailwind-merge": "^3.3.1",
     "ts-node": "^10.9.2",
+    "use-debounce": "^10.0.6",
     "which": "^5.0.0"
   },
   "devDependencies": {