hedgequantx 2.6.126 → 2.6.127

package/package.json

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

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

@@ -78,32 +78,21 @@ 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 symbols (up to MAX_SYMBOLS)
-  const contracts = await selectSymbols(accountService, selectedAccount);
-  if (!contracts || contracts.length === 0) return;
+  // Select symbol
+  const contract = await selectSymbol(accountService, selectedAccount);
+  if (!contract) return;
   
-  // Configure algo (shared config for all symbols)
-  const config = await configureAlgo(selectedAccount, contracts);
+  // Configure algo
+  const config = await configureAlgo(selectedAccount, contract);
   if (!config) return;
   
-  // Launch algo for all selected symbols
-  if (contracts.length === 1) {
-    // Single symbol - use original launchAlgo
-    await launchAlgo(accountService, selectedAccount, contracts[0], config);
-  } else {
-    // Multiple symbols - launch parallel trading
-    await launchMultiAlgo(accountService, selectedAccount, contracts, config);
-  }
+  await launchAlgo(accountService, selectedAccount, contract, config);
 };
 
-// Maximum number of symbols to trade simultaneously
-const MAX_SYMBOLS = 5;
-
 /**
  * Symbol selection - sorted with popular indices first
- * Allows selecting multiple symbols (up to MAX_SYMBOLS)
  */
-const selectSymbols = async (service, account) => {
+const selectSymbol = async (service, account) => {
   const spinner = ora({ text: 'LOADING SYMBOLS...', color: 'yellow' }).start();
   
   const contractsResult = await service.getContracts();
@@ -137,102 +126,28 @@ const selectSymbols = async (service, account) => {
   
   spinner.succeed(`FOUND ${contracts.length} CONTRACTS`);
   
-  // Multi-symbol selection loop
-  const selectedContracts = [];
+  // Display sorted contracts from API (uniform format: NAME - DESCRIPTION)
+  const options = contracts.map(c => {
+    const name = c.name || c.symbol || c.baseSymbol;
+    const desc = c.description || '';
+    const label = desc ? `${name} - ${desc}` : name;
+    return { label, value: c };
+  });
   
-  while (selectedContracts.length < MAX_SYMBOLS) {
-    console.log();
-    if (selectedContracts.length > 0) {
-      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_SYMBOLS}):`));
-      selectedContracts.forEach((c, i) => {
-        const name = c.name || c.symbol || c.baseSymbol;
-        console.log(chalk.green(`    ${i + 1}. ${name}`));
-      });
-      console.log();
-    }
-    
-    // Filter out already selected contracts
-    const availableContracts = contracts.filter(c => {
-      const cId = c.id || c.symbol || c.name;
-      return !selectedContracts.some(sc => (sc.id || sc.symbol || sc.name) === cId);
-    });
-    
-    // Build options
-    const options = availableContracts.map(c => {
-      const name = c.name || c.symbol || c.baseSymbol;
-      const desc = c.description || '';
-      const label = desc ? `${name} - ${desc}` : name;
-      return { label, value: c };
-    });
-    
-    // Add done/back options
-    if (selectedContracts.length > 0) {
-      options.unshift({ label: chalk.green(`✓ DONE (trade ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''})`), value: 'done' });
-    }
-    options.push({ label: chalk.gray('< BACK'), value: 'back' });
-    
-    const promptText = selectedContracts.length === 0 
-      ? chalk.yellow(`SELECT SYMBOL (1-${MAX_SYMBOLS}):`)
-      : chalk.yellow(`ADD SYMBOL (${selectedContracts.length + 1}/${MAX_SYMBOLS}) OR DONE:`);
-    
-    const choice = await prompts.selectOption(promptText, options);
-    
-    if (choice === 'back' || choice === null) {
-      if (selectedContracts.length === 0) {
-        return null; // Go back
-      }
-      // Remove last selected
-      selectedContracts.pop();
-      continue;
-    }
-    
-    if (choice === 'done') {
-      break; // Done selecting
-    }
-    
-    // Add selected contract
-    selectedContracts.push(choice);
-    
-    if (selectedContracts.length >= MAX_SYMBOLS) {
-      console.log(chalk.yellow(`  MAX ${MAX_SYMBOLS} SYMBOLS REACHED`));
-      break;
-    }
-  }
+  options.push({ label: chalk.gray('< BACK'), value: 'back' });
   
-  return selectedContracts.length > 0 ? selectedContracts : null;
-};
-
-/**
- * Legacy single symbol selection (kept for compatibility)
- */
-const selectSymbol = async (service, account) => {
-  const contracts = await selectSymbols(service, account);
-  return contracts && contracts.length > 0 ? contracts[0] : null;
+  const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
+  return contract === 'back' || contract === null ? null : contract;
 };
 
 /**
  * Configure algo
- * @param {Object} account - Trading account
- * @param {Array|Object} contractsOrContract - Single contract or array of contracts
  */
-const configureAlgo = async (account, contractsOrContract) => {
-  // Normalize to array
-  const contractList = Array.isArray(contractsOrContract) ? contractsOrContract : [contractsOrContract];
-  
+const configureAlgo = async (account, contract) => {
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
   console.log();
   
-  // Show selected symbols
-  if (contractList.length > 1) {
-    console.log(chalk.white(`  TRADING ${contractList.length} SYMBOLS:`));
-    contractList.forEach((c, i) => {
-      const name = c.name || c.symbol || c.baseSymbol;
-      console.log(chalk.yellow(`    ${i + 1}. ${name}`));
-    });
-    console.log();
-  }
-  
   const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
   if (contracts === null) return null;
   
@@ -1368,291 +1283,4 @@ const launchAlgo = async (service, account, contract, config) => {
   await prompts.waitForEnter();
 };
 
-/**
- * Launch multi-symbol algo trading
- * Runs multiple symbols in parallel on the same account
- * 
- * @param {Object} service - Trading service
- * @param {Object} account - Trading account
- * @param {Array} contracts - Array of contracts to trade
- * @param {Object} config - Algo configuration
- */
-const launchMultiAlgo = async (service, account, contracts, config) => {
-  const { contracts: qty, dailyTarget, maxRisk, showName } = config;
-  
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
-  const connectionType = account.platform || 'ProjectX';
-  const useFastPath = isRithmicFastPath(service);
-  
-  // Build symbol list string
-  const symbolNames = contracts.map(c => c.name || c.symbol || c.baseSymbol);
-  const symbolsStr = symbolNames.join(', ');
-  
-  const ui = new AlgoUI({ 
-    subtitle: `MULTI-SYMBOL (${contracts.length})`, 
-    mode: 'one-account' 
-  });
-  
-  // Shared stats across all symbols
-  const stats = {
-    accountName,
-    symbol: symbolsStr,
-    qty,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: connectionType,
-    pnl: null,
-    openPnl: null,
-    closedPnl: null,
-    balance: null,
-    buyingPower: null,
-    margin: null,
-    netLiquidation: null,
-    position: 0,
-    entryPrice: 0,
-    lastPrice: 0,
-    trades: 0,
-    wins: 0,
-    losses: 0,
-    sessionPnl: 0,
-    latency: 0,
-    connected: false,
-    startTime: Date.now(),
-    aiSupervision: config.enableAI || false,
-    aiMode: null,
-    agentCount: 0,
-    fastPath: useFastPath,
-    avgEntryLatency: 0,
-    avgFillLatency: 0,
-    entryLatencies: [],
-    // Multi-symbol specific
-    activeSymbols: contracts.length,
-    symbolStats: {}, // Per-symbol stats
-  };
-  
-  // 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;
-  
-  // Track market feeds and position managers for cleanup
-  const marketFeeds = [];
-  const positionManagers = [];
-  
-  ui.render(stats);
-  ui.addLog('info', `MULTI-SYMBOL MODE: ${contracts.length} symbols`);
-  symbolNames.forEach(name => ui.addLog('info', `  → ${name}`));
-  
-  // Launch trading for each symbol
-  const symbolPromises = contracts.map(async (contract, index) => {
-    const symbolName = contract.name || contract.symbol;
-    const contractId = contract.id || contract.symbol || contract.name;
-    const tickSize = contract.tickSize ?? null;
-    const tickValue = contract.tickValue ?? null;
-    
-    // Initialize strategy for this symbol
-    const strategy = (USE_HFT_STRATEGY && useFastPath) ? hftStrategy : M1;
-    if (tickSize !== null && tickValue !== null) {
-      strategy.initialize(contractId, tickSize, tickValue);
-    }
-    
-    // Initialize Position Manager for fast path
-    let positionManager = null;
-    if (useFastPath) {
-      positionManager = new PositionManager(service, strategy);
-      if (tickSize !== null && tickValue !== null) {
-        positionManager.setContractInfo(symbolName, { tickSize, tickValue, contractId });
-      }
-      positionManager.start();
-      positionManagers.push(positionManager);
-      
-      // Position manager events
-      positionManager.on('entryFilled', ({ position, fillLatencyMs }) => {
-        stats.entryLatencies.push(fillLatencyMs);
-        stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
-        const side = position.side === 0 ? 'LONG' : 'SHORT';
-        ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${position.entryPrice} | ${fillLatencyMs}ms`);
-      });
-      
-      positionManager.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;
-          
-          if (pnlDollars >= 0) {
-            stats.wins++;
-            stats.symbolStats[symbolName].wins++;
-            ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
-          } else {
-            stats.losses++;
-            stats.symbolStats[symbolName].losses++;
-            ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
-          }
-          stats.trades++;
-          stats.symbolStats[symbolName].trades++;
-        }
-        ui.render(stats);
-      });
-    }
-    
-    // Connect market feed for this symbol
-    const MarketFeedClass = useFastPath ? RithmicMarketDataFeed : MarketDataFeed;
-    const marketFeed = new MarketFeedClass(service);
-    marketFeeds.push(marketFeed);
-    
-    try {
-      await marketFeed.connect(contractId, account.accountId);
-      ui.addLog('success', `[${symbolName}] Market feed connected`);
-      stats.connected = true;
-      
-      // Handle market data ticks
-      marketFeed.on('tick', (tick) => {
-        if (!running) return;
-        
-        stats.latency = tick.latency || 0;
-        stats.lastPrice = tick.price || tick.last || 0;
-        
-        // Get strategy signal
-        const signal = strategy.onTick ? strategy.onTick(tick) : strategy.analyze?.(tick);
-        
-        if (signal && signal.action && signal.action !== 'hold') {
-          if (useFastPath && positionManager) {
-            // Fast path execution
-            if (signal.action === 'buy' || signal.action === 'long') {
-              positionManager.openPosition(symbolName, contract.exchange || 'CME', 0, qty, account.accountId);
-            } else if (signal.action === 'sell' || signal.action === 'short') {
-              positionManager.openPosition(symbolName, contract.exchange || 'CME', 1, qty, account.accountId);
-            } else if (signal.action === 'close' || signal.action === 'exit') {
-              positionManager.closePosition(symbolName);
-            }
-          }
-        }
-        
-        ui.render(stats);
-      });
-      
-    } catch (err) {
-      ui.addLog('error', `[${symbolName}] Failed to connect: ${err.message}`);
-    }
-  });
-  
-  // Wait for all symbols to initialize
-  await Promise.all(symbolPromises);
-  
-  // Keyboard handler for emergency stop
-  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';
-        
-        ui.addLog('warning', '████ EMERGENCY STOP - CLOSING ALL POSITIONS ████');
-        
-        // Close all positions on all symbols
-        for (const pm of positionManagers) {
-          try {
-            pm.closeAllPositions();
-          } catch (e) {}
-        }
-        
-        ui.addLog('info', 'All positions closed');
-        ui.render(stats);
-      }
-    };
-    process.stdin.on('keypress', onKey);
-    return () => {
-      process.stdin.removeListener('keypress', onKey);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-    };
-  };
-  
-  const cleanupKeys = setupKeyHandler();
-  
-  // Wait for stop
-  await new Promise(resolve => {
-    const check = setInterval(() => {
-      if (!running) {
-        clearInterval(check);
-        resolve();
-      }
-    }, 100);
-  });
-  
-  // Cleanup
-  for (const pm of positionManagers) {
-    try { pm.stop(); } catch {}
-  }
-  
-  for (const feed of marketFeeds) {
-    try { await feed.disconnect(); } catch {}
-  }
-  
-  try { if (cleanupKeys) cleanupKeys(); } catch {}
-  try { ui.cleanup(); } catch {}
-  
-  try {
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-    process.stdin.resume();
-  } catch {}
-  
-  // Duration
-  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);
-  stats.duration = hours > 0 
-    ? `${hours}h ${minutes}m ${seconds}s`
-    : minutes > 0 
-      ? `${minutes}m ${seconds}s`
-      : `${seconds}s`;
-  
-  // Summary with per-symbol breakdown
-  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();
-  console.log(chalk.white(`  TOTAL: ${stats.trades} trades | ${stats.wins}W/${stats.losses}L | Session P&L: ${stats.sessionPnl >= 0 ? chalk.green('$' + stats.sessionPnl.toFixed(2)) : chalk.red('$' + stats.sessionPnl.toFixed(2))}`));
-  console.log(chalk.white(`  Duration: ${stats.duration}`));
-  console.log();
-  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
-  
-  await prompts.waitForEnter();
-};
-
 module.exports = { oneAccountMenu };