hedgequantx 2.7.19 → 2.7.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.7.19",
+  "version": "2.7.21",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/ai-agents.js

@@ -10,8 +10,10 @@ const os = require('os');
 const path = require('path');
 const fs = require('fs');
 
+const ora = require('ora');
 const { getLogoWidth, centerText, visibleLength } = require('../ui');
 const { prompts } = require('../utils');
+const { fetchModelsFromApi } = require('./ai-models');
 
 // Config file path
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
@@ -63,7 +65,7 @@ const saveConfig = (config) => {
 };
 
 /**
- * Mask API key for display (show first 8 and last 4 chars)
+ * Mask API key for display
  * @param {string} key - API key
  * @returns {string} Masked key
  */
@@ -73,71 +75,107 @@ const maskKey = (key) => {
 };
 
 /**
- * Draw the main providers selection table (2 columns)
- * @param {Object} config - Current config
- * @param {number} boxWidth - Box width
+ * Draw a 2-column row
  */
-const drawProvidersTable = (config, boxWidth) => {
-  const W = boxWidth - 2;
+const draw2ColRow = (leftText, rightText, W) => {
   const col1Width = Math.floor(W / 2);
   const col2Width = W - col1Width;
-  
-  // Header
+  const leftLen = visibleLength(leftText);
+  const leftPad = col1Width - leftLen;
+  const leftPadL = Math.floor(leftPad / 2);
+  const rightLen = visibleLength(rightText || '');
+  const rightPad = col2Width - rightLen;
+  const rightPadL = Math.floor(rightPad / 2);
+  console.log(
+    chalk.cyan('║') +
+    ' '.repeat(leftPadL) + leftText + ' '.repeat(leftPad - leftPadL) +
+    ' '.repeat(rightPadL) + (rightText || '') + ' '.repeat(rightPad - rightPadL) +
+    chalk.cyan('║')
+  );
+};
+
+/**
+ * Draw 2-column table
+ */
+const draw2ColTable = (title, titleColor, items, backText, W) => {
   console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
-  console.log(chalk.cyan('║') + chalk.yellow.bold(centerText('AI AGENTS CONFIGURATION', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + titleColor(centerText(title, W)) + chalk.cyan('║'));
   console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
   
-  // Calculate max name length for alignment
-  const maxNameLen = Math.max(...AI_PROVIDERS.map(p => p.name.length));
-  
-  // Provider rows (2 columns)
-  const rows = Math.ceil(AI_PROVIDERS.length / 2);
+  const rows = Math.ceil(items.length / 2);
   for (let row = 0; row < rows; row++) {
-    const leftIdx = row;
-    const rightIdx = row + rows;
+    const left = items[row];
+    const right = items[row + rows];
+    draw2ColRow(left || '', right || '', W);
+  }
+  
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.red(centerText(backText, W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+};
+
+/**
+ * Draw providers table
+ */
+const drawProvidersTable = (config, boxWidth) => {
+  const W = boxWidth - 2;
+  const items = AI_PROVIDERS.map((p, i) => {
+    const status = config.providers[p.id]?.active ? chalk.green(' ●') : '';
+    return chalk.cyan(`[${i + 1}]`) + ' ' + chalk[p.color](p.name) + status;
+  });
+  draw2ColTable('AI AGENTS CONFIGURATION', chalk.yellow.bold, items, '[B] Back to Menu', W);
+};
+
+/**
+ * Draw models table
+ */
+const drawModelsTable = (provider, models, boxWidth) => {
+  const W = boxWidth - 2;
+  const items = models.map((m, i) => chalk.cyan(`[${i + 1}]`) + ' ' + chalk.white(m.name));
+  draw2ColTable(`${provider.name.toUpperCase()} - MODELS`, chalk[provider.color].bold, items, '[B] Back', W);
+};
+
+/**
+ * Select a model for a provider (fetches from API)
+ * @param {Object} provider - Provider object
+ * @param {string} apiKey - API key for fetching models
+ * @returns {Object|null} Selected model or null if cancelled/failed
+ */
+const selectModel = async (provider, apiKey) => {
+  const boxWidth = getLogoWidth();
+  
+  // Fetch models from API
+  const spinner = ora({ text: 'Fetching models from API...', color: 'yellow' }).start();
+  const result = await fetchModelsFromApi(provider.id, apiKey);
+  
+  if (!result.success || result.models.length === 0) {
+    spinner.fail(result.error || 'No models available');
+    await prompts.waitForEnter();
+    return null;
+  }
+  
+  spinner.succeed(`Found ${result.models.length} models`);
+  const models = result.models;
+  
+  while (true) {
+    console.clear();
+    drawModelsTable(provider, models, boxWidth);
     
-    const leftProvider = AI_PROVIDERS[leftIdx];
-    const rightProvider = AI_PROVIDERS[rightIdx];
+    const input = await prompts.textInput(chalk.cyan('Select model: '));
+    const choice = (input || '').toLowerCase().trim();
     
-    // Left column
-    const leftNum = `[${leftIdx + 1}]`;
-    const leftName = leftProvider.name;
-    const leftConfig = config.providers[leftProvider.id] || {};
-    const leftStatus = leftConfig.active ? chalk.green('●') : '';
-    const leftText = chalk.cyan(leftNum) + ' ' + chalk[leftProvider.color](leftName) + ' ' + leftStatus;
-    const leftLen = visibleLength(leftText);
-    const leftPadTotal = col1Width - leftLen;
-    const leftPadL = Math.floor(leftPadTotal / 2);
-    const leftPadR = leftPadTotal - leftPadL;
+    if (choice === 'b' || choice === '') {
+      return null;
+    }
     
-    // Right column
-    let rightText = '';
-    let rightPadL = 0;
-    let rightPadR = col2Width;
-    if (rightProvider) {
-      const rightNum = `[${rightIdx + 1}]`;
-      const rightName = rightProvider.name;
-      const rightConfig = config.providers[rightProvider.id] || {};
-      const rightStatus = rightConfig.active ? chalk.green('●') : '';
-      rightText = chalk.cyan(rightNum) + ' ' + chalk[rightProvider.color](rightName) + ' ' + rightStatus;
-      const rightLen = visibleLength(rightText);
-      const rightPadTotal = col2Width - rightLen;
-      rightPadL = Math.floor(rightPadTotal / 2);
-      rightPadR = rightPadTotal - rightPadL;
+    const num = parseInt(choice);
+    if (!isNaN(num) && num >= 1 && num <= models.length) {
+      return models[num - 1];
     }
     
-    console.log(
-      chalk.cyan('║') +
-      ' '.repeat(leftPadL) + leftText + ' '.repeat(leftPadR) +
-      ' '.repeat(rightPadL) + rightText + ' '.repeat(rightPadR) +
-      chalk.cyan('║')
-    );
+    console.log(chalk.red('  Invalid option.'));
+    await new Promise(r => setTimeout(r, 1000));
   }
-  
-  // Footer
-  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + chalk.red(centerText('[B] Back to Menu', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
 };
 
 /**
@@ -213,11 +251,8 @@ const drawProviderWindow = (provider, config, boxWidth) => {
   let statusText = '';
   if (providerConfig.active) {
     const connType = providerConfig.connectionType === 'cliproxy' ? 'CLIProxy' : 'API Key';
-    const keyDisplay = providerConfig.apiKey ? maskKey(providerConfig.apiKey) : 'N/A';
-    statusText = chalk.green('● ACTIVE') + chalk.gray(' via ') + chalk.cyan(connType);
-    if (providerConfig.connectionType === 'apikey' && providerConfig.apiKey) {
-      statusText += chalk.gray('  Key: ') + chalk.cyan(keyDisplay);
-    }
+    const modelName = providerConfig.modelName || 'N/A';
+    statusText = chalk.green('● ACTIVE') + chalk.gray('  Model: ') + chalk.yellow(modelName) + chalk.gray('  via ') + chalk.cyan(connType);
   } else if (providerConfig.apiKey || providerConfig.connectionType) {
     statusText = chalk.yellow('● CONFIGURED') + chalk.gray(' (not active)');
   } else {
@@ -269,10 +304,10 @@ const handleProviderConfig = async (provider, config) => {
     }
     
     if (choice === '1') {
-      // CLIProxy connection
+      // CLIProxy connection - models will be fetched via proxy
       console.log();
-      console.log(chalk.cyan('  Connecting via CLIProxy...'));
-      console.log(chalk.gray('  This uses your paid plan (Claude Pro, ChatGPT Plus, etc.)'));
+      console.log(chalk.cyan('  CLIProxy uses your paid plan subscription.'));
+      console.log(chalk.gray('  Model selection will be available after connecting.'));
       console.log();
       
       // Deactivate all other providers
@@ -282,6 +317,8 @@ const handleProviderConfig = async (provider, config) => {
       
       if (!config.providers[provider.id]) config.providers[provider.id] = {};
       config.providers[provider.id].connectionType = 'cliproxy';
+      config.providers[provider.id].modelId = null;
+      config.providers[provider.id].modelName = 'N/A';
       config.providers[provider.id].active = true;
       config.providers[provider.id].configuredAt = new Date().toISOString();
       
@@ -295,9 +332,9 @@ const handleProviderConfig = async (provider, config) => {
     }
     
     if (choice === '2') {
-      // API Key connection
-      console.log();
-      console.log(chalk.yellow(`  Enter your ${provider.name} API key:`));
+      // API Key connection - get key first, then fetch models
+      console.clear();
+      console.log(chalk.yellow(`\n  Enter your ${provider.name} API key:`));
       console.log(chalk.gray('  (Press Enter to cancel)'));
       console.log();
       
@@ -315,6 +352,10 @@ const handleProviderConfig = async (provider, config) => {
         continue;
       }
       
+      // Fetch models from API with the provided key
+      const selectedModel = await selectModel(provider, apiKey.trim());
+      if (!selectedModel) continue;
+      
       // Deactivate all other providers
       Object.keys(config.providers).forEach(id => {
         if (config.providers[id]) config.providers[id].active = false;
@@ -323,13 +364,16 @@ const handleProviderConfig = async (provider, config) => {
       if (!config.providers[provider.id]) config.providers[provider.id] = {};
       config.providers[provider.id].connectionType = 'apikey';
       config.providers[provider.id].apiKey = apiKey.trim();
+      config.providers[provider.id].modelId = selectedModel.id;
+      config.providers[provider.id].modelName = selectedModel.name;
       config.providers[provider.id].active = true;
       config.providers[provider.id].configuredAt = new Date().toISOString();
       
       if (saveConfig(config)) {
-        console.log(chalk.green(`  ✓ ${provider.name} connected via API Key.`));
+        console.log(chalk.green(`\n  ✓ ${provider.name} connected via API Key.`));
+        console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
       } else {
-        console.log(chalk.red('  Failed to save config.'));
+        console.log(chalk.red('\n  Failed to save config.'));
       }
       await prompts.waitForEnter();
       continue;
@@ -352,7 +396,9 @@ const getActiveProvider = () => {
         id: provider.id,
         name: provider.name,
         connectionType: providerConfig.connectionType,
-        apiKey: providerConfig.apiKey || null
+        apiKey: providerConfig.apiKey || null,
+        modelId: providerConfig.modelId || null,
+        modelName: providerConfig.modelName || null
       };
     }
   }

package/src/pages/ai-models.js

@@ -0,0 +1,224 @@
+/**
+ * AI Models - Fetch from provider APIs
+ * 
+ * Models are fetched dynamically from each provider's API.
+ * No hardcoded model lists - data comes from real APIs only.
+ */
+
+const https = require('https');
+
+/**
+ * API endpoints for fetching models
+ */
+const API_ENDPOINTS = {
+  anthropic: 'https://api.anthropic.com/v1/models',
+  openai: 'https://api.openai.com/v1/models',
+  google: 'https://generativelanguage.googleapis.com/v1/models',
+  mistral: 'https://api.mistral.ai/v1/models',
+  groq: 'https://api.groq.com/openai/v1/models',
+  xai: 'https://api.x.ai/v1/models',
+  perplexity: 'https://api.perplexity.ai/models',
+  openrouter: 'https://openrouter.ai/api/v1/models',
+};
+
+/**
+ * Make HTTPS request
+ * @param {string} url - API URL
+ * @param {Object} headers - Request headers
+ * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
+ * @returns {Promise<Object>} Response data
+ */
+const fetchApi = (url, headers = {}, timeout = 60000) => {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const options = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers
+      },
+      timeout
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve({ success: true, data: JSON.parse(data) });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}` });
+          }
+        } catch (error) {
+          resolve({ success: false, error: 'Invalid JSON response' });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      resolve({ success: false, error: error.message });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false, error: 'Request timeout' });
+    });
+
+    req.end();
+  });
+};
+
+/**
+ * Get auth headers for provider
+ * @param {string} providerId - Provider ID
+ * @param {string} apiKey - API key
+ * @returns {Object} Headers object
+ */
+const getAuthHeaders = (providerId, apiKey) => {
+  if (!apiKey) return {};
+  
+  switch (providerId) {
+    case 'anthropic':
+      return { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
+    case 'openai':
+    case 'groq':
+    case 'xai':
+    case 'perplexity':
+    case 'openrouter':
+      return { 'Authorization': `Bearer ${apiKey}` };
+    case 'google':
+      return {}; // Google uses query param
+    case 'mistral':
+      return { 'Authorization': `Bearer ${apiKey}` };
+    default:
+      return { 'Authorization': `Bearer ${apiKey}` };
+  }
+};
+
+/**
+ * Parse models response based on provider
+ * @param {string} providerId - Provider ID
+ * @param {Object} data - API response data
+ * @returns {Array} Parsed models list
+ */
+const parseModelsResponse = (providerId, data) => {
+  if (!data) return [];
+  
+  try {
+    switch (providerId) {
+      case 'anthropic':
+        // Anthropic returns { data: [{ id, display_name, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.display_name || m.id
+        }));
+      
+      case 'openai':
+      case 'groq':
+      case 'xai':
+        // OpenAI format: { data: [{ id, ... }] }
+        return (data.data || [])
+          .filter(m => m.id && !m.id.includes('whisper') && !m.id.includes('tts') && !m.id.includes('dall-e'))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+      
+      case 'google':
+        // Google format: { models: [{ name, displayName, ... }] }
+        return (data.models || []).map(m => ({
+          id: m.name?.replace('models/', '') || m.name,
+          name: m.displayName || m.name
+        }));
+      
+      case 'mistral':
+        // Mistral format: { data: [{ id, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.id
+        }));
+      
+      case 'perplexity':
+        // Perplexity format varies
+        return (data.models || data.data || []).map(m => ({
+          id: m.id || m.model,
+          name: m.id || m.model
+        }));
+      
+      case 'openrouter':
+        // OpenRouter format: { data: [{ id, name, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.name || m.id
+        }));
+      
+      default:
+        return [];
+    }
+  } catch (error) {
+    return [];
+  }
+};
+
+/**
+ * Fetch models from provider API
+ * @param {string} providerId - Provider ID
+ * @param {string} apiKey - API key (required for most providers)
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchModelsFromApi = async (providerId, apiKey) => {
+  const endpoint = API_ENDPOINTS[providerId];
+  if (!endpoint) {
+    return { success: false, models: [], error: 'Unknown provider' };
+  }
+  
+  // Build URL (Google needs API key in query)
+  let url = endpoint;
+  if (providerId === 'google' && apiKey) {
+    url += `?key=${apiKey}`;
+  }
+  
+  const headers = getAuthHeaders(providerId, apiKey);
+  const result = await fetchApi(url, headers);
+  
+  if (!result.success) {
+    return { success: false, models: [], error: result.error };
+  }
+  
+  const models = parseModelsResponse(providerId, result.data);
+  
+  if (models.length === 0) {
+    return { success: false, models: [], error: 'No models returned' };
+  }
+  
+  return { success: true, models, error: null };
+};
+
+/**
+ * Get models for a provider - returns empty, use fetchModelsFromApi
+ * @param {string} providerId - Provider ID
+ * @returns {Array} Empty array
+ */
+const getModelsForProvider = (providerId) => {
+  return [];
+};
+
+/**
+ * Get model by ID - returns null, use API data
+ * @param {string} providerId - Provider ID  
+ * @param {string} modelId - Model ID
+ * @returns {null} Always null
+ */
+const getModelById = (providerId, modelId) => {
+  return null;
+};
+
+module.exports = {
+  fetchModelsFromApi,
+  getModelsForProvider,
+  getModelById,
+  API_ENDPOINTS
+};