hedgequantx 2.6.44 → 2.6.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.44",
+  "version": "2.6.46",
   "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,17 +386,45 @@ const launchAlgo = async (service, account, contract, config) => {
     // Only update for our account
     if (pnlData.accountId !== rithmicAccountId) return;
     
-    // R Trader style P&L breakdown
-    const openPnl = parseFloat(pnlData.openPositionPnl || 0);
-    const closedPnl = parseFloat(pnlData.closedPositionPnl || 0);
+    // ═══════════════════════════════════════════════════════════════════════════
+    // ACCOUNT_PNL_UPDATE (451) - All R Trader account-level metrics
+    // ═══════════════════════════════════════════════════════════════════════════
     
-    // Update stats (like R Trader display)
-    stats.openPnl = openPnl;      // Unrealized
-    stats.closedPnl = closedPnl;  // Realized
-    stats.pnl = openPnl + closedPnl;  // Total (same as R Trader "Today's P&L")
+    // 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
+    stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
   });
   
   // Listen to position updates for real-time position tracking (like R Trader)
+  // INSTRUMENT_PNL_UPDATE (450) provides per-instrument P&L in real-time
   service.on('positionUpdate', (pos) => {
     if (!pos || pos.accountId !== rithmicAccountId) return;
     if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
@@ -398,6 +433,17 @@ const launchAlgo = async (service, account, contract, config) => {
     stats.position = pos.quantity || 0;
     stats.entryPrice = pos.averagePrice || 0;
     currentPosition = pos.quantity || 0;
+    
+    // CRITICAL: Update Open P&L from instrument-level data (real-time, same as R Trader)
+    // 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) {
+      // Total P&L = openPnl + closedPnl (same formula as R Trader)
+      stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+    }
   });
   
   // Initialize AI Strategy Supervisor - agents observe, learn & optimize

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');
     }