hedgequantx 2.7.2 → 2.7.4

package/package.json

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

package/src/pages/stats/display.js

@@ -214,8 +214,7 @@ const renderHQXScore = (data) => {
  * Render data source notice
  */
 const renderNotice = () => {
-  console.log();
-  console.log(chalk.gray('  Note: Rithmic API provides balance/P&L only. Trade history not available.'));
+  // No notice needed - all data comes from Rithmic API
 };
 
 module.exports = {

package/src/pages/stats/index.js

@@ -11,6 +11,7 @@ const ora = require('ora');
 
 const { connections } = require('../../services');
 const { prompts } = require('../../utils');
+const { displayBanner } = require('../../ui');
 const { aggregateStats, calculateDerivedMetrics, calculateQuantMetrics, calculateHQXScore } = require('./metrics');
 const { renderOverview, renderPnLMetrics, renderQuantMetrics, renderTradesHistory, renderHQXScore, renderNotice } = require('./display');
 const { renderEquityCurve } = require('./chart');
@@ -196,6 +197,8 @@ const showStats = async (service) => {
     const accountData = await aggregateAccountData(activeAccounts);
     
     spinner.succeed('Stats loaded');
+    console.clear();
+    displayBanner();
     console.log();
     
     // Calculate stats from API data

package/src/services/rithmic/handlers.js

@@ -36,10 +36,10 @@ const createOrderHandler = (service) => {
         handleShowOrdersResponse(service, data);
         break;
       case STREAM.EXCHANGE_NOTIFICATION:
-        service.emit('exchangeNotification', data);
+        handleExchangeNotification(service, data);
         break;
       case STREAM.ORDER_NOTIFICATION:
-        service.emit('orderNotification', data);
+        handleOrderNotification(service, data);
         break;
     }
   };
@@ -211,6 +211,93 @@ const handleInstrumentPnLUpdate = (service, data) => {
   }
 };
 
+/**
+ * Handle exchange order notification (fills/trades)
+ * NotifyType: 5 = FILL
+ */
+const handleExchangeNotification = (service, data) => {
+  try {
+    const res = proto.decode('ExchangeOrderNotification', data);
+    debug('Exchange notification:', res.notifyType, res.symbol);
+    
+    // notifyType 5 = FILL (trade executed)
+    if (res.notifyType === 5 && res.fillPrice && res.fillSize) {
+      const trade = {
+        id: res.fillId || `${Date.now()}-${res.basketId}`,
+        accountId: res.accountId,
+        symbol: res.symbol,
+        exchange: res.exchange || 'CME',
+        side: res.transactionType, // 1=BUY, 2=SELL
+        price: parseFloat(res.fillPrice),
+        size: parseInt(res.fillSize),
+        fillTime: res.fillTime,
+        fillDate: res.fillDate,
+        basketId: res.basketId,
+        avgFillPrice: parseFloat(res.avgFillPrice || res.fillPrice),
+        totalFillSize: parseInt(res.totalFillSize || res.fillSize),
+        timestamp: Date.now(),
+        ssboe: res.ssboe,
+        usecs: res.usecs,
+      };
+      
+      debug('Trade (fill) captured:', trade.symbol, trade.side === 1 ? 'BUY' : 'SELL', trade.size, '@', trade.price);
+      
+      // Store in trades history
+      if (!service.trades) service.trades = [];
+      service.trades.push(trade);
+      
+      // Keep max 1000 trades in memory
+      if (service.trades.length > 1000) {
+        service.trades = service.trades.slice(-1000);
+      }
+      
+      service.emit('trade', trade);
+    }
+    
+    service.emit('exchangeNotification', res);
+  } catch (e) {
+    debug('Error decoding ExchangeOrderNotification:', e.message);
+  }
+};
+
+/**
+ * Handle Rithmic order notification
+ */
+const handleOrderNotification = (service, data) => {
+  try {
+    const res = proto.decode('RithmicOrderNotification', data);
+    debug('Order notification:', res.notifyType, res.symbol, res.status);
+    
+    // Track order status changes
+    if (res.basketId) {
+      const order = {
+        basketId: res.basketId,
+        accountId: res.accountId,
+        symbol: res.symbol,
+        exchange: res.exchange || 'CME',
+        side: res.transactionType,
+        quantity: res.quantity,
+        price: res.price,
+        status: res.status,
+        notifyType: res.notifyType,
+        avgFillPrice: res.avgFillPrice,
+        totalFillSize: res.totalFillSize,
+        totalUnfilledSize: res.totalUnfilledSize,
+        timestamp: Date.now(),
+      };
+      
+      service.emit('orderNotification', order);
+      
+      // If order is complete (notifyType 15), calculate P&L
+      if (res.notifyType === 15 && res.avgFillPrice) {
+        debug('Order complete:', res.basketId, 'avg fill:', res.avgFillPrice);
+      }
+    }
+  } catch (e) {
+    debug('Error decoding RithmicOrderNotification:', e.message);
+  }
+};
+
 module.exports = {
   createOrderHandler,
   createPnLHandler

package/src/services/rithmic/index.js

@@ -16,7 +16,7 @@ const {
   subscribePnLUpdates,
   getPositions,
 } = require('./accounts');
-const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
+const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
 const { getContracts, searchContracts } = require('./contracts');
 const { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
@@ -73,6 +73,9 @@ class RithmicService extends EventEmitter {
     // Cache
     this._contractsCache = null;
     this._contractsCacheTime = 0;
+    
+    // Trades history (captured from ExchangeOrderNotification fills)
+    this.trades = [];
   }
 
   // ==================== AUTH ====================
@@ -226,18 +229,160 @@ class RithmicService extends EventEmitter {
   async getPositions() { return getPositions(this); }
   async getOrders() { return getOrders(this); }
   async getOrderHistory(date) { return getOrderHistory(this, date); }
+  async getOrderHistoryDates() { return getOrderHistoryDates(this); }
+  async getTradeHistoryFull(days) { return getTradeHistoryFull(this, days); }
   async placeOrder(orderData) { return placeOrder(this, orderData); }
   async cancelOrder(orderId) { return cancelOrder(this, orderId); }
   async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
   async getContracts() { return getContracts(this); }
   async searchContracts(searchText) { return searchContracts(this, searchText); }
 
-  // ==================== STUBS ====================
+  // ==================== STATS & HISTORY ====================
 
   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 Rithmic API
+   * @param {string} accountId - Optional account filter
+   * @param {number} days - Number of days to look back (default 30)
+   */
+  async getTradeHistory(accountId, days = 30) {
+    // Fetch from API
+    const result = await getTradeHistoryFull(this, days);
+    
+    if (!result.success) {
+      return { success: false, trades: [] };
+    }
+    
+    let trades = result.trades || [];
+    
+    // Filter by account if specified
+    if (accountId) {
+      trades = trades.filter(t => t.accountId === accountId);
+    }
+    
+    // Add timestamp from fillDate/fillTime if not present
+    trades = trades.map(t => ({
+      ...t,
+      timestamp: t.timestamp || this._parseDateTime(t.fillDate, t.fillTime),
+    }));
+    
+    // Sort by timestamp descending (newest first)
+    trades.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+    
+    return { success: true, trades };
+  }
+  
+  /**
+   * Parse Rithmic date/time to timestamp
+   * @private
+   */
+  _parseDateTime(dateStr, timeStr) {
+    if (!dateStr) return Date.now();
+    try {
+      // dateStr format: YYYYMMDD, timeStr format: HH:MM:SS
+      const year = dateStr.slice(0, 4);
+      const month = dateStr.slice(4, 6);
+      const day = dateStr.slice(6, 8);
+      const time = timeStr || '00:00:00';
+      return new Date(`${year}-${month}-${day}T${time}Z`).getTime();
+    } catch (e) {
+      return Date.now();
+    }
+  }
+  
+  /**
+   * Get lifetime stats calculated from trade history
+   */
+  async getLifetimeStats(accountId) {
+    const { trades } = await this.getTradeHistory(accountId, 365);
+    
+    if (trades.length === 0) {
+      return { success: true, stats: null };
+    }
+    
+    // Calculate stats from trades
+    let totalTrades = trades.length;
+    let winningTrades = 0;
+    let losingTrades = 0;
+    let totalProfit = 0;
+    let totalLoss = 0;
+    let longTrades = 0;
+    let shortTrades = 0;
+    let totalVolume = 0;
+    
+    // Group fills by basketId to calculate P&L per trade
+    const tradeGroups = new Map();
+    for (const trade of trades) {
+      const key = trade.basketId || trade.id;
+      if (!tradeGroups.has(key)) {
+        tradeGroups.set(key, []);
+      }
+      tradeGroups.get(key).push(trade);
+    }
+    
+    for (const [, fills] of tradeGroups) {
+      const firstFill = fills[0];
+      totalVolume += fills.reduce((sum, f) => sum + f.size, 0);
+      
+      if (firstFill.side === 1) longTrades++;
+      else if (firstFill.side === 2) shortTrades++;
+      
+      // P&L calculation requires entry/exit matching which needs position tracking
+      // For now, count trades
+      totalTrades = tradeGroups.size;
+    }
+    
+    const stats = {
+      totalTrades,
+      winningTrades,
+      losingTrades,
+      winRate: totalTrades > 0 ? ((winningTrades / totalTrades) * 100).toFixed(2) : 0,
+      totalProfit,
+      totalLoss,
+      netPnL: totalProfit - totalLoss,
+      longTrades,
+      shortTrades,
+      totalVolume,
+    };
+    
+    return { success: true, stats };
+  }
+  
+  /**
+   * Get daily stats from trade history
+   */
+  async getDailyStats(accountId, days = 30) {
+    const { trades } = await this.getTradeHistory(accountId, days);
+    
+    // Group by date
+    const dailyStats = new Map();
+    
+    for (const trade of trades) {
+      const date = new Date(trade.timestamp).toISOString().slice(0, 10);
+      
+      if (!dailyStats.has(date)) {
+        dailyStats.set(date, {
+          date,
+          trades: 0,
+          volume: 0,
+          buys: 0,
+          sells: 0,
+        });
+      }
+      
+      const day = dailyStats.get(date);
+      day.trades++;
+      day.volume += trade.size;
+      if (trade.side === 1) day.buys++;
+      else if (trade.side === 2) day.sells++;
+    }
+    
+    // Convert to array and sort by date
+    const stats = Array.from(dailyStats.values()).sort((a, b) => b.date.localeCompare(a.date));
+    
+    return { success: true, stats };
+  }
 
   async getMarketStatus() {
     const status = this.checkMarketHours();

package/src/services/rithmic/orders.js

@@ -119,9 +119,57 @@ const getOrders = async (service) => {
 };
 
 /**
- * Get order history
+ * Get available order history dates
+ * @param {RithmicService} service - The Rithmic service instance
+ * @returns {Promise<{success: boolean, dates: string[]}>}
+ */
+const getOrderHistoryDates = async (service) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, dates: [] };
+  }
+
+  return new Promise((resolve) => {
+    const dates = [];
+    const timeout = setTimeout(() => {
+      resolve({ success: true, dates });
+    }, 5000);
+
+    const handler = (msg) => {
+      if (msg.templateId === 319 && msg.date) {
+        // ResponseShowOrderHistoryDates returns dates array
+        if (Array.isArray(msg.date)) {
+          dates.push(...msg.date);
+        } else {
+          dates.push(msg.date);
+        }
+      }
+      if (msg.templateId === 319 && msg.rpCode && msg.rpCode[0] === '0') {
+        clearTimeout(timeout);
+        service.orderConn.removeListener('message', handler);
+        resolve({ success: true, dates });
+      }
+    };
+
+    service.orderConn.on('message', handler);
+
+    try {
+      service.orderConn.send('RequestShowOrderHistoryDates', {
+        templateId: REQ.SHOW_ORDER_HISTORY_DATES,
+        userMsg: ['HQX'],
+      });
+    } catch (e) {
+      clearTimeout(timeout);
+      service.orderConn.removeListener('message', handler);
+      resolve({ success: false, error: e.message, dates: [] });
+    }
+  });
+};
+
+/**
+ * Get order history for a specific date
  * @param {RithmicService} service - The Rithmic service instance
  * @param {string} date - Date in YYYYMMDD format
+ * @returns {Promise<{success: boolean, orders: Array}>}
  */
 const getOrderHistory = async (service, date) => {
   if (!service.orderConn || !service.loginInfo) {
@@ -133,12 +181,46 @@ const getOrderHistory = async (service, date) => {
   return new Promise((resolve) => {
     const orders = [];
     const timeout = setTimeout(() => {
+      service.orderConn.removeListener('message', handler);
       resolve({ success: true, orders });
-    }, 3000);
+    }, 10000);
+
+    const handler = (msg) => {
+      // ExchangeOrderNotification (352) contains order/fill details
+      if (msg.templateId === 352 && msg.data) {
+        try {
+          const notification = service.orderConn.proto.decode('ExchangeOrderNotification', msg.data);
+          if (notification && notification.symbol) {
+            orders.push({
+              id: notification.fillId || notification.basketId || `${Date.now()}`,
+              accountId: notification.accountId,
+              symbol: notification.symbol,
+              exchange: notification.exchange || 'CME',
+              side: notification.transactionType, // 1=BUY, 2=SELL
+              quantity: notification.quantity,
+              price: notification.price,
+              fillPrice: notification.fillPrice,
+              fillSize: notification.fillSize,
+              fillTime: notification.fillTime,
+              fillDate: notification.fillDate,
+              avgFillPrice: notification.avgFillPrice,
+              totalFillSize: notification.totalFillSize,
+              status: notification.status,
+              notifyType: notification.notifyType,
+              isSnapshot: notification.isSnapshot,
+            });
+          }
+        } catch (e) {
+          // Ignore decode errors
+        }
+      }
+    };
+
+    service.orderConn.on('message', handler);
 
     try {
       for (const acc of service.accounts) {
-        service.orderConn.send('RequestShowOrderHistorySummary', {
+        service.orderConn.send('RequestShowOrderHistory', {
           templateId: REQ.SHOW_ORDER_HISTORY,
           userMsg: ['HQX'],
           fcmId: acc.fcmId || service.loginInfo.fcmId,
@@ -148,17 +230,53 @@ const getOrderHistory = async (service, date) => {
         });
       }
       
+      // Wait for responses
       setTimeout(() => {
         clearTimeout(timeout);
+        service.orderConn.removeListener('message', handler);
         resolve({ success: true, orders });
-      }, 2000);
+      }, 5000);
     } catch (e) {
       clearTimeout(timeout);
+      service.orderConn.removeListener('message', handler);
       resolve({ success: false, error: e.message, orders: [] });
     }
   });
 };
 
+/**
+ * Get full trade history for multiple dates
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {number} days - Number of days to fetch (default 30)
+ * @returns {Promise<{success: boolean, trades: Array}>}
+ */
+const getTradeHistoryFull = async (service, days = 30) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, trades: [] };
+  }
+
+  // Get available dates
+  const { dates } = await getOrderHistoryDates(service);
+  if (!dates || dates.length === 0) {
+    return { success: true, trades: [] };
+  }
+
+  // Sort dates descending and limit to requested days
+  const sortedDates = dates.sort((a, b) => b.localeCompare(a)).slice(0, days);
+  
+  const allTrades = [];
+  
+  // Fetch history for each date
+  for (const date of sortedDates) {
+    const { orders } = await getOrderHistory(service, date);
+    // Filter only fills (notifyType 5)
+    const fills = orders.filter(o => o.notifyType === 5 || o.fillPrice);
+    allTrades.push(...fills);
+  }
+
+  return { success: true, trades: allTrades };
+};
+
 /**
  * Close position (market order to flatten)
  * @param {RithmicService} service - The Rithmic service instance
@@ -188,5 +306,7 @@ module.exports = {
   cancelOrder,
   getOrders,
   getOrderHistory,
+  getOrderHistoryDates,
+  getTradeHistoryFull,
   closePosition
 };