hedgequantx 2.6.17 → 2.6.18

package/package.json

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

package/src/pages/stats.js

@@ -170,8 +170,9 @@ const showStats = async (service) => {
           } catch (e) {}
         }
         
-        // ===== TRADE HISTORY (from API - ProjectX only) =====
-        // Rithmic doesn't have getTradeHistory - returns empty array
+        // ===== TRADE HISTORY (from API) =====
+        // ProjectX: Historical trades from API
+        // Rithmic: Session trades tracked locally (entry/exit matching)
         if (typeof svc.getTradeHistory === 'function') {
           try {
             const tradesResult = await svc.getTradeHistory(account.accountId, 30);

package/src/services/rithmic/index.js

@@ -71,6 +71,7 @@ class RithmicService extends EventEmitter {
     this.accountPnL = new Map();
     this.positions = new Map();
     this.orders = [];
+    this.completedTrades = []; // Store filled orders for trade history
     this.user = null;
     this.credentials = null;
     
@@ -121,6 +122,80 @@ class RithmicService extends EventEmitter {
             log.warn('Failed to fetch accounts', { error: err.message });
           }
           
+          // Track open entries for P&L calculation
+          this._openEntries = new Map(); // key: accountId:symbol, value: {side, qty, price}
+          
+          // Listen for filled orders to build trade history
+          this.on('orderFilled', (fillInfo) => {
+            const key = `${fillInfo.accountId}:${fillInfo.symbol}`;
+            const side = fillInfo.transactionType === 1 ? 0 : 1; // 0=BUY, 1=SELL (entry side)
+            const qty = fillInfo.fillQuantity || fillInfo.totalFillQuantity || 0;
+            const price = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
+            
+            // Check if this is closing an existing position
+            const openEntry = this._openEntries.get(key);
+            let pnl = null;
+            let isClosingTrade = false;
+            
+            if (openEntry && openEntry.side !== side) {
+              // This is a closing trade (opposite side of open position)
+              isClosingTrade = true;
+              const closeQty = Math.min(qty, openEntry.qty);
+              
+              // Calculate P&L based on direction
+              // If we bought (side=0), we sell to close - profit if close price > entry price
+              // If we sold (side=1), we buy to close - profit if entry price > close price
+              if (openEntry.side === 0) {
+                // Was long, selling to close
+                pnl = (price - openEntry.price) * closeQty;
+              } else {
+                // Was short, buying to close
+                pnl = (openEntry.price - price) * closeQty;
+              }
+              
+              // Update or remove open entry
+              const remainingQty = openEntry.qty - closeQty;
+              if (remainingQty <= 0) {
+                this._openEntries.delete(key);
+              } else {
+                openEntry.qty = remainingQty;
+              }
+              
+              // Store the closing trade with P&L
+              this.completedTrades.push({
+                id: fillInfo.orderId || fillInfo.orderTag,
+                orderTag: fillInfo.orderTag,
+                accountId: fillInfo.accountId,
+                symbol: fillInfo.symbol,
+                exchange: fillInfo.exchange,
+                side: openEntry.side, // Original entry side (for stats: LONG or SHORT)
+                size: closeQty,
+                entryPrice: openEntry.price,
+                exitPrice: price,
+                price: price,
+                timestamp: fillInfo.localTimestamp || Date.now(),
+                creationTimestamp: new Date().toISOString(),
+                status: 'CLOSED',
+                profitAndLoss: pnl,
+                pnl: pnl,
+                fees: 0,
+              });
+              log.debug('Trade closed', { symbol: fillInfo.symbol, pnl, trades: this.completedTrades.length });
+            } else {
+              // This is opening a new position or adding to existing
+              if (openEntry && openEntry.side === side) {
+                // Adding to position - update average price
+                const totalQty = openEntry.qty + qty;
+                openEntry.price = ((openEntry.price * openEntry.qty) + (price * qty)) / totalQty;
+                openEntry.qty = totalQty;
+              } else {
+                // New position
+                this._openEntries.set(key, { side, qty, price, timestamp: Date.now() });
+              }
+              log.debug('Position opened/added', { symbol: fillInfo.symbol, side, qty, price });
+            }
+          });
+          
           // Store credentials for reconnection
           this.credentials = { username, password };
           
@@ -332,7 +407,27 @@ class RithmicService extends EventEmitter {
   async getUser() { return this.user; }
   async getLifetimeStats() { return { success: true, stats: null }; }
   async getDailyStats() { return { success: true, stats: [] }; }
-  async getTradeHistory() { return { success: true, trades: [] }; }
+  
+  /**
+   * Get trade history from completed fills
+   * Note: Rithmic doesn't provide historical P&L per trade via API
+   * We track fills in real-time during the session
+   * @param {string} accountId - Optional account filter
+   * @param {number} days - Not used for Rithmic (session-only data)
+   * @returns {Promise<{success: boolean, trades: Array}>}
+   */
+  async getTradeHistory(accountId, days) {
+    // Filter by account if specified
+    let trades = this.completedTrades;
+    if (accountId) {
+      trades = trades.filter(t => t.accountId === accountId);
+    }
+    
+    // Sort by timestamp descending (newest first)
+    trades = [...trades].sort((a, b) => b.timestamp - a.timestamp);
+    
+    return { success: true, trades };
+  }
 
   async getMarketStatus() {
     const status = this.checkMarketHours();
@@ -615,6 +710,8 @@ class RithmicService extends EventEmitter {
     this.accountPnL.clear();
     this.positions.clear();
     this.orders = [];
+    this.completedTrades = [];
+    this._openEntries = null;
     this.loginInfo = null;
     this.user = null;
     this.credentials = null;