hedgequantx 2.4.30 → 2.4.31

package/package.json

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

package/src/pages/algo/copy-trading.js

@@ -11,6 +11,7 @@ const { connections } = require('../../services');
 const { AlgoUI, renderSessionSummary } = require('./ui');
 const { logger, prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
+const { algoLogger } = require('./logger');
 
 const log = logger.scope('CopyTrading');
 
@@ -299,10 +300,17 @@ const launchCopyTrading = async (config) => {
     }
   };
 
-  // Local copy trading - no external server needed
-  ui.addLog('info', `Starting copy trading on ${stats.platform}...`);
-  ui.addLog('info', `Lead: ${stats.leadName} -> Follower: ${stats.followerName}`);
-  ui.addLog('info', `Symbol: ${stats.symbol} | Target: $${dailyTarget} | Risk: $${maxRisk}`);
+  // Smart startup logs (same as HQX-TG)
+  const market = checkMarketHours();
+  const sessionName = market.session || 'AMERICAN';
+  const etTime = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', timeZone: 'America/New_York' });
+  
+  algoLogger.connectingToEngine(ui, lead.account.accountId);
+  algoLogger.engineStarting(ui, stats.platform, dailyTarget, maxRisk);
+  algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
+  algoLogger.info(ui, 'COPY MODE', `Lead: ${lead.propfirm} -> Follower: ${follower.propfirm}`);
+  algoLogger.dataConnected(ui, 'API');
+  algoLogger.algoOperational(ui, stats.platform);
   stats.connected = true;
   
   // Track lead positions and copy to follower
@@ -321,7 +329,12 @@ const launchCopyTrading = async (config) => {
         const existing = lastLeadPositions.find(p => p.contractId === pos.contractId);
         if (!existing && pos.quantity !== 0) {
           // New position opened - copy to follower
-          ui.addLog('trade', `Lead opened: ${pos.quantity > 0 ? 'LONG' : 'SHORT'} ${Math.abs(pos.quantity)}x ${pos.symbol || pos.contractId}`);
+          const side = pos.quantity > 0 ? 'LONG' : 'SHORT';
+          const symbol = pos.symbol || pos.contractId;
+          const size = Math.abs(pos.quantity);
+          const entry = pos.averagePrice || 0;
+          algoLogger.positionOpened(ui, symbol, side, size, entry);
+          algoLogger.info(ui, 'COPYING TO FOLLOWER', `${side} ${size}x ${symbol}`);
           // TODO: Place order on follower account
         }
       }
@@ -330,7 +343,13 @@ const launchCopyTrading = async (config) => {
       for (const oldPos of lastLeadPositions) {
         const stillOpen = currentPositions.find(p => p.contractId === oldPos.contractId);
         if (!stillOpen || stillOpen.quantity === 0) {
-          ui.addLog('info', `Lead closed: ${oldPos.symbol || oldPos.contractId}`);
+          const side = oldPos.quantity > 0 ? 'LONG' : 'SHORT';
+          const symbol = oldPos.symbol || oldPos.contractId;
+          const size = Math.abs(oldPos.quantity);
+          const exit = stillOpen?.averagePrice || oldPos.averagePrice || 0;
+          const pnl = oldPos.profitAndLoss || 0;
+          algoLogger.positionClosed(ui, symbol, side, size, exit, pnl);
+          algoLogger.info(ui, 'CLOSING ON FOLLOWER', symbol);
           // TODO: Close position on follower account
         }
       }
@@ -353,11 +372,13 @@ const launchCopyTrading = async (config) => {
       if (stats.pnl >= dailyTarget) {
         stopReason = 'target';
         running = false;
-        ui.addLog('success', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+        algoLogger.targetHit(ui, lead.symbol.name, 0, stats.pnl);
+        algoLogger.info(ui, 'DAILY TARGET REACHED', `+$${stats.pnl.toFixed(2)} - Stopping algo`);
       } else if (stats.pnl <= -maxRisk) {
         stopReason = 'risk';
         running = false;
-        ui.addLog('error', `MAX RISK HIT! -$${Math.abs(stats.pnl).toFixed(2)}`);
+        algoLogger.dailyLimitWarning(ui, stats.pnl, -maxRisk);
+        algoLogger.error(ui, 'MAX RISK HIT', `-$${Math.abs(stats.pnl).toFixed(2)} - Stopping algo`);
       }
     } catch (e) {
       // Silent fail - will retry

package/src/pages/algo/logger.js

@@ -0,0 +1,245 @@
+/**
+ * =============================================================================
+ * HQX Algo Trading System - Smart Algo Logger
+ * =============================================================================
+ * Provides rich, detailed logs for the algo UI
+ * Copied from HQX-TG algo-logger.ts - All 47 log types
+ */
+
+'use strict';
+
+/**
+ * Smart Algo Logger - All 47 log types from HQX-TG
+ */
+const algoLogger = {
+  // === MARKET DATA LOGS ===
+  quote(ui, symbol, bid, ask, spread) {
+    ui.addLog('info', `QUOTE ${symbol} - bid: ${bid.toFixed(2)} | ask: ${ask.toFixed(2)} | spread: ${spread.toFixed(2)}`);
+  },
+
+  tape(ui, symbol, buyVol, sellVol, delta) {
+    const sign = delta > 0 ? '+' : '';
+    ui.addLog('info', `TAPE ${symbol} - buy: ${buyVol} | sell: ${sellVol} | delta: ${sign}${delta}`);
+  },
+
+  dom(ui, symbol, bidDepth, askDepth, imbalance) {
+    const direction = imbalance > 0 ? '▲' : imbalance < 0 ? '▼' : '=';
+    ui.addLog('info', `DOM ${symbol} - bidDepth: ${bidDepth} | askDepth: ${askDepth} | imbalance: ${direction}${Math.abs(imbalance).toFixed(1)}%`);
+  },
+
+  volumeSpike(ui, symbol, volume, avgVolume, ratio) {
+    ui.addLog('analysis', `VOLUME SPIKE ${symbol} - vol: ${volume} | avg: ${avgVolume.toFixed(0)} | ratio: ${ratio.toFixed(1)}x`);
+  },
+
+  // === ANALYSIS LOGS ===
+  orderFlow(ui, symbol, score, direction) {
+    const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '=';
+    ui.addLog('analysis', `ORDER FLOW ${symbol} - score: ${score.toFixed(0)} | direction: ${arrow} ${direction}`);
+  },
+
+  absorption(ui, symbol, level, side, strength) {
+    ui.addLog('analysis', `ABSORPTION ${side} - price: ${level.toFixed(2)} | strength: ${strength.toFixed(0)}%`);
+  },
+
+  sweep(ui, symbol, side, levels, volume) {
+    ui.addLog('analysis', `SWEEP ${side} - levels: ${levels} | volume: ${volume}`);
+  },
+
+  iceberg(ui, symbol, price, hiddenSize) {
+    ui.addLog('analysis', `ICEBERG DETECTED - price: ${price.toFixed(2)} | hidden: ${hiddenSize}`);
+  },
+
+  deltaDivergence(ui, symbol, priceDir, deltaDir) {
+    ui.addLog('analysis', `DELTA DIVERGENCE - price: ${priceDir} | delta: ${deltaDir}`);
+  },
+
+  vpoc(ui, symbol, poc, valueHigh, valueLow) {
+    ui.addLog('analysis', `VPOC ${symbol} - poc: ${poc.toFixed(2)} | VAH: ${valueHigh.toFixed(2)} | VAL: ${valueLow.toFixed(2)}`);
+  },
+
+  regime(ui, symbol, regime, confidence) {
+    ui.addLog('analysis', `REGIME ${symbol} - ${regime} | confidence: ${confidence.toFixed(0)}%`);
+  },
+
+  volatility(ui, symbol, atr, regime) {
+    ui.addLog('analysis', `VOLATILITY ${symbol} - ATR: ${atr.toFixed(2)} | regime: ${regime}`);
+  },
+
+  // === SIGNAL LOGS ===
+  signalGenerated(ui, symbol, direction, confidence, strategy) {
+    const arrow = direction === 'LONG' ? '▲' : '▼';
+    ui.addLog('signal', `SIGNAL ${arrow} ${direction} - ${symbol} | conf: ${confidence.toFixed(0)}% | strategy: ${strategy}`);
+  },
+
+  signalRejected(ui, symbol, reason) {
+    ui.addLog('warning', `SIGNAL REJECTED - ${symbol} | reason: ${reason}`);
+  },
+
+  signalExpired(ui, symbol) {
+    ui.addLog('info', `SIGNAL EXPIRED - ${symbol}`);
+  },
+
+  // === TRADE LOGS ===
+  orderSubmitted(ui, symbol, side, size, price) {
+    ui.addLog('trade', `ORDER SUBMITTED - ${side} ${size} ${symbol} @ ${price.toFixed(2)}`);
+  },
+
+  orderFilled(ui, symbol, side, size, price) {
+    ui.addLog('trade', `ORDER FILLED - ${side} ${size} ${symbol} @ ${price.toFixed(2)}`);
+  },
+
+  orderRejected(ui, symbol, reason) {
+    ui.addLog('error', `ORDER REJECTED - ${symbol} | ${reason}`);
+  },
+
+  orderCancelled(ui, symbol, orderId) {
+    ui.addLog('warning', `ORDER CANCELLED - ${symbol} | id: ${orderId}`);
+  },
+
+  positionOpened(ui, symbol, side, size, entry) {
+    const arrow = side === 'LONG' ? '▲' : '▼';
+    ui.addLog('trade', `POSITION OPENED ${arrow} - ${side} ${size} ${symbol} @ ${entry.toFixed(2)}`);
+  },
+
+  positionClosed(ui, symbol, side, size, exit, pnl) {
+    const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+    const type = pnl >= 0 ? 'trade' : 'warning';
+    ui.addLog(type, `POSITION CLOSED - ${side} ${size} ${symbol} @ ${exit.toFixed(2)} | PnL: ${pnlStr}`);
+  },
+
+  stopHit(ui, symbol, price, loss) {
+    ui.addLog('warning', `STOP LOSS HIT - ${symbol} @ ${price.toFixed(2)} | loss: -$${Math.abs(loss).toFixed(2)}`);
+  },
+
+  targetHit(ui, symbol, price, profit) {
+    ui.addLog('trade', `TARGET HIT - ${symbol} @ ${price.toFixed(2)} | profit: +$${profit.toFixed(2)}`);
+  },
+
+  trailingStopMoved(ui, symbol, oldStop, newStop) {
+    ui.addLog('info', `TRAILING STOP MOVED - ${symbol} | ${oldStop.toFixed(2)} → ${newStop.toFixed(2)}`);
+  },
+
+  fillSync(ui, side, size, price, orderId) {
+    ui.addLog('trade', `FILL (SYNC) - ${side} ${size} @ ${price.toFixed(2)} (order #${orderId})`);
+  },
+
+  entryConfirmed(ui, side, size, symbol, price) {
+    ui.addLog('info', `ENTRY CONFIRMED - ${side} ${size}x ${symbol} @ ${price.toFixed(2)}`);
+  },
+
+  stopsSet(ui, sl, tp) {
+    ui.addLog('info', `STOPS SET - SL: ${sl.toFixed(2)} | TP: ${tp.toFixed(2)}`);
+  },
+
+  // === RISK LOGS ===
+  riskCheck(ui, passed, reason) {
+    const type = passed ? 'info' : 'warning';
+    ui.addLog(type, `RISK CHECK ${passed ? 'PASSED' : 'BLOCKED'} - ${reason}`);
+  },
+
+  dailyLimitWarning(ui, current, limit) {
+    ui.addLog('warning', `DAILY LIMIT WARNING - PnL: $${current.toFixed(2)} / limit: $${limit.toFixed(2)}`);
+  },
+
+  maxDrawdownWarning(ui, current, max) {
+    ui.addLog('warning', `DRAWDOWN WARNING - current: ${current.toFixed(1)}% / max: ${max.toFixed(1)}%`);
+  },
+
+  positionSized(ui, contracts, kelly, riskAmount, riskPct) {
+    ui.addLog('info', `POSITION SIZE - ${contracts} contracts | kelly: ${kelly.toFixed(2)} | risk: $${riskAmount} (${riskPct}% of max)`);
+  },
+
+  bracketSet(ui, stopTicks, targetTicks, rr) {
+    ui.addLog('info', `BRACKET SET - SL: ${stopTicks}t | TP: ${targetTicks}t | R:R: ${rr.toFixed(1)}`);
+  },
+
+  // === STRATEGY LOGS ===
+  strategySelected(ui, strategy, session, regime) {
+    ui.addLog('info', `STRATEGY SELECTED - ${strategy} | session: ${session} | regime: ${regime}`);
+  },
+
+  strategySwitch(ui, from, to, reason) {
+    ui.addLog('info', `STRATEGY SWITCH - ${from} → ${to} | ${reason}`);
+  },
+
+  // === SESSION LOGS ===
+  sessionStart(ui, session) {
+    ui.addLog('info', `SESSION START - ${session}`);
+  },
+
+  sessionEnd(ui, session) {
+    ui.addLog('info', `SESSION END - ${session}`);
+  },
+
+  marketOpen(ui, session, etTime) {
+    ui.addLog('info', `MARKET OPEN - ${session} SESSION | ET: ${etTime} ET`);
+  },
+
+  marketClosed(ui) {
+    ui.addLog('warning', `MARKET CLOSED - Trading paused`);
+  },
+
+  // === SYSTEM LOGS ===
+  connectingToEngine(ui, accountId) {
+    ui.addLog('info', `CONNECTING TO ALGO ENGINE... - Account: ${accountId}`);
+  },
+
+  engineStarting(ui, platform, dailyTarget, dailyRisk) {
+    ui.addLog('info', `ALGO ENGINE STARTING... - Platform: ${platform} | Daily Target: $${dailyTarget} | Daily Risk: $${dailyRisk}`);
+  },
+
+  engineStarted(ui, platform, status) {
+    ui.addLog('info', `ALGO ENGINE STARTED - Status: ${status}`);
+  },
+
+  engineStopped(ui, reason) {
+    ui.addLog('info', `ENGINE STOPPED - ${reason || 'All positions flat'}`);
+  },
+
+  algoOperational(ui, platform) {
+    ui.addLog('info', `ALGO FULLY OPERATIONAL - Connected to ${platform} - Scanning for alpha...`);
+  },
+
+  dataConnected(ui, source) {
+    ui.addLog('info', `WEBSOCKET CONNECTED - Real-time updates enabled`);
+  },
+
+  dataDisconnected(ui, source, reason) {
+    ui.addLog('warning', `WEBSOCKET DISCONNECTED - Attempting to reconnect...`);
+  },
+
+  heartbeat(ui, tps, latency) {
+    ui.addLog('info', `HEARTBEAT - tps: ${tps} | latency: ${latency}ms`);
+  },
+
+  latencyReport(ui, latency) {
+    ui.addLog('analysis', `LATENCY - ${latency}ms order-to-fill`);
+  },
+
+  // === GENERIC ===
+  info(ui, message, details) {
+    ui.addLog('info', details ? `${message} - ${details}` : message);
+  },
+
+  warning(ui, message, details) {
+    ui.addLog('warning', details ? `${message} - ${details}` : message);
+  },
+
+  error(ui, message, details) {
+    ui.addLog('error', details ? `${message} - ${details}` : message);
+  },
+
+  signal(ui, message, details) {
+    ui.addLog('signal', details ? `${message} - ${details}` : message);
+  },
+
+  trade(ui, message, details) {
+    ui.addLog('trade', details ? `${message} - ${details}` : message);
+  },
+
+  analysis(ui, message, details) {
+    ui.addLog('analysis', details ? `${message} - ${details}` : message);
+  },
+};
+
+module.exports = { algoLogger };

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

@@ -14,6 +14,7 @@ const { checkMarketHours } = require('../../services/projectx/market');
 // Strategy & Market Data (obfuscated)
 const { M1 } = require('../../../dist/lib/m/s1');
 const { MarketDataFeed } = require('../../../dist/lib/data');
+const { algoLogger } = require('./logger');
 
 
 
@@ -213,12 +214,14 @@ const launchAlgo = async (service, account, contract, config) => {
   // Initialize Market Data Feed
   const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
   
-  // Log startup - UPPERCASE
-  ui.addLog('info', `CONNECTION: ${connectionType.toUpperCase()}`);
-  ui.addLog('info', `ACCOUNT: ${accountName.toUpperCase()}`);
-  ui.addLog('info', `SYMBOL: ${symbolName.toUpperCase()} | QTY: ${contracts}`);
-  ui.addLog('info', `TARGET: $${dailyTarget} | MAX RISK: $${maxRisk}`);
-  ui.addLog('info', 'CONNECTING TO MARKET DATA...');
+  // Smart startup logs (same as HQX-TG)
+  const market = checkMarketHours();
+  const sessionName = market.session || 'AMERICAN';
+  const etTime = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', timeZone: 'America/New_York' });
+  
+  algoLogger.connectingToEngine(ui, account.accountId);
+  algoLogger.engineStarting(ui, connectionType, dailyTarget, maxRisk);
+  algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
@@ -226,7 +229,12 @@ const launchAlgo = async (service, account, contract, config) => {
     
     const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
     
-    ui.addLog('signal', `${direction.toUpperCase()} signal @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
+    // Calculate position size with kelly
+    const kelly = Math.min(0.25, confidence);
+    const riskAmount = Math.round(maxRisk * kelly);
+    const riskPct = Math.round((riskAmount / maxRisk) * 100);
+    
+    algoLogger.positionSized(ui, contracts, kelly, riskAmount, riskPct);
     
     // Place order via API
     pendingOrder = true;
@@ -243,7 +251,13 @@ const launchAlgo = async (service, account, contract, config) => {
       if (orderResult.success) {
         currentPosition = direction === 'long' ? contracts : -contracts;
         stats.trades++;
-        ui.addLog('trade', `OPENED ${direction.toUpperCase()} ${contracts}x @ market`);
+        const sideStr = direction === 'long' ? 'BUY' : 'SELL';
+        const positionSide = direction === 'long' ? 'LONG' : 'SHORT';
+        
+        algoLogger.orderSubmitted(ui, symbolName, sideStr, contracts, entry);
+        algoLogger.orderFilled(ui, symbolName, sideStr, contracts, entry);
+        algoLogger.positionOpened(ui, symbolName, positionSide, contracts, entry);
+        algoLogger.entryConfirmed(ui, sideStr, contracts, symbolName, entry);
         
         // Place bracket orders (SL/TP)
         if (stopLoss && takeProfit) {
@@ -267,20 +281,24 @@ const launchAlgo = async (service, account, contract, config) => {
             limitPrice: takeProfit
           });
           
-          ui.addLog('info', `SL: ${stopLoss.toFixed(2)} | TP: ${takeProfit.toFixed(2)}`);
+          algoLogger.stopsSet(ui, stopLoss, takeProfit);
         }
       } else {
-        ui.addLog('error', `Order failed: ${orderResult.error}`);
+        algoLogger.orderRejected(ui, symbolName, orderResult.error || 'Unknown error');
       }
     } catch (e) {
-      ui.addLog('error', `Order error: ${e.message}`);
+      algoLogger.error(ui, 'ORDER ERROR', e.message);
     }
     pendingOrder = false;
   });
   
   // Handle market data ticks
+  let lastHeartbeat = Date.now();
+  let tps = 0;
+  
   marketFeed.on('tick', (tick) => {
     tickCount++;
+    tps++;
     const latencyStart = Date.now();
     
     // Feed tick to strategy
@@ -296,26 +314,27 @@ const launchAlgo = async (service, account, contract, config) => {
     
     stats.latency = Date.now() - latencyStart;
     
-    // Log every 100th tick to show activity
-    if (tickCount % 100 === 0) {
-      const displayPrice = tick.price || tick.bid || tick.ask;
-      ui.addLog('info', `TICK #${tickCount} @ ${displayPrice?.toFixed(2) || '--'}`);
+    // Heartbeat every 30 seconds (smart log instead of tick count)
+    if (Date.now() - lastHeartbeat > 30000) {
+      algoLogger.heartbeat(ui, tps, stats.latency);
+      lastHeartbeat = Date.now();
+      tps = 0;
     }
   });
   
   marketFeed.on('connected', () => {
     stats.connected = true;
-    ui.addLog('success', 'MARKET DATA CONNECTED');
+    algoLogger.dataConnected(ui, 'RTC');
+    algoLogger.algoOperational(ui, connectionType);
   });
   
   marketFeed.on('error', (err) => {
-    ui.addLog('error', `MARKET: ${err.message.toUpperCase()}`);
+    algoLogger.error(ui, 'MARKET ERROR', err.message);
   });
   
   marketFeed.on('disconnected', (err) => {
     stats.connected = false;
-    const reason = err?.message || 'UNKNOWN';
-    ui.addLog('error', `DISC: ${reason.substring(0, 70).toUpperCase()}`);
+    algoLogger.dataDisconnected(ui, 'WEBSOCKET', err?.message);
   });
   
   // Connect to market data
@@ -324,14 +343,14 @@ const launchAlgo = async (service, account, contract, config) => {
     
     // CRITICAL: Get a fresh token for WebSocket connection
     // TopStep invalidates WebSocket sessions for old tokens
-    ui.addLog('info', 'REFRESHING AUTH TOKEN...');
+    algoLogger.info(ui, 'REFRESHING AUTH TOKEN...');
     const token = await service.getFreshToken?.() || service.token || service.getToken?.();
     
     if (!token) {
-      ui.addLog('error', 'NO AUTH TOKEN - PLEASE RECONNECT');
+      algoLogger.error(ui, 'NO AUTH TOKEN', 'Please reconnect');
     } else {
-      ui.addLog('info', `TOKEN OK (${token.length} CHARS)`);
-      ui.addLog('info', `RTC: ${propfirmKey.toUpperCase()} | ${contractId}`);
+      algoLogger.info(ui, 'TOKEN OK', `${token.length} chars`);
+      algoLogger.info(ui, 'CONNECTING', `${propfirmKey.toUpperCase()} | ${contractId}`);
       
       await marketFeed.connect(token, propfirmKey);
       
@@ -340,13 +359,13 @@ const launchAlgo = async (service, account, contract, config) => {
       
       if (marketFeed.isConnected()) {
         await marketFeed.subscribe(symbolName, contractId);
-        ui.addLog('success', 'SUBSCRIBED TO MARKET DATA');
+        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} real-time feed active`);
       } else {
-        ui.addLog('error', 'CONNECTION LOST BEFORE SUBSCRIBE');
+        algoLogger.error(ui, 'CONNECTION LOST', 'Before subscribe');
       }
     }
   } catch (e) {
-    ui.addLog('error', `ERR: ${e.message.substring(0, 60).toUpperCase()}`);
+    algoLogger.error(ui, 'CONNECTION ERROR', e.message.substring(0, 50));
   }
   
   // Poll account P&L from API
@@ -391,11 +410,11 @@ const launchAlgo = async (service, account, contract, config) => {
       if (stats.pnl >= dailyTarget) {
         stopReason = 'target';
         running = false;
-        ui.addLog('success', `TARGET REACHED +$${stats.pnl.toFixed(2)}`);
+        algoLogger.targetHit(ui, symbolName, 0, stats.pnl);
       } else if (stats.pnl <= -maxRisk) {
         stopReason = 'risk';
         running = false;
-        ui.addLog('error', `MAX RISK -$${Math.abs(stats.pnl).toFixed(2)}`);
+        algoLogger.dailyLimitWarning(ui, stats.pnl, -maxRisk);
       }
     } catch (e) {
       // Silently handle polling errors