hedgequantx 2.7.99 → 2.8.1

package/package.json

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

package/src/menus/dashboard.js

@@ -242,18 +242,10 @@ const handleUpdate = async () => {
     
     spinner.succeed(`UPDATED TO V${latestVersion}!`);
     console.log(chalk.green('\n  ✓ UPDATE SUCCESSFUL!'));
-    console.log(chalk.cyan('\n  RESTARTING HQX...'));
-    
-    // Restart CLI with new version using spawn detached
-    const { spawn } = require('child_process');
-    const child = spawn('hqx', [], {
-      detached: true,
-      stdio: 'inherit',
-      shell: true
-    });
-    child.unref();
-    
-    // Exit current process to let new one take over
+    console.log(chalk.yellow('\n  Please restart HQX to use the new version.'));
+    console.log(chalk.cyan('  Run: hqx'));
+    console.log();
+    await prompts.waitForEnter();
     process.exit(0);
     
   } catch (error) {

package/src/pages/ai-agents-ui.js

@@ -5,8 +5,10 @@
  */
 
 const chalk = require('chalk');
+const ora = require('ora');
 const { centerText, visibleLength } = require('../ui');
 const cliproxy = require('../services/cliproxy');
+const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../services/ai-supervision');
 
 /**
  * Draw a 2-column row with perfect alignment
@@ -294,10 +296,53 @@ const drawProviderWindow = (provider, config, boxWidth) => {
   console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
 };
 
+/**
+ * Draw and run connection test for all agents
+ * @param {Array} agents - Array of agent configs
+ * @param {number} boxWidth - Box width
+ * @param {Function} clearWithBanner - Function to clear and show banner
+ * @returns {Promise<Object>} Test results
+ */
+const drawConnectionTest = async (agents, boxWidth, clearWithBanner) => {
+  if (agents.length === 0) {
+    console.log(chalk.yellow('\n  No agents configured. Connect an agent first.'));
+    return { success: false, error: 'No agents' };
+  }
+  
+  clearWithBanner();
+  const W = boxWidth - 2;
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+  console.log(chalk.cyan('║') + chalk.yellow.bold(centerText('AI AGENTS CONNECTION TEST', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + ' '.repeat(W) + chalk.cyan('║'));
+  
+  // Run pre-flight check
+  const spinner = ora({ text: 'Testing connections...', color: 'yellow' }).start();
+  const results = await runPreflightCheck(agents);
+  spinner.stop();
+  
+  // Display results
+  const lines = formatPreflightResults(results, boxWidth);
+  for (const line of lines) {
+    const paddedLine = line.length < W - 1 ? line + ' '.repeat(W - 1 - visibleLength(line)) : line;
+    console.log(chalk.cyan('║') + ' ' + paddedLine + chalk.cyan('║'));
+  }
+  
+  // Summary
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  const summary = getPreflightSummary(results);
+  console.log(chalk.cyan('║') + centerText(summary.text, W) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+  
+  return results;
+};
+
 module.exports = {
   draw2ColRow,
   draw2ColTable,
   drawProvidersTable,
   drawModelsTable,
-  drawProviderWindow
+  drawProviderWindow,
+  drawConnectionTest
 };

package/src/pages/ai-agents.js

@@ -14,7 +14,7 @@ const ora = require('ora');
 const { getLogoWidth, displayBanner } = require('../ui');
 const { prompts } = require('../utils');
 const { fetchModelsFromApi } = require('./ai-models');
-const { drawProvidersTable, drawModelsTable, drawProviderWindow } = require('./ai-agents-ui');
+const { drawProvidersTable, drawModelsTable, drawProviderWindow, drawConnectionTest } = require('./ai-agents-ui');
 const cliproxy = require('../services/cliproxy');
 
 /** Clear screen and show banner (always closed) */
@@ -102,70 +102,46 @@ const activateProvider = (config, providerId, data) => {
 };
 
 /** Wait for child process to exit */
-const waitForProcessExit = (childProcess, timeoutMs = 15000, intervalMs = 500) => {
-  return new Promise((resolve) => {
-    if (!childProcess) return resolve();
-    let elapsed = 0;
-    const checkInterval = setInterval(() => {
-      elapsed += intervalMs;
-      if (childProcess.exitCode !== null || childProcess.killed || elapsed >= timeoutMs) {
-        clearInterval(checkInterval);
-        if (elapsed >= timeoutMs) try { childProcess.kill(); } catch (e) { /* ignore */ }
-        resolve();
-      }
-    }, intervalMs);
-  });
-};
+const waitForProcessExit = (cp, timeoutMs = 15000, intervalMs = 500) => new Promise((resolve) => {
+  if (!cp) return resolve();
+  let elapsed = 0;
+  const check = setInterval(() => {
+    elapsed += intervalMs;
+    if (cp.exitCode !== null || cp.killed || elapsed >= timeoutMs) {
+      clearInterval(check);
+      if (elapsed >= timeoutMs) try { cp.kill(); } catch (e) {}
+      resolve();
+    }
+  }, intervalMs);
+});
 
 /** Handle CLIProxy connection (with auto-install) */
 const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log();
-  
-  // Check if CLIProxyAPI is installed
+  // Check/install CLIProxyAPI
   if (!cliproxy.isInstalled()) {
     console.log(chalk.yellow('  CLIPROXYAPI NOT INSTALLED. INSTALLING...'));
-    const spinner = ora({ text: 'DOWNLOADING CLIPROXYAPI...', color: 'yellow' }).start();
-    
-    const installResult = await cliproxy.install((msg, percent) => {
-      spinner.text = `${msg.toUpperCase()} ${percent}%`;
-    });
-    
-    if (!installResult.success) {
-      spinner.fail(`INSTALLATION FAILED: ${installResult.error.toUpperCase()}`);
-      await prompts.waitForEnter();
-      return false;
-    }
+    const spinner = ora({ text: 'DOWNLOADING...', color: 'yellow' }).start();
+    const installResult = await cliproxy.install((msg, percent) => { spinner.text = `${msg.toUpperCase()} ${percent}%`; });
+    if (!installResult.success) { spinner.fail(`INSTALL FAILED: ${installResult.error}`); await prompts.waitForEnter(); return false; }
     spinner.succeed('CLIPROXYAPI INSTALLED');
   }
-  
-  // Check if running, start if not (or restart if config missing)
+  // Check/start CLIProxy
   let status = await cliproxy.isRunning();
   if (!status.running) {
     const spinner = ora({ text: 'STARTING CLIPROXYAPI...', color: 'yellow' }).start();
     const startResult = await cliproxy.start();
-    
-    if (!startResult.success) {
-      spinner.fail(`FAILED TO START: ${startResult.error.toUpperCase()}`);
-      await prompts.waitForEnter();
-      return false;
-    }
+    if (!startResult.success) { spinner.fail(`START FAILED: ${startResult.error}`); await prompts.waitForEnter(); return false; }
     spinner.succeed('CLIPROXYAPI STARTED');
   } else {
-    // Running, but check if config exists (for proper API key auth)
-    const configPath = require('path').join(require('os').homedir(), '.hqx', 'cliproxy', 'config.yaml');
-    if (!require('fs').existsSync(configPath)) {
-      console.log(chalk.yellow('  RESTARTING CLIPROXYAPI WITH PROPER CONFIG...'));
+    const cfgPath = path.join(os.homedir(), '.hqx', 'cliproxy', 'config.yaml');
+    if (!fs.existsSync(cfgPath)) {
+      console.log(chalk.yellow('  RESTARTING CLIPROXYAPI...'));
       await cliproxy.stop();
-      const startResult = await cliproxy.start();
-      if (!startResult.success) {
-        console.log(chalk.red(`  FAILED TO RESTART: ${startResult.error.toUpperCase()}`));
-        await prompts.waitForEnter();
-        return false;
-      }
-      console.log(chalk.green('  ✓ CLIPROXYAPI RESTARTED'));
-    } else {
-      console.log(chalk.green('  ✓ CLIPROXYAPI IS RUNNING'));
-    }
+      const res = await cliproxy.start();
+      if (!res.success) { console.log(chalk.red(`  RESTART FAILED: ${res.error}`)); await prompts.waitForEnter(); return false; }
+      console.log(chalk.green('  ✓ RESTARTED'));
+    } else console.log(chalk.green('  ✓ CLIPROXYAPI RUNNING'));
   }
   
   // First, check if models are already available (existing auth)
@@ -397,7 +373,7 @@ const handleProviderConfig = async (provider, config) => {
   return config;
 };
 
-/** Get active AI provider config */
+/** Get active AI provider config (legacy - single provider) */
 const getActiveProvider = () => {
   const config = loadConfig();
   for (const provider of AI_PROVIDERS) {
@@ -409,15 +385,52 @@ const getActiveProvider = () => {
         connectionType: pc.connectionType,
         apiKey: pc.apiKey || null,
         modelId: pc.modelId || null,
-        modelName: pc.modelName || null
+        modelName: pc.modelName || null,
+        weight: pc.weight || 100
       };
     }
   }
   return null;
 };
 
+/** Get ALL active AI agents for multi-agent supervision */
+const getActiveAgents = () => {
+  const config = loadConfig();
+  const agents = [];
+  
+  for (const provider of AI_PROVIDERS) {
+    const pc = config.providers[provider.id];
+    if (pc && pc.active) {
+      agents.push({
+        id: `agent-${provider.id}`,
+        provider: provider.id,
+        name: provider.name,
+        connectionType: pc.connectionType,
+        apiKey: pc.apiKey || null,
+        modelId: pc.modelId || null,
+        modelName: pc.modelName || null,
+        weight: pc.weight || Math.floor(100 / AI_PROVIDERS.filter(p => config.providers[p.id]?.active).length),
+        active: true
+      });
+    }
+  }
+  
+  return agents;
+};
+
+/** Get supervision config for SupervisionEngine */
+const getSupervisionConfig = () => {
+  const agents = getActiveAgents();
+  return {
+    supervisionEnabled: agents.length > 0,
+    agents,
+    minAgents: 1,
+    timeout: 30000
+  };
+};
+
 /** Count active AI agents */
-const getActiveAgentCount = () => getActiveProvider() ? 1 : 0;
+const getActiveAgentCount = () => getActiveAgents().length;
 
 /** Main AI Agents menu */
 const aiAgentsMenu = async () => {
@@ -428,11 +441,26 @@ const aiAgentsMenu = async () => {
     clearWithBanner();
     drawProvidersTable(AI_PROVIDERS, config, boxWidth);
     
-    const input = await prompts.textInput(chalk.cyan('SELECT (1-8/B): '));
+    // Show [T] TEST option if agents are configured
+    const agentCount = getActiveAgentCount();
+    if (agentCount > 0) {
+      console.log(chalk.cyan('  [T] TEST ALL CONNECTIONS'));
+    }
+    console.log();
+    
+    const promptText = agentCount > 0 ? 'SELECT (1-8/T/B): ' : 'SELECT (1-8/B): ';
+    const input = await prompts.textInput(chalk.cyan(promptText));
     const choice = (input || '').toLowerCase().trim();
     
     if (choice === 'b' || choice === '') break;
     
+    if (choice === 't' && agentCount > 0) {
+      const agents = getActiveAgents();
+      await drawConnectionTest(agents, boxWidth, clearWithBanner);
+      await prompts.waitForEnter();
+      continue;
+    }
+    
     const num = parseInt(choice);
     if (!isNaN(num) && num >= 1 && num <= AI_PROVIDERS.length) {
       config = await handleProviderConfig(AI_PROVIDERS[num - 1], config);
@@ -447,6 +475,8 @@ const aiAgentsMenu = async () => {
 module.exports = {
   aiAgentsMenu,
   getActiveProvider,
+  getActiveAgents,
+  getSupervisionConfig,
   getActiveAgentCount,
   loadConfig,
   saveConfig,

package/src/pages/algo/algo-executor.js

@@ -1,12 +1,14 @@
 /**
  * Algo Executor - Shared execution engine for all algo modes
  * Handles market data, signals, orders, and P&L tracking
+ * Supports multi-agent AI supervision for signal optimization
  */
 
 const readline = require('readline');
 const { AlgoUI, renderSessionSummary } = require('./ui');
 const { M1 } = require('../../lib/m/s1');
 const { MarketDataFeed } = require('../../lib/data');
+const { SupervisionEngine } = require('../../services/ai-supervision');
 
 /**
  * Execute algo strategy with market data
@@ -15,11 +17,15 @@ const { MarketDataFeed } = require('../../lib/data');
  * @param {Object} params.account - Account object
  * @param {Object} params.contract - Contract object
  * @param {Object} params.config - Algo config (contracts, target, risk, showName)
- * @param {Object} params.options - Optional: aiSupervision, aiProvider, askAI function
+ * @param {Object} params.options - Optional: supervisionConfig for multi-agent AI
  */
 const executeAlgo = async ({ service, account, contract, config, options = {} }) => {
   const { contracts, dailyTarget, maxRisk, showName } = config;
-  const { aiSupervision, aiProvider, askAI, subtitle } = options;
+  const { supervisionConfig, subtitle } = options;
+  
+  // Initialize AI Supervision Engine if configured
+  const supervisionEnabled = supervisionConfig?.supervisionEnabled && supervisionConfig?.agents?.length > 0;
+  const supervisionEngine = supervisionEnabled ? new SupervisionEngine(supervisionConfig) : null;
   
   const accountName = showName 
     ? (account.accountName || account.rithmicAccountId || account.accountId) 
@@ -29,7 +35,7 @@ const executeAlgo = async ({ service, account, contract, config, options = {} })
   const tickSize = contract.tickSize || 0.25;
   
   const ui = new AlgoUI({ 
-    subtitle: subtitle || (aiSupervision ? 'CUSTOM STRATEGY + AI' : 'HQX Ultra Scalping'), 
+    subtitle: subtitle || (supervisionEnabled ? 'HQX + AI SUPERVISION' : 'HQX Ultra Scalping'), 
     mode: 'one-account' 
   });
   
@@ -57,8 +63,8 @@ const executeAlgo = async ({ service, account, contract, config, options = {} })
   let pendingOrder = false;
   let tickCount = 0;
   
-  // AI context for supervision
-  const aiContext = { recentTicks: [], recentSignals: [], maxTicks: 100 };
+  // Context for AI supervision
+  const aiContext = { recentTicks: [], recentSignals: [], recentTrades: [], maxTicks: 100 };
   
   // Initialize Strategy
   const strategy = new M1({ tickSize });
@@ -68,32 +74,68 @@ const executeAlgo = async ({ service, account, contract, config, options = {} })
   const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
   
   // Log startup
-  ui.addLog('info', `Strategy: ${aiSupervision ? 'CUSTOM + AI' : 'HQX Ultra Scalping'}`);
+  ui.addLog('info', `Strategy: ${supervisionEnabled ? 'HQX + AI Supervision' : 'HQX Ultra Scalping'}`);
   ui.addLog('info', `Account: ${accountName}`);
   ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
   ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
-  if (aiSupervision && aiProvider) ui.addLog('info', `AI: ${aiProvider.name} supervision`);
+  if (supervisionEnabled) {
+    const agentCount = supervisionEngine.getActiveCount();
+    ui.addLog('info', `AI Agents: ${agentCount} active`);
+  }
   ui.addLog('info', 'Connecting to market data...');
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
     if (!running || pendingOrder || currentPosition !== 0) return;
     
-    const { direction, entry, stopLoss, takeProfit, confidence } = signal;
+    let { direction, entry, stopLoss, takeProfit, confidence } = signal;
+    let orderSize = contracts;
     
     aiContext.recentSignals.push({ ...signal, timestamp: Date.now() });
     if (aiContext.recentSignals.length > 10) aiContext.recentSignals.shift();
     
     ui.addLog('info', `Signal: ${direction.toUpperCase()} @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
     
-    // AI Supervision check
-    if (aiSupervision && askAI) {
-      const aiDecision = await askAI(aiContext, signal, { symbolName, currentPosition, stats, dailyTarget, maxRisk });
-      if (!aiDecision.approve) {
-        ui.addLog('info', `AI rejected: ${aiDecision.reason || 'No reason'}`);
+    // Multi-Agent AI Supervision
+    if (supervisionEnabled && supervisionEngine) {
+      ui.addLog('info', 'AI analyzing signal...');
+      
+      const supervisionResult = await supervisionEngine.supervise({
+        symbolId: symbolName,
+        signal: { direction, entry, stopLoss, takeProfit, confidence, size: contracts },
+        recentTicks: aiContext.recentTicks,
+        recentSignals: aiContext.recentSignals,
+        recentTrades: aiContext.recentTrades,
+        stats,
+        config: { dailyTarget, maxRisk }
+      });
+      
+      if (!supervisionResult.success) {
+        ui.addLog('info', `AI: ${supervisionResult.reason || 'Error'}`);
+      } else if (supervisionResult.decision === 'reject') {
+        ui.addLog('info', `AI rejected (${supervisionResult.confidence}%): ${supervisionResult.reason}`);
         return;
+      } else {
+        // Apply optimizations
+        const opt = supervisionResult.optimizedSignal;
+        if (opt.aiOptimized) {
+          if (opt.entry !== entry) entry = opt.entry;
+          if (opt.stopLoss !== stopLoss) stopLoss = opt.stopLoss;
+          if (opt.takeProfit !== takeProfit) takeProfit = opt.takeProfit;
+          if (opt.size && opt.size !== contracts) orderSize = opt.size;
+        }
+        const action = supervisionResult.decision === 'modify' ? 'optimized' : 'approved';
+        ui.addLog('info', `AI ${action} (${supervisionResult.confidence}%): ${supervisionResult.reason}`);
+        
+        // Check timing
+        if (opt.aiTiming === 'wait') {
+          ui.addLog('info', 'AI: Wait for better entry');
+          return;
+        } else if (opt.aiTiming === 'cancel') {
+          ui.addLog('info', 'AI: Signal cancelled');
+          return;
+        }
       }
-      ui.addLog('info', `AI approved: ${aiDecision.reason || 'OK'}`);
     }
     
     // Place order
@@ -105,24 +147,24 @@ const executeAlgo = async ({ service, account, contract, config, options = {} })
         contractId: contractId,
         type: 2,
         side: orderSide,
-        size: contracts
+        size: orderSize
       });
       
       if (orderResult.success) {
-        currentPosition = direction === 'long' ? contracts : -contracts;
+        currentPosition = direction === 'long' ? orderSize : -orderSize;
         stats.trades++;
         ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), 
-          `OPENED ${direction.toUpperCase()} ${contracts}x @ market`);
+          `OPENED ${direction.toUpperCase()} ${orderSize}x @ market`);
         
         // Bracket orders
         if (stopLoss && takeProfit) {
           await service.placeOrder({
             accountId: account.accountId, contractId, type: 4,
-            side: direction === 'long' ? 1 : 0, size: contracts, stopPrice: stopLoss
+            side: direction === 'long' ? 1 : 0, size: orderSize, stopPrice: stopLoss
           });
           await service.placeOrder({
             accountId: account.accountId, contractId, type: 1,
-            side: direction === 'long' ? 1 : 0, size: contracts, limitPrice: takeProfit
+            side: direction === 'long' ? 1 : 0, size: orderSize, limitPrice: takeProfit
           });
           ui.addLog('info', `SL: ${stopLoss.toFixed(2)} | TP: ${takeProfit.toFixed(2)}`);
         }