hedgequantx 2.7.1 → 2.7.3

package/package.json

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

package/src/menus/dashboard.js

@@ -51,18 +51,14 @@ const dashboardMenu = async (service) => {
     const balStr = statsInfo.balance !== null ? `$${statsInfo.balance.toLocaleString()}` : '--';
     const balColor = statsInfo.balance !== null ? chalk.green : chalk.gray;
     
-    let pnlDisplay, pnlColor;
-    if (statsInfo.pnl !== null) {
-      pnlColor = statsInfo.pnl >= 0 ? chalk.green : chalk.red;
-      pnlDisplay = `${statsInfo.pnl >= 0 ? '+' : ''}$${Math.abs(statsInfo.pnl).toLocaleString()}`;
-    } else {
-      pnlColor = chalk.gray;
-      pnlDisplay = '--';
-    }
+    // AI Agents status
+    const agentCount = statsInfo.agents || 0;
+    const agentDisplay = agentCount > 0 ? `${agentCount} connected` : 'disconnected';
+    const agentColor = agentCount > 0 ? chalk.green : chalk.red;
     
     // Yellow icons: ✔ for each stat
     const icon = chalk.yellow('✔ ');
-    const statsPlain = `✔ Connections: ${statsInfo.connections}    ✔ Accounts: ${statsInfo.accounts}    ✔ Balance: ${balStr}    ✔ P&L: ${pnlDisplay}`;
+    const statsPlain = `✔ Connections: ${statsInfo.connections}    ✔ Accounts: ${statsInfo.accounts}    ✔ Balance: ${balStr}    ✔ AI Agents: ${agentDisplay}`;
     const statsLeftPad = Math.floor((W - statsPlain.length) / 2);
     const statsRightPad = W - statsPlain.length - statsLeftPad;
     
@@ -70,19 +66,30 @@ const dashboardMenu = async (service) => {
       icon + chalk.white(`Connections: ${statsInfo.connections}`) + '    ' +
       icon + chalk.white(`Accounts: ${statsInfo.accounts}`) + '    ' +
       icon + chalk.white('Balance: ') + balColor(balStr) + '    ' +
-      icon + chalk.white('P&L: ') + pnlColor(pnlDisplay) +
+      icon + chalk.white('AI Agents: ') + agentColor(agentDisplay) +
       ' '.repeat(Math.max(0, statsRightPad)) + chalk.cyan('║'));
   }
   
   console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
   
-  // Menu in 2 columns
+  // Menu in 2 columns - centered
   const col1Width = Math.floor(W / 2);
+  const col2Width = W - col1Width;
+  
   const menuRow = (left, right) => {
     const leftPlain = left.replace(/\x1b\[[0-9;]*m/g, '');
     const rightPlain = right.replace(/\x1b\[[0-9;]*m/g, '');
-    const leftPadded = '  ' + left + ' '.repeat(Math.max(0, col1Width - leftPlain.length - 2));
-    const rightPadded = right + ' '.repeat(Math.max(0, W - col1Width - rightPlain.length));
+    
+    // Center left item in col1
+    const leftPadL = Math.floor((col1Width - leftPlain.length) / 2);
+    const leftPadR = col1Width - leftPlain.length - leftPadL;
+    const leftPadded = ' '.repeat(leftPadL) + left + ' '.repeat(leftPadR);
+    
+    // Center right item in col2
+    const rightPadL = Math.floor((col2Width - rightPlain.length) / 2);
+    const rightPadR = col2Width - rightPlain.length - rightPadL;
+    const rightPadded = ' '.repeat(rightPadL) + right + ' '.repeat(rightPadR);
+    
     console.log(chalk.cyan('║') + leftPadded + rightPadded + chalk.cyan('║'));
   };
   

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

@@ -73,6 +73,9 @@ class RithmicService extends EventEmitter {
     // Cache
     this._contractsCache = null;
     this._contractsCacheTime = 0;
+    
+    // Trades history (captured from ExchangeOrderNotification fills)
+    this.trades = [];
   }
 
   // ==================== AUTH ====================
@@ -232,12 +235,121 @@ class RithmicService extends EventEmitter {
   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 captured fills
+   * @param {string} accountId - Optional account filter
+   * @param {number} days - Number of days to look back (default 30)
+   */
+  async getTradeHistory(accountId, days = 30) {
+    const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
+    let trades = this.trades.filter(t => t.timestamp >= cutoff);
+    
+    if (accountId) {
+      trades = trades.filter(t => t.accountId === accountId);
+    }
+    
+    // Sort by timestamp descending (newest first)
+    trades.sort((a, b) => b.timestamp - a.timestamp);
+    
+    return { success: true, trades };
+  }
+  
+  /**
+   * 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();