hedgequantx 2.4.31 → 2.4.33

package/package.json

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

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

@@ -206,6 +206,8 @@ const launchAlgo = async (service, account, contract, config) => {
   let currentPosition = 0; // Current position qty (+ long, - short)
   let pendingOrder = false; // Prevent duplicate orders
   let tickCount = 0;
+  let lastTradeCount = 0; // Track number of trades from API
+  let lastPositionQty = 0; // Track position changes
   
   // Initialize Strategy (M1 is singleton instance)
   const strategy = M1;
@@ -301,16 +303,23 @@ const launchAlgo = async (service, account, contract, config) => {
     tps++;
     const latencyStart = Date.now();
     
+    // Debug: log first tick to see structure
+    if (tickCount === 1) {
+      algoLogger.info(ui, 'FIRST TICK', `price=${tick.price} bid=${tick.bid} ask=${tick.ask} vol=${tick.volume}`);
+    }
+    
     // Feed tick to strategy
-    strategy.processTick({
+    const tickData = {
       contractId: tick.contractId || contractId,
-      price: tick.price,
+      price: tick.price || tick.lastPrice || tick.bid,
       bid: tick.bid,
       ask: tick.ask,
-      volume: tick.volume || 1,
-      side: tick.lastTradeSide || 'unknown',
+      volume: tick.volume || tick.size || 1,
+      side: tick.lastTradeSide || tick.side || 'unknown',
       timestamp: tick.timestamp || Date.now()
-    });
+    };
+    
+    strategy.processTick(tickData);
     
     stats.latency = Date.now() - latencyStart;
     
@@ -368,24 +377,20 @@ const launchAlgo = async (service, account, contract, config) => {
     algoLogger.error(ui, 'CONNECTION ERROR', e.message.substring(0, 50));
   }
   
-  // Poll account P&L from API
+  // Poll account P&L and sync with real trades from API
   const pollPnL = async () => {
     try {
+      // Get account P&L
       const accountResult = await service.getTradingAccounts();
       if (accountResult.success && accountResult.accounts) {
         const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
         if (acc && acc.profitAndLoss !== undefined) {
           if (startingPnL === null) startingPnL = acc.profitAndLoss;
           stats.pnl = acc.profitAndLoss - startingPnL;
-          
-          // Record trade result in strategy
-          if (stats.pnl !== 0) {
-            strategy.recordTradeResult(stats.pnl);
-          }
         }
       }
       
-      // Check positions
+      // Check positions - detect when position closes
       const posResult = await service.getPositions(account.accountId);
       if (posResult.success && posResult.positions) {
         const pos = posResult.positions.find(p => {
@@ -393,24 +398,67 @@ const launchAlgo = async (service, account, contract, config) => {
           return sym.includes(contract.name) || sym.includes(contractId);
         });
         
-        if (pos && pos.quantity !== 0) {
-          currentPosition = pos.quantity;
-          const side = pos.quantity > 0 ? 'LONG' : 'SHORT';
-          const pnl = pos.profitAndLoss || 0;
+        const newPositionQty = pos?.quantity || 0;
+        
+        // Position just closed - cancel remaining orders and log result
+        if (lastPositionQty !== 0 && newPositionQty === 0) {
+          // Cancel all open orders to prevent new positions
+          try {
+            await service.cancelAllOrders(account.accountId);
+            algoLogger.info(ui, 'ORDERS CANCELLED', 'Position closed - brackets removed');
+          } catch (e) {
+            // Silent fail
+          }
           
-          // Check if position closed (win/loss)
-          if (pnl > 0) stats.wins = Math.max(stats.wins, 1);
-          else if (pnl < 0) stats.losses = Math.max(stats.losses, 1);
-        } else {
-          currentPosition = 0;
+          // Get real trade data from API
+          try {
+            const tradesResult = await service.getTrades(account.accountId);
+            if (tradesResult.success && tradesResult.trades?.length > 0) {
+              // Count completed trades (those with profitAndLoss not null)
+              const completedTrades = tradesResult.trades.filter(t => t.profitAndLoss !== null);
+              
+              // Update stats from real trades
+              let wins = 0, losses = 0;
+              for (const trade of completedTrades) {
+                if (trade.profitAndLoss > 0) wins++;
+                else if (trade.profitAndLoss < 0) losses++;
+              }
+              stats.trades = completedTrades.length;
+              stats.wins = wins;
+              stats.losses = losses;
+              
+              // Log the trade that just closed
+              const lastTrade = completedTrades[completedTrades.length - 1];
+              if (lastTrade) {
+                const pnl = lastTrade.profitAndLoss || 0;
+                const side = lastTrade.side === 0 ? 'LONG' : 'SHORT';
+                const exitPrice = lastTrade.price || 0;
+                
+                if (pnl >= 0) {
+                  algoLogger.targetHit(ui, symbolName, exitPrice, pnl);
+                } else {
+                  algoLogger.stopHit(ui, symbolName, exitPrice, Math.abs(pnl));
+                }
+                algoLogger.positionClosed(ui, symbolName, side, contracts, exitPrice, pnl);
+                
+                // Record in strategy for adaptation
+                strategy.recordTradeResult(pnl);
+              }
+            }
+          } catch (e) {
+            // Silent fail - trades API might not be available
+          }
         }
+        
+        lastPositionQty = newPositionQty;
+        currentPosition = newPositionQty;
       }
       
       // Check target/risk
       if (stats.pnl >= dailyTarget) {
         stopReason = 'target';
         running = false;
-        algoLogger.targetHit(ui, symbolName, 0, stats.pnl);
+        algoLogger.info(ui, 'DAILY TARGET REACHED', `+$${stats.pnl.toFixed(2)}`);
       } else if (stats.pnl <= -maxRisk) {
         stopReason = 'risk';
         running = false;

package/src/pages/stats.js

@@ -186,8 +186,8 @@ const showStats = async (service) => {
       } catch (e) {}
     }
 
-    // ========== AGGREGATE STATS FROM API DATA ==========
-    // Stats come from API (lifetimeStats) or calculated from API trade data
+    // ========== AGGREGATE STATS FROM TRADE HISTORY (API DATA) ==========
+    // Calculate stats from actual trades to ensure consistency with displayed trades
     
     let stats = {
       totalTrades: 0, winningTrades: 0, losingTrades: 0,
@@ -197,27 +197,8 @@ const showStats = async (service) => {
       longTrades: 0, shortTrades: 0, longWins: 0, shortWins: 0
     };
     
-    // First: aggregate lifetimeStats from APIs (ProjectX)
-    for (const account of activeAccounts) {
-      if (account.lifetimeStats) {
-        const s = account.lifetimeStats;
-        stats.totalTrades += s.totalTrades || 0;
-        stats.winningTrades += s.winningTrades || 0;
-        stats.losingTrades += s.losingTrades || 0;
-        stats.totalWinAmount += s.totalWinAmount || 0;
-        stats.totalLossAmount += s.totalLossAmount || 0;
-        stats.bestTrade = Math.max(stats.bestTrade, s.bestTrade || 0);
-        stats.worstTrade = Math.min(stats.worstTrade, s.worstTrade || 0);
-        stats.totalVolume += s.totalVolume || 0;
-        stats.maxConsecutiveWins = Math.max(stats.maxConsecutiveWins, s.maxConsecutiveWins || 0);
-        stats.maxConsecutiveLosses = Math.max(stats.maxConsecutiveLosses, s.maxConsecutiveLosses || 0);
-        stats.longTrades += s.longTrades || 0;
-        stats.shortTrades += s.shortTrades || 0;
-      }
-    }
-    
-    // If no lifetimeStats, calculate from trade history (still 100% API data)
-    if (stats.totalTrades === 0 && allTrades.length > 0) {
+    // Calculate stats from trade history (100% API data, consistent with displayed trades)
+    if (allTrades.length > 0) {
       stats.totalTrades = allTrades.length;
       let consecutiveWins = 0, consecutiveLosses = 0;
       
@@ -464,11 +445,16 @@ const showStats = async (service) => {
       // Header
       const header = ` ${'Time'.padEnd(colTime)}| ${'Symbol'.padEnd(colSymbol)}| ${'Price'.padEnd(colPrice)}| ${'P&L'.padEnd(colPnl)}| ${'Side'.padEnd(colSide)}| ${'Account'.padEnd(colAccount - 2)}`;
       console.log(chalk.cyan('\u2551') + chalk.white(header) + chalk.cyan('\u2551'));
-      console.log(chalk.cyan('\u2551') + chalk.gray('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2551'));
+      console.log(chalk.cyan('\u255F') + chalk.cyan('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2562'));
       
-      const recentTrades = allTrades.slice(-10).reverse();
+      // Show ALL trades, sorted by time (most recent first)
+      const sortedTrades = [...allTrades].sort((a, b) => {
+        const timeA = new Date(a.creationTimestamp || a.timestamp || 0).getTime();
+        const timeB = new Date(b.creationTimestamp || b.timestamp || 0).getTime();
+        return timeB - timeA;
+      });
       
-      for (const trade of recentTrades) {
+      for (const trade of sortedTrades) {
         const timestamp = trade.creationTimestamp || trade.timestamp;
         const time = timestamp ? new Date(timestamp).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true }) : '--:--';
         const symbol = extractSymbol(trade.contractId || trade.symbol);
@@ -493,11 +479,6 @@ const showStats = async (service) => {
         const row = ` ${timeStr}| ${symbolStr}| ${priceStr}| ${pnlColored}| ${sideColored}| ${accountStr}`;
         console.log(chalk.cyan('\u2551') + row + chalk.cyan('\u2551'));
       }
-      
-      if (allTrades.length > 10) {
-        const moreMsg = `  ... and ${allTrades.length - 10} more trades`;
-        console.log(chalk.cyan('\u2551') + moreMsg.padEnd(innerWidth) + chalk.cyan('\u2551'));
-      }
     } else {
       const msg = connectionTypes.rithmic > 0 
         ? '  No trade history (Rithmic API limitation)'

package/src/services/projectx/index.js

@@ -384,6 +384,42 @@ class ProjectXService {
     }
   }
 
+  /**
+   * Get trades history for today
+   * @param {number|string} accountId - Account ID
+   * @returns {Promise<{success: boolean, trades: Array, error?: string}>}
+   */
+  async getTrades(accountId) {
+    try {
+      const id = validateAccountId(accountId);
+      
+      // Get today's trades (from midnight UTC)
+      const now = new Date();
+      const startOfDay = new Date(now);
+      startOfDay.setUTCHours(0, 0, 0, 0);
+      
+      const response = await this._request(
+        this.propfirm.gatewayApi,
+        '/api/Trade/search',
+        'POST',
+        { 
+          accountId: id,
+          startTimestamp: startOfDay.toISOString(),
+          endTimestamp: now.toISOString()
+        }
+      );
+      
+      if (response.statusCode === 200) {
+        const trades = response.data.trades || response.data || [];
+        return { success: true, trades: Array.isArray(trades) ? trades : [] };
+      }
+      
+      return { success: true, trades: [] };
+    } catch (err) {
+      return { success: true, trades: [], error: err.message };
+    }
+  }
+
   /**
    * Place an order
    * @param {Object} orderData - Order details