hedgequantx 2.6.127 → 2.6.128

package/package.json

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

package/src/pages/algo/one-account.js

@@ -34,6 +34,17 @@ const StrategySupervisor = require('../../services/ai/strategy-supervisor');
 
 
 
+/**
+ * Check if service supports fast path (Rithmic direct)
+ * @param {Object} service - Trading service
+ * @returns {boolean}
+ */
+const isRithmicFastPath = (service) => {
+  return typeof service.fastEntry === 'function' && 
+         typeof service.fastExit === 'function' &&
+         service.orderConn?.isConnected;
+};
+
 /**
  * One Account Menu
  */
@@ -78,21 +89,48 @@ const oneAccountMenu = async (service) => {
   // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
   const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
   
-  // Select symbol
-  const contract = await selectSymbol(accountService, selectedAccount);
-  if (!contract) return;
+  // Check if Rithmic (supports multi-symbol)
+  const isRithmicAccount = isRithmicFastPath(accountService);
+  
+  // Ask for multi-symbol mode (Rithmic only)
+  let useMultiSymbol = false;
+  if (isRithmicAccount) {
+    console.log();
+    useMultiSymbol = await prompts.confirmPrompt(chalk.cyan(`MULTI-SYMBOL MODE? (up to ${MAX_MULTI_SYMBOLS} symbols)`), false);
+    if (useMultiSymbol === null) return;
+  }
+  
+  // Select symbol(s)
+  const contracts = await selectSymbol(accountService, selectedAccount, useMultiSymbol);
+  if (!contracts) return;
+  
+  // Normalize to array
+  const contractList = Array.isArray(contracts) ? contracts : [contracts];
   
   // Configure algo
-  const config = await configureAlgo(selectedAccount, contract);
+  const config = await configureAlgo(selectedAccount, contractList);
   if (!config) return;
   
-  await launchAlgo(accountService, selectedAccount, contract, config);
+  // Launch appropriate algo
+  if (contractList.length === 1) {
+    await launchAlgo(accountService, selectedAccount, contractList[0], config);
+  } else {
+    await launchMultiSymbolRithmic(accountService, selectedAccount, contractList, config);
+  }
 };
 
+// Maximum symbols for multi-symbol trading
+const MAX_MULTI_SYMBOLS = 5;
+
 /**
  * Symbol selection - sorted with popular indices first
+ * Supports selecting multiple symbols (up to MAX_MULTI_SYMBOLS)
+ * @param {Object} service - Trading service
+ * @param {Object} account - Trading account  
+ * @param {boolean} allowMultiple - Allow selecting multiple symbols
+ * @returns {Object|Array|null} Single contract or array of contracts
  */
-const selectSymbol = async (service, account) => {
+const selectSymbol = async (service, account, allowMultiple = false) => {
   const spinner = ora({ text: 'LOADING SYMBOLS...', color: 'yellow' }).start();
   
   const contractsResult = await service.getContracts();
@@ -136,16 +174,86 @@ const selectSymbol = async (service, account) => {
   
   options.push({ label: chalk.gray('< BACK'), value: 'back' });
   
-  const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
-  return contract === 'back' || contract === null ? null : contract;
+  // Single symbol mode
+  if (!allowMultiple) {
+    const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
+    return contract === 'back' || contract === null ? null : contract;
+  }
+  
+  // Multi-symbol selection mode
+  const selectedContracts = [];
+  
+  while (selectedContracts.length < MAX_MULTI_SYMBOLS) {
+    console.log();
+    
+    // Show already selected symbols
+    if (selectedContracts.length > 0) {
+      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_MULTI_SYMBOLS}):`));
+      selectedContracts.forEach((c, i) => {
+        const name = c.name || c.symbol;
+        console.log(chalk.green(`    ${i + 1}. ${name}`));
+      });
+      console.log();
+    }
+    
+    // Filter out already selected
+    const availableOptions = options.filter(opt => {
+      if (opt.value === 'back') return true;
+      const optId = opt.value.id || opt.value.symbol || opt.value.name;
+      return !selectedContracts.some(sc => (sc.id || sc.symbol || sc.name) === optId);
+    });
+    
+    // Add DONE option if at least 1 selected
+    if (selectedContracts.length > 0) {
+      availableOptions.unshift({ 
+        label: chalk.green(`✓ DONE - Start trading ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''}`), 
+        value: 'done' 
+      });
+    }
+    
+    const promptText = selectedContracts.length === 0 
+      ? chalk.yellow(`SELECT SYMBOL (1/${MAX_MULTI_SYMBOLS}):`)
+      : chalk.yellow(`ADD SYMBOL (${selectedContracts.length + 1}/${MAX_MULTI_SYMBOLS}) OR DONE:`);
+    
+    const choice = await prompts.selectOption(promptText, availableOptions);
+    
+    if (choice === null || choice === 'back') {
+      if (selectedContracts.length === 0) return null;
+      selectedContracts.pop(); // Remove last
+      continue;
+    }
+    
+    if (choice === 'done') break;
+    
+    selectedContracts.push(choice);
+    
+    if (selectedContracts.length >= MAX_MULTI_SYMBOLS) {
+      console.log(chalk.yellow(`  Maximum ${MAX_MULTI_SYMBOLS} symbols reached`));
+      break;
+    }
+  }
+  
+  return selectedContracts.length > 0 ? selectedContracts : null;
 };
 
 /**
  * Configure algo
+ * @param {Object} account - Trading account
+ * @param {Object|Array} contractOrContracts - Single contract or array of contracts
  */
-const configureAlgo = async (account, contract) => {
+const configureAlgo = async (account, contractOrContracts) => {
+  const contractList = Array.isArray(contractOrContracts) ? contractOrContracts : [contractOrContracts];
+  
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
+  
+  // Show selected symbols
+  if (contractList.length > 1) {
+    console.log(chalk.white(`  Trading ${contractList.length} symbols:`));
+    contractList.forEach((c, i) => {
+      console.log(chalk.yellow(`    ${i + 1}. ${c.name || c.symbol}`));
+    });
+  }
   console.log();
   
   const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
@@ -197,17 +305,6 @@ const configureAlgo = async (account, contract) => {
   return { contracts, dailyTarget, maxRisk, showName, enableAI };
 };
 
-/**
- * Check if service supports fast path (Rithmic direct)
- * @param {Object} service - Trading service
- * @returns {boolean}
- */
-const isRithmicFastPath = (service) => {
-  return typeof service.fastEntry === 'function' && 
-         typeof service.fastExit === 'function' &&
-         service.orderConn?.isConnected;
-};
-
 /**
  * Launch algo trading - HQX Ultra Scalping Strategy
  * Real-time market data + Strategy signals + Auto order execution
@@ -1283,4 +1380,363 @@ const launchAlgo = async (service, account, contract, config) => {
   await prompts.waitForEnter();
 };
 
+/**
+ * Launch multi-symbol algo trading (Rithmic only)
+ * Uses single market feed connection with multiple subscriptions
+ * Each symbol has its own PositionManager and strategy instance
+ * 
+ * @param {Object} service - Rithmic trading service
+ * @param {Object} account - Trading account
+ * @param {Array} contracts - Array of contracts to trade
+ * @param {Object} config - Algo configuration
+ */
+const launchMultiSymbolRithmic = async (service, account, contracts, config) => {
+  const { contracts: qty, dailyTarget, maxRisk, showName, enableAI } = config;
+  
+  const accountName = showName 
+    ? (account.accountName || account.rithmicAccountId || account.accountId) 
+    : 'HQX *****';
+  const rithmicAccountId = account.rithmicAccountId || account.accountId;
+  
+  // Build symbols string for UI
+  const symbolNames = contracts.map(c => c.name || c.symbol);
+  const symbolsDisplay = symbolNames.join(', ');
+  
+  const ui = new AlgoUI({ 
+    subtitle: `MULTI-SYMBOL (${contracts.length})`, 
+    mode: 'one-account' 
+  });
+  
+  // Shared stats
+  const stats = {
+    accountName,
+    symbol: symbolsDisplay,
+    qty,
+    target: dailyTarget,
+    risk: maxRisk,
+    propfirm: account.propfirm || 'Unknown',
+    platform: 'RITHMIC',
+    pnl: null,
+    openPnl: null,
+    closedPnl: null,
+    balance: null,
+    position: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    sessionPnl: 0,
+    latency: 0,
+    connected: false,
+    startTime: Date.now(),
+    aiSupervision: enableAI || false,
+    fastPath: true,
+    // Per-symbol tracking
+    symbolStats: {},
+  };
+  
+  // Initialize per-symbol stats
+  contracts.forEach(c => {
+    const name = c.name || c.symbol;
+    stats.symbolStats[name] = { position: 0, trades: 0, wins: 0, losses: 0, pnl: 0 };
+  });
+  
+  let running = true;
+  let stopReason = null;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // POSITION MANAGERS - One per symbol
+  // ═══════════════════════════════════════════════════════════════════════════
+  const positionManagers = {};
+  const strategies = {};
+  
+  contracts.forEach(contract => {
+    const symbolName = contract.name || contract.symbol;
+    const contractId = contract.id || contract.symbol || contract.name;
+    const tickSize = contract.tickSize ?? null;
+    const tickValue = contract.tickValue ?? null;
+    
+    // Create strategy instance for this symbol
+    const strategy = Object.create(hftStrategy);
+    if (tickSize !== null && tickValue !== null) {
+      strategy.initialize(contractId, tickSize, tickValue);
+    }
+    strategies[symbolName] = strategy;
+    
+    // Create position manager for this symbol
+    const pm = new PositionManager(service, strategy);
+    if (tickSize !== null && tickValue !== null) {
+      pm.setContractInfo(symbolName, { tickSize, tickValue, contractId });
+    }
+    pm.start();
+    positionManagers[symbolName] = pm;
+    
+    // Position manager events
+    pm.on('entryFilled', ({ position, fillLatencyMs }) => {
+      const side = position.side === 0 ? 'LONG' : 'SHORT';
+      ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${position.entryPrice} | ${fillLatencyMs}ms`);
+      stats.symbolStats[symbolName].position = position.side === 0 ? position.size : -position.size;
+    });
+    
+    pm.on('exitFilled', ({ exitPrice, pnlTicks, holdDurationMs }) => {
+      const holdSec = (holdDurationMs / 1000).toFixed(1);
+      if (pnlTicks !== null && tickValue !== null) {
+        const pnlDollars = pnlTicks * tickValue;
+        stats.sessionPnl += pnlDollars;
+        stats.symbolStats[symbolName].pnl += pnlDollars;
+        stats.symbolStats[symbolName].trades++;
+        stats.trades++;
+        
+        if (pnlDollars >= 0) {
+          stats.wins++;
+          stats.symbolStats[symbolName].wins++;
+          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} | ${holdSec}s`);
+        } else {
+          stats.losses++;
+          stats.symbolStats[symbolName].losses++;
+          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} | ${holdSec}s`);
+        }
+      }
+      stats.symbolStats[symbolName].position = 0;
+      ui.render(stats);
+    });
+    
+    // Strategy signals
+    strategy.on('signal', async (signal) => {
+      if (!running) return;
+      if (!pm.canEnter(symbolName)) return;
+      
+      const { direction } = signal;
+      const orderSide = direction === 'long' ? 0 : 1;
+      const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
+      
+      ui.addLog('entry', `[${symbolName}] ${sideStr} signal`);
+      
+      const orderData = {
+        accountId: rithmicAccountId,
+        symbol: symbolName,
+        exchange: contract.exchange || 'CME',
+        size: qty,
+        side: orderSide,
+      };
+      
+      const entryResult = service.fastEntry(orderData);
+      if (entryResult.success) {
+        pm.registerEntry(entryResult, orderData, { tickSize, tickValue, contractId });
+      } else {
+        ui.addLog('error', `[${symbolName}] Entry failed: ${entryResult.error}`);
+      }
+    });
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // MARKET DATA FEED - Single connection, multiple subscriptions
+  // ═══════════════════════════════════════════════════════════════════════════
+  const marketFeed = new RithmicMarketDataFeed(service);
+  
+  marketFeed.on('connected', () => {
+    stats.connected = true;
+    ui.addLog('success', 'Market feed connected');
+    ui.render(stats);
+  });
+  
+  marketFeed.on('tick', (tick) => {
+    if (!running) return;
+    
+    stats.latency = tick.latency || 0;
+    
+    // Route tick to correct strategy based on symbol
+    const tickSymbol = tick.symbol;
+    
+    // Find matching strategy (ES matches ESH6, NQ matches NQH6, etc.)
+    for (const [symbolName, strategy] of Object.entries(strategies)) {
+      const baseSymbol = symbolName.replace(/[A-Z]\d+$/, '');
+      if (tickSymbol === baseSymbol || tickSymbol === symbolName || symbolName.startsWith(tickSymbol)) {
+        const tickData = {
+          contractId: tick.contractId || symbolName,
+          price: tick.price || tick.lastPrice || tick.bid,
+          bid: tick.bid,
+          ask: tick.ask,
+          volume: tick.volume || tick.size || 1,
+          timestamp: tick.timestamp || Date.now()
+        };
+        strategy.processTick(tickData);
+        
+        // Update price for position manager
+        service.emit('priceUpdate', {
+          symbol: symbolName,
+          price: tickData.price,
+          timestamp: tickData.timestamp,
+        });
+        break;
+      }
+    }
+    
+    ui.render(stats);
+  });
+  
+  marketFeed.on('error', (err) => {
+    ui.addLog('error', `Feed error: ${err.message}`);
+  });
+  
+  // Connect and subscribe
+  ui.render(stats);
+  ui.addLog('info', `MULTI-SYMBOL: ${contracts.length} symbols`);
+  
+  try {
+    await marketFeed.connect();
+    await new Promise(r => setTimeout(r, 1000));
+    
+    if (marketFeed.isConnected()) {
+      for (const contract of contracts) {
+        const symbolName = contract.name || contract.symbol;
+        const exchange = contract.exchange || 'CME';
+        marketFeed.subscribe(symbolName, exchange);
+        ui.addLog('success', `[${symbolName}] Subscribed`);
+      }
+    } else {
+      ui.addLog('error', 'Failed to connect market feed');
+    }
+  } catch (e) {
+    ui.addLog('error', `Connection error: ${e.message}`);
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // P&L UPDATES VIA WEBSOCKET
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (typeof service.on === 'function') {
+    service.on('pnlUpdate', (pnlData) => {
+      if (pnlData.accountId !== rithmicAccountId) return;
+      if (pnlData.closedPositionPnl !== undefined) {
+        stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
+      }
+      if (pnlData.accountBalance !== undefined) {
+        stats.balance = parseFloat(pnlData.accountBalance);
+      }
+      stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+    });
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // EMERGENCY STOP
+  // ═══════════════════════════════════════════════════════════════════════════
+  const emergencyStopAll = async () => {
+    ui.addLog('warning', '████ EMERGENCY STOP ████');
+    
+    // Close all positions
+    for (const [symbolName, pm] of Object.entries(positionManagers)) {
+      try {
+        if (pm.hasPosition(symbolName)) {
+          pm.closePosition(symbolName);
+          ui.addLog('info', `[${symbolName}] Closing position...`);
+        }
+      } catch (e) {
+        ui.addLog('error', `[${symbolName}] Close failed: ${e.message}`);
+      }
+    }
+    
+    ui.addLog('info', 'All close orders sent');
+    ui.render(stats);
+  };
+  
+  // Keyboard handler
+  let emergencyStopInProgress = false;
+  
+  const setupKeyHandler = () => {
+    if (!process.stdin.isTTY) return;
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    
+    const onKey = async (str, key) => {
+      if (key && (key.name === 'x' || key.name === 'X' || (key.ctrl && key.name === 'c'))) {
+        if (emergencyStopInProgress) return;
+        emergencyStopInProgress = true;
+        running = false;
+        stopReason = 'manual';
+        await emergencyStopAll();
+      }
+    };
+    process.stdin.on('keypress', onKey);
+    return () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    };
+  };
+  
+  const cleanupKeys = setupKeyHandler();
+  
+  // UI refresh
+  const refreshInterval = setInterval(() => {
+    if (running) ui.render(stats);
+  }, 1000);
+  
+  // Wait for stop
+  await new Promise(resolve => {
+    const check = setInterval(() => {
+      if (!running) {
+        clearInterval(check);
+        resolve();
+      }
+    }, 100);
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CLEANUP
+  // ═══════════════════════════════════════════════════════════════════════════
+  clearInterval(refreshInterval);
+  
+  // Stop all position managers
+  for (const pm of Object.values(positionManagers)) {
+    try { pm.stop(); } catch {}
+  }
+  
+  // Disconnect market feed
+  try { await marketFeed.disconnect(); } catch {}
+  
+  // Cleanup keyboard
+  try { if (cleanupKeys) cleanupKeys(); } catch {}
+  try { ui.cleanup(); } catch {}
+  
+  try {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.resume();
+  } catch {}
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SESSION SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  const durationMs = Date.now() - stats.startTime;
+  const hours = Math.floor(durationMs / 3600000);
+  const minutes = Math.floor((durationMs % 3600000) / 60000);
+  const seconds = Math.floor((durationMs % 60000) / 1000);
+  const duration = hours > 0 
+    ? `${hours}h ${minutes}m ${seconds}s`
+    : minutes > 0 
+      ? `${minutes}m ${seconds}s`
+      : `${seconds}s`;
+  
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log(chalk.cyan('                 MULTI-SYMBOL SESSION SUMMARY'));
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log();
+  
+  for (const [symbol, symStats] of Object.entries(stats.symbolStats)) {
+    const winRate = symStats.trades > 0 ? ((symStats.wins / symStats.trades) * 100).toFixed(0) : 0;
+    const pnlColor = symStats.pnl >= 0 ? chalk.green : chalk.red;
+    console.log(chalk.white(`  ${symbol}:`));
+    console.log(`    Trades: ${symStats.trades} | WR: ${winRate}% | P&L: ${pnlColor('$' + symStats.pnl.toFixed(2))}`);
+  }
+  
+  console.log();
+  const totalPnlColor = stats.sessionPnl >= 0 ? chalk.green : chalk.red;
+  console.log(chalk.white(`  TOTAL: ${stats.trades} trades | ${stats.wins}W/${stats.losses}L`));
+  console.log(chalk.white(`  Session P&L: ${totalPnlColor('$' + stats.sessionPnl.toFixed(2))}`));
+  console.log(chalk.white(`  Duration: ${duration}`));
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  
+  await prompts.waitForEnter();
+};
+
 module.exports = { oneAccountMenu };