hedgequantx 2.6.45 → 2.6.47

package/package.json

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

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

@@ -245,14 +245,21 @@ const launchAlgo = async (service, account, contract, config) => {
     risk: maxRisk,
     propfirm: account.propfirm || 'Unknown',
     platform: connectionType,
-    pnl: 0,
-    // R Trader style P&L breakdown
-    openPnl: 0,      // Unrealized P&L (current position)
-    closedPnl: 0,    // Realized P&L (closed trades today)
-    // Position info (like R Trader)
-    position: 0,     // Current position qty (+ long, - short)
-    entryPrice: 0,   // Average entry price
-    lastPrice: 0,    // Last market price
+    // ═══════════════════════════════════════════════════════════════════════════
+    // R TRADER METRICS - All from Rithmic API (ACCOUNT_PNL_UPDATE 451)
+    // ═══════════════════════════════════════════════════════════════════════════
+    pnl: null,             // Today's P&L (openPnl + closedPnl)
+    openPnl: null,         // Unrealized P&L (current position) - from INSTRUMENT_PNL_UPDATE 450
+    closedPnl: null,       // Realized P&L (closed trades today)
+    balance: null,         // Account Balance
+    buyingPower: null,     // Available Buying Power
+    margin: null,          // Margin Balance
+    netLiquidation: null,  // Net Liquidation Value (balance + openPnl)
+    // Position info (like R Trader Positions panel) - from INSTRUMENT_PNL_UPDATE 450
+    position: 0,           // Current position qty (+ long, - short)
+    entryPrice: 0,         // Average entry price
+    lastPrice: 0,          // Last market price (from ticker)
+    // Trading stats
     trades: 0,
     wins: 0,
     losses: 0,
@@ -379,12 +386,37 @@ const launchAlgo = async (service, account, contract, config) => {
     // Only update for our account
     if (pnlData.accountId !== rithmicAccountId) return;
     
-    // ACCOUNT_PNL_UPDATE (451) provides account-level totals
-    // closedPositionPnl = realized P&L from all closed trades today
-    const closedPnl = parseFloat(pnlData.closedPositionPnl || 0);
+    // ═══════════════════════════════════════════════════════════════════════════
+    // ACCOUNT_PNL_UPDATE (451) - All R Trader account-level metrics
+    // ═══════════════════════════════════════════════════════════════════════════
     
-    // Update closed P&L (realized) from account-level data
-    stats.closedPnl = closedPnl;
+    // Closed P&L (realized) - from closed trades today
+    if (pnlData.closedPositionPnl !== undefined) {
+      stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
+    }
+    
+    // Account Balance
+    if (pnlData.accountBalance !== undefined) {
+      stats.balance = parseFloat(pnlData.accountBalance);
+    }
+    
+    // Buying Power (Available)
+    if (pnlData.availableBuyingPower !== undefined) {
+      stats.buyingPower = parseFloat(pnlData.availableBuyingPower);
+    }
+    
+    // Margin Balance
+    if (pnlData.marginBalance !== undefined) {
+      stats.margin = parseFloat(pnlData.marginBalance);
+    }
+    
+    // Net Liquidation Value (balance + openPnl) - same as R Trader
+    if (pnlData.netLiquidation !== undefined) {
+      stats.netLiquidation = parseFloat(pnlData.netLiquidation);
+    } else if (stats.balance !== null) {
+      // Calculate if not provided directly
+      stats.netLiquidation = stats.balance + (stats.openPnl || 0);
+    }
     
     // Total P&L = openPnl (from positionUpdate) + closedPnl (from pnlUpdate)
     // This matches R Trader's "Today's P&L" calculation
@@ -406,11 +438,13 @@ const launchAlgo = async (service, account, contract, config) => {
     // pos.openPnl comes from INSTRUMENT_PNL_UPDATE (450) - this is the unrealized P&L
     if (pos.openPnl !== undefined && pos.openPnl !== null) {
       stats.openPnl = pos.openPnl;
-    }
-    // Update day P&L if available
-    if (pos.dayPnl !== undefined && pos.dayPnl !== null) {
+      // Recalculate total P&L whenever Open P&L changes
       // Total P&L = openPnl + closedPnl (same formula as R Trader)
       stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+      // Also update Net Liquidation (balance + openPnl)
+      if (stats.balance !== null) {
+        stats.netLiquidation = stats.balance + stats.openPnl;
+      }
     }
   });
   

package/src/pages/algo/ui.js

@@ -210,29 +210,55 @@ class AlgoUI {
     
     this._line(chalk.cyan(GM));
     
-    // Row 4: Target | Risk
+    // Row 4: Balance | Net Liquidation (R Trader style)
+    const balanceStr = stats.balance !== null && stats.balance !== undefined 
+      ? '$' + stats.balance.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+      : '--';
+    const netLiqStr = stats.netLiquidation !== null && stats.netLiquidation !== undefined
+      ? '$' + stats.netLiquidation.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+      : '--';
+    const r4c1 = buildCell('BALANCE', balanceStr, chalk.white, colL);
+    const r4c2 = buildCell('NET LIQ', netLiqStr, chalk.cyan, colR);
+    row(r4c1.padded, r4c2.padded);
+    
+    this._line(chalk.cyan(GM));
+    
+    // Row 5: Buying Power | Margin (R Trader style)
+    const bpStr = stats.buyingPower !== null && stats.buyingPower !== undefined
+      ? '$' + stats.buyingPower.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+      : '--';
+    const marginStr = stats.margin !== null && stats.margin !== undefined
+      ? '$' + stats.margin.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+      : '--';
+    const r5c1 = buildCell('BUYING PWR', bpStr, chalk.green, colL);
+    const r5c2 = buildCell('MARGIN', marginStr, chalk.yellow, colR);
+    row(r5c1.padded, r5c2.padded);
+    
+    this._line(chalk.cyan(GM));
+    
+    // Row 6: Target | Risk
     const targetStr = stats.target !== null && stats.target !== undefined ? '$' + stats.target.toFixed(2) : '--';
     const riskStr = stats.risk !== null && stats.risk !== undefined ? '$' + stats.risk.toFixed(2) : '--';
-    const r4c1 = buildCell('TARGET', targetStr, chalk.green, colL);
-    const r4c2 = buildCell('RISK', riskStr, chalk.red, colR);
-    row(r4c1.padded, r4c2.padded);
+    const r6c1 = buildCell('TARGET', targetStr, chalk.green, colL);
+    const r6c2 = buildCell('RISK', riskStr, chalk.red, colR);
+    row(r6c1.padded, r6c2.padded);
     
     this._line(chalk.cyan(GM));
     
-    // Row 5: Trades W/L | Entry Price (if in position)
-    const r5c1t = ` ${chalk.bold('TRADES')}: ${chalk.cyan.bold(stats.trades || 0)}  ${chalk.bold('W/L')}: ${chalk.green.bold(stats.wins || 0)}/${chalk.red.bold(stats.losses || 0)}`;
-    const r5c1p = ` TRADES: ${stats.trades || 0}  W/L: ${stats.wins || 0}/${stats.losses || 0}`;
+    // Row 7: Trades W/L | Entry Price (if in position)
+    const r7c1t = ` ${chalk.bold('TRADES')}: ${chalk.cyan.bold(stats.trades || 0)}  ${chalk.bold('W/L')}: ${chalk.green.bold(stats.wins || 0)}/${chalk.red.bold(stats.losses || 0)}`;
+    const r7c1p = ` TRADES: ${stats.trades || 0}  W/L: ${stats.wins || 0}/${stats.losses || 0}`;
     const entryStr = stats.entryPrice > 0 ? stats.entryPrice.toFixed(2) : '--';
-    const r5c2 = buildCell('ENTRY', entryStr, chalk.yellow, colR);
-    row(r5c1t + pad(colL - r5c1p.length), r5c2.padded);
+    const r7c2 = buildCell('ENTRY', entryStr, chalk.yellow, colR);
+    row(r7c1t + pad(colL - r7c1p.length), r7c2.padded);
     
     this._line(chalk.cyan(GM));
     
-    // Row 6: Connection | Propfirm
+    // Row 8: Connection | Propfirm
     const connection = stats.platform || 'ProjectX';
-    const r6c1 = buildCell('CONNECTION', connection, chalk.cyan, colL);
-    const r6c2 = buildCell('PROPFIRM', stats.propfirm || 'N/A', chalk.cyan, colR);
-    row(r6c1.padded, r6c2.padded);
+    const r8c1 = buildCell('CONNECTION', connection, chalk.cyan, colL);
+    const r8c2 = buildCell('PROPFIRM', stats.propfirm || 'N/A', chalk.cyan, colR);
+    row(r8c1.padded, r8c2.padded);
     
     this._line(chalk.cyan(GB));
   }

package/src/services/rithmic/accounts.js

@@ -109,28 +109,46 @@ const getTradingAccounts = async (service) => {
     debug(`Account ${acc.accountId} pnlData:`, JSON.stringify(pnlData));
     debug(`  accountPnL map size:`, service.accountPnL.size);
     
-    // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS
-    const accountBalance = pnlData.accountBalance ? parseFloat(pnlData.accountBalance) : null;
-    const openPnL = pnlData.openPositionPnl ? parseFloat(pnlData.openPositionPnl) : null;
-    const closedPnL = pnlData.closedPositionPnl ? parseFloat(pnlData.closedPositionPnl) : null;
-    const dayPnL = pnlData.dayPnl ? parseFloat(pnlData.dayPnl) : null;
+    // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS (RULES.md compliant)
+    // All values are null if not available from API
+    const accountBalance = pnlData.accountBalance !== undefined ? parseFloat(pnlData.accountBalance) : null;
+    const openPnL = pnlData.openPositionPnl !== undefined ? parseFloat(pnlData.openPositionPnl) : null;
+    const closedPnL = pnlData.closedPositionPnl !== undefined ? parseFloat(pnlData.closedPositionPnl) : null;
+    const dayPnL = pnlData.dayPnl !== undefined ? parseFloat(pnlData.dayPnl) : null;
+    
+    // R Trader additional metrics (from ACCOUNT_PNL_UPDATE 451)
+    const buyingPower = pnlData.availableBuyingPower !== undefined ? parseFloat(pnlData.availableBuyingPower) : null;
+    const margin = pnlData.marginBalance !== undefined ? parseFloat(pnlData.marginBalance) : null;
+    const cashOnHand = pnlData.cashOnHand !== undefined ? parseFloat(pnlData.cashOnHand) : null;
 
     // Calculate P&L like R Trader: openPositionPnl + closedPositionPnl
     // This matches what R Trader shows as "Today's P&L"
     const totalPnL = (openPnL !== null || closedPnL !== null) 
       ? (openPnL || 0) + (closedPnL || 0) 
       : null;
+    
+    // Net Liquidation Value = Account Balance + Open P&L (same as R Trader)
+    const netLiquidation = (accountBalance !== null || openPnL !== null)
+      ? (accountBalance || 0) + (openPnL || 0)
+      : null;
 
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountId,  // Never expose real name - only account ID
       name: acc.accountId,         // Never expose real name - only account ID
+      // Core metrics (same as R Trader)
       balance: accountBalance,
       profitAndLoss: totalPnL,  // Same as R Trader: open + closed
       openPnL: openPnL,
       closedPnL: closedPnL,
-      dayPnL: dayPnL,  // Keep for reference
+      dayPnL: dayPnL,
+      // R Trader additional metrics
+      buyingPower: buyingPower,
+      margin: margin,
+      cashOnHand: cashOnHand,
+      netLiquidation: netLiquidation,
+      // Meta
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,

package/src/services/rithmic/handlers.js

@@ -332,17 +332,23 @@ const handleAccountPnLUpdate = (service, data) => {
     debug('Decoded Account PNL:', JSON.stringify(pnl));
     
     if (pnl.accountId) {
+      // Store ALL R Trader metrics from ACCOUNT_PNL_UPDATE (451)
       const pnlData = {
+        // Core P&L
         accountBalance: parseFloat(pnl.accountBalance || 0),
-        cashOnHand: parseFloat(pnl.cashOnHand || 0),
-        marginBalance: parseFloat(pnl.marginBalance || 0),
         openPositionPnl: parseFloat(pnl.openPositionPnl || 0),
         closedPositionPnl: parseFloat(pnl.closedPositionPnl || 0),
         dayPnl: parseFloat(pnl.dayPnl || 0),
+        // R Trader additional metrics
+        availableBuyingPower: parseFloat(pnl.availableBuyingPower || 0),
+        marginBalance: parseFloat(pnl.marginBalance || 0),
+        cashOnHand: parseFloat(pnl.cashOnHand || 0),
+        // Net Liquidation = Account Balance + Open P&L (same as R Trader)
+        netLiquidation: parseFloat(pnl.accountBalance || 0) + parseFloat(pnl.openPositionPnl || 0),
       };
       debug('Storing PNL for account:', pnl.accountId, pnlData);
       service.accountPnL.set(pnl.accountId, pnlData);
-      service.emit('pnlUpdate', pnl);
+      service.emit('pnlUpdate', { accountId: pnl.accountId, ...pnlData });
     } else {
       debug('No accountId in PNL response');
     }
@@ -353,6 +359,8 @@ const handleAccountPnLUpdate = (service, data) => {
 
 /**
  * Handle instrument PnL update (positions)
+ * INSTRUMENT_PNL_UPDATE (450) - Real-time position and P&L per instrument
+ * This is the PRIMARY source for unrealized P&L (same as R Trader Positions panel)
  */
 const handleInstrumentPnLUpdate = (service, data) => {
   try {
@@ -361,26 +369,33 @@ const handleInstrumentPnLUpdate = (service, data) => {
       const key = `${pos.accountId}:${pos.symbol}:${pos.exchange}`;
       const netQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
       
+      // Build position data - ALWAYS emit, even when FLAT (netQty === 0)
+      // This ensures Open P&L resets to 0 when position closes (like R Trader)
+      const positionData = {
+        accountId: pos.accountId,
+        symbol: pos.symbol,
+        exchange: pos.exchange || 'CME',
+        quantity: netQty,
+        averagePrice: netQty !== 0 ? (pos.avgOpenFillPrice || 0) : 0,
+        // Open P&L from API - this is the real-time unrealized P&L (same as R Trader)
+        openPnl: parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0),
+        closedPnl: parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0),
+        dayPnl: parseFloat(pos.dayPnl || 0),
+        isSnapshot: pos.isSnapshot || false,
+      };
+      
       if (netQty !== 0) {
-        service.positions.set(key, {
-          accountId: pos.accountId,
-          symbol: pos.symbol,
-          exchange: pos.exchange || 'CME',
-          quantity: netQty,
-          averagePrice: pos.avgOpenFillPrice || 0,
-          openPnl: parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0),
-          closedPnl: parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0),
-          dayPnl: parseFloat(pos.dayPnl || 0),
-          isSnapshot: pos.isSnapshot || false,
-        });
+        service.positions.set(key, positionData);
       } else {
         service.positions.delete(key);
       }
       
-      service.emit('positionUpdate', service.positions.get(key));
+      // ALWAYS emit positionUpdate - even when FLAT
+      // This ensures UI updates Open P&L to 0 when position closes
+      service.emit('positionUpdate', positionData);
     }
   } catch (e) {
-    // Ignore decode errors
+    debug('Error decoding Instrument PNL:', e.message);
   }
 };