hedgequantx 2.6.129 → 2.6.131

package/package.json

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

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

@@ -181,17 +181,18 @@ const selectSymbol = async (service, account, allowMultiple = false) => {
   }
   
   // Multi-symbol selection mode
+  // Each contract will have a 'qty' property for number of contracts
   const selectedContracts = [];
   
   while (selectedContracts.length < MAX_MULTI_SYMBOLS) {
     console.log();
     
-    // Show already selected symbols
+    // Show already selected symbols with quantities
     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(chalk.green(`    ${i + 1}. ${name} x${c.qty}`));
       });
       console.log();
     }
@@ -225,6 +226,13 @@ const selectSymbol = async (service, account, allowMultiple = false) => {
     
     if (choice === 'done') break;
     
+    // Ask for number of contracts for this symbol
+    const symbolName = choice.name || choice.symbol;
+    const qty = await prompts.numberInput(`CONTRACTS FOR ${symbolName}:`, 1, 1, 10);
+    if (qty === null) continue; // User cancelled, don't add symbol
+    
+    // Add qty to contract object
+    choice.qty = qty;
     selectedContracts.push(choice);
     
     if (selectedContracts.length >= MAX_MULTI_SYMBOLS) {
@@ -243,21 +251,29 @@ const selectSymbol = async (service, account, allowMultiple = false) => {
  */
 const configureAlgo = async (account, contractOrContracts) => {
   const contractList = Array.isArray(contractOrContracts) ? contractOrContracts : [contractOrContracts];
+  const isMultiSymbol = contractList.length > 1;
   
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
   
-  // Show selected symbols
-  if (contractList.length > 1) {
+  // Show selected symbols with quantities (multi-symbol mode)
+  if (isMultiSymbol) {
     console.log(chalk.white(`  Trading ${contractList.length} symbols:`));
     contractList.forEach((c, i) => {
-      console.log(chalk.yellow(`    ${i + 1}. ${c.name || c.symbol}`));
+      const name = c.name || c.symbol;
+      const qty = c.qty || 1;
+      console.log(chalk.yellow(`    ${i + 1}. ${name} x${qty}`));
     });
   }
   console.log();
   
-  const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
-  if (contracts === null) return null;
+  // Only ask for contracts in single-symbol mode
+  // In multi-symbol mode, qty is already set per symbol
+  let contracts = 1;
+  if (!isMultiSymbol) {
+    contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
+    if (contracts === null) return null;
+  }
   
   const dailyTarget = await prompts.numberInput('DAILY TARGET ($):', 1000, 1, 10000);
   if (dailyTarget === null) return null;
@@ -1393,27 +1409,33 @@ const launchAlgo = async (service, account, contract, config) => {
  * @param {Object} config - Algo configuration
  */
 const launchMultiSymbolRithmic = async (service, account, contracts, config) => {
-  const { contracts: qty, dailyTarget, maxRisk, showName, enableAI } = config;
+  const { 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(', ');
+  // Build symbols string for UI (with quantities)
+  const symbolsDisplay = contracts.map(c => {
+    const name = c.name || c.symbol;
+    const qty = c.qty || 1;
+    return `${name}x${qty}`;
+  }).join(', ');
   
   const ui = new AlgoUI({ 
     subtitle: `MULTI-SYMBOL (${contracts.length})`, 
     mode: 'one-account' 
   });
   
+  // Calculate total qty across all symbols
+  const totalQty = contracts.reduce((sum, c) => sum + (c.qty || 1), 0);
+  
   // Shared stats (same structure as launchAlgo)
   const stats = {
     accountName,
     symbol: symbolsDisplay,
-    qty,
+    qty: totalQty,
     target: dailyTarget,
     risk: maxRisk,
     propfirm: account.propfirm || 'Unknown',
@@ -1455,6 +1477,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       wins: 0, 
       losses: 0, 
       pnl: 0,
+      openPnl: 0, // Per-symbol unrealized P&L
       tickCount: 0,
     };
   });
@@ -1463,7 +1486,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   let stopReason = null;
   let tickCount = 0;
   
-  // Store contract info for later use
+  // Store contract info for later use (including qty per symbol)
   const contractInfoMap = {};
   contracts.forEach(c => {
     const name = c.name || c.symbol;
@@ -1472,6 +1495,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       tickValue: c.tickValue ?? null,
       contractId: c.id || c.symbol || c.name,
       exchange: c.exchange || 'CME',
+      qty: c.qty || 1, // Per-symbol quantity
     };
   });
   
@@ -1481,6 +1505,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   const positionManagers = {};
   const strategies = {};
   const pendingOrders = {}; // Track pending orders per symbol
+  const disabledSymbols = new Set(); // Symbols disabled after SL hit
   
   contracts.forEach(contract => {
     const symbolName = contract.name || contract.symbol;
@@ -1554,6 +1579,11 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
           stats.losses++;
           stats.symbolStats[symbolName].losses++;
           ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+          
+          // Disable symbol after loss (SL hit) - other symbols continue
+          disabledSymbols.add(symbolName);
+          ui.addLog('warning', `[${symbolName}] DISABLED - SL hit, other symbols continue`);
+          stats.activeSymbols = contracts.length - disabledSymbols.size;
         }
       } else if (pnlTicks !== null) {
         // Log with ticks only
@@ -1567,9 +1597,17 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
           stats.losses++;
           stats.symbolStats[symbolName].losses++;
           ui.addLog('loss', `[${symbolName}] ${pnlTicks} ticks | ${holdSec}s`);
+          
+          // Disable symbol after loss (SL hit) - other symbols continue
+          disabledSymbols.add(symbolName);
+          ui.addLog('warning', `[${symbolName}] DISABLED - SL hit, other symbols continue`);
+          stats.activeSymbols = contracts.length - disabledSymbols.size;
         }
       }
       stats.symbolStats[symbolName].position = 0;
+      stats.symbolStats[symbolName].openPnl = 0; // Reset open P&L when position closed
+      // Recalculate total Open P&L
+      stats.openPnl = Object.values(stats.symbolStats).reduce((sum, s) => sum + (s.openPnl || 0), 0);
       pendingOrders[symbolName] = false;
       ui.render(stats);
     });
@@ -1587,6 +1625,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     // ═══════════════════════════════════════════════════════════════════════
     strategy.on('signal', async (signal) => {
       if (!running) return;
+      if (disabledSymbols.has(symbolName)) return; // Skip disabled symbols (SL hit)
       if (pendingOrders[symbolName]) return;
       if (!pm.canEnter(symbolName)) return;
       
@@ -1594,19 +1633,22 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       const orderSide = direction === 'long' ? 0 : 1;
       const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
       
+      // Use per-symbol quantity
+      const symbolQty = contractInfoMap[symbolName].qty;
+      
       // Calculate risk amount
       const kelly = Math.min(0.25, confidence || 0.15);
       const riskAmount = Math.round(maxRisk * kelly);
       const riskPct = Math.round((riskAmount / maxRisk) * 100);
       
       pendingOrders[symbolName] = true;
-      ui.addLog('entry', `[${symbolName}] ${sideStr} ${qty}x | risk: $${riskAmount} (${riskPct}%)`);
+      ui.addLog('entry', `[${symbolName}] ${sideStr} ${symbolQty}x | risk: $${riskAmount} (${riskPct}%)`);
       
       const orderData = {
         accountId: rithmicAccountId,
         symbol: symbolName,
         exchange: contractInfoMap[symbolName].exchange,
-        size: qty,
+        size: symbolQty,
         side: orderSide,
       };
       
@@ -1747,6 +1789,32 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     algoLogger.error(ui, 'CONNECTION ERROR', e.message);
   }
   
+  // ═══════════════════════════════════════════════════════════════════════════
+  // TARGET/RISK CHECK - Stop algo when limits reached
+  // ═══════════════════════════════════════════════════════════════════════════
+  const checkTargetRisk = () => {
+    if (!running) return;
+    
+    const totalPnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+    
+    // Daily target reached - STOP with profit
+    if (totalPnl >= dailyTarget) {
+      stopReason = 'target';
+      running = false;
+      algoLogger.info(ui, 'TARGET REACHED', `+$${totalPnl.toFixed(2)} >= $${dailyTarget}`);
+      ui.addLog('success', `████ DAILY TARGET REACHED: +$${totalPnl.toFixed(2)} ████`);
+      emergencyStopAll(); // Close all positions
+    }
+    // Max risk reached - STOP to protect capital
+    else if (totalPnl <= -maxRisk) {
+      stopReason = 'risk';
+      running = false;
+      algoLogger.info(ui, 'MAX RISK HIT', `-$${Math.abs(totalPnl).toFixed(2)} <= -$${maxRisk}`);
+      ui.addLog('error', `████ MAX RISK REACHED: -$${Math.abs(totalPnl).toFixed(2)} ████`);
+      emergencyStopAll(); // Close all positions
+    }
+  };
+  
   // ═══════════════════════════════════════════════════════════════════════════
   // REAL-TIME P&L VIA WEBSOCKET (same as launchAlgo)
   // ═══════════════════════════════════════════════════════════════════════════
@@ -1774,10 +1842,14 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       }
       
       stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+      
+      // Check target/risk on every P&L update
+      checkTargetRisk();
+      
       ui.render(stats);
     });
     
-    // Position-level updates (for Open P&L)
+    // Position-level updates (for Open P&L per symbol)
     service.on('positionUpdate', (pos) => {
       if (!pos || pos.accountId !== rithmicAccountId) return;
       
@@ -1787,14 +1859,20 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
         if (posSymbol === baseSymbol || posSymbol === symbolName || symbolName.startsWith(posSymbol)) {
           stats.symbolStats[symbolName].position = pos.quantity || 0;
           
-          // Update Open P&L from position
+          // Update Open P&L for this symbol
           if (pos.openPnl !== undefined && pos.openPnl !== null) {
-            stats.openPnl = pos.openPnl;
+            stats.symbolStats[symbolName].openPnl = pos.openPnl;
+            
+            // Calculate total Open P&L from all symbols
+            stats.openPnl = Object.values(stats.symbolStats).reduce((sum, s) => sum + (s.openPnl || 0), 0);
             stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
             
             if (stats.balance !== null) {
               stats.netLiquidation = stats.balance + stats.openPnl;
             }
+            
+            // Check target/risk on Open P&L changes too
+            checkTargetRisk();
           }
           break;
         }