hedgequantx 2.9.51 → 2.9.52

package/package.json

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

package/src/lib/smart-logs.js

@@ -0,0 +1,419 @@
+/**
+ * =============================================================================
+ * Smart Logging System
+ * =============================================================================
+ * Non-repetitive, contextual, varied log messages
+ * - Uses message pools to avoid repetition
+ * - Tracks recent messages to ensure variety
+ * - Provides market-context-aware messages
+ */
+
+'use strict';
+
+// Track recently used messages to avoid repetition
+const recentMessages = new Map();
+const MAX_RECENT = 5;
+
+/**
+ * Get a message from a pool, avoiding recent ones
+ */
+function getVariedMessage(category, pool, defaultMsg) {
+  const recent = recentMessages.get(category) || [];
+
+  // Filter out recently used messages
+  const available = pool.filter(msg => !recent.includes(msg));
+
+  // If all messages were recently used, reset
+  if (available.length === 0) {
+    recentMessages.set(category, []);
+    return pool[Math.floor(Math.random() * pool.length)] || defaultMsg;
+  }
+
+  // Pick a random available message
+  const chosen = available[Math.floor(Math.random() * available.length)] || defaultMsg;
+
+  // Track it
+  recent.push(chosen);
+  if (recent.length > MAX_RECENT) recent.shift();
+  recentMessages.set(category, recent);
+
+  return chosen;
+}
+
+// =============================================================================
+// MESSAGE POOLS - Market Flow
+// =============================================================================
+
+const LONG_BIAS_MESSAGES = [
+  'Bullish bias detected',
+  'Buyers in control',
+  'Long-side pressure',
+  'Bid accumulation',
+  'Buy programs active',
+];
+
+const SHORT_BIAS_MESSAGES = [
+  'Bearish bias detected',
+  'Sellers in control',
+  'Short-side pressure',
+  'Offer distribution',
+  'Sell programs active',
+];
+
+const FLAT_BIAS_MESSAGES = [
+  'Market balanced',
+  'Two-way flow',
+  'Consolidation mode',
+  'No clear direction',
+  'Mixed signals',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Trading Events
+// =============================================================================
+
+const SIGNAL_LONG_MESSAGES = [
+  'Buy signal generated',
+  'Long opportunity detected',
+  'Bullish setup confirmed',
+  'Entry signal: LONG',
+  'Buy zone activated',
+];
+
+const SIGNAL_SHORT_MESSAGES = [
+  'Sell signal generated',
+  'Short opportunity detected',
+  'Bearish setup confirmed',
+  'Entry signal: SHORT',
+  'Sell zone activated',
+];
+
+const ENTRY_LONG_MESSAGES = [
+  'Long position opened',
+  'Buy order filled',
+  'Entered long',
+  'Long initiated',
+  'Position: LONG',
+];
+
+const ENTRY_SHORT_MESSAGES = [
+  'Short position opened',
+  'Sell order filled',
+  'Entered short',
+  'Short initiated',
+  'Position: SHORT',
+];
+
+const EXIT_PROFIT_MESSAGES = [
+  'Target reached',
+  'Profit taken',
+  'Winner closed',
+  'TP hit',
+  'Profit locked',
+];
+
+const EXIT_LOSS_MESSAGES = [
+  'Stop triggered',
+  'Loss taken',
+  'Loser closed',
+  'SL hit',
+  'Risk contained',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Analysis
+// =============================================================================
+
+const ZONE_APPROACH_MESSAGES = [
+  'Approaching key level',
+  'Zone test incoming',
+  'Near decision point',
+  'Level approach detected',
+  'Key zone in range',
+];
+
+const ZONE_CONFIRMED_MESSAGES = [
+  'Zone confirmation',
+  'Level validated',
+  'Support/resistance active',
+  'Zone reaction detected',
+  'Level holding',
+];
+
+const HIGH_VOLATILITY_MESSAGES = [
+  'Volatility elevated',
+  'High ATR detected',
+  'Increased price range',
+  'Market volatile',
+  'Wide swings detected',
+];
+
+const LOW_VOLATILITY_MESSAGES = [
+  'Low volatility',
+  'Tight range detected',
+  'Compressed price action',
+  'Market quiet',
+  'Narrow swings',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Risk
+// =============================================================================
+
+const RISK_PASSED_MESSAGES = [
+  'Risk check passed',
+  'Trade approved',
+  'Within risk limits',
+  'Risk validated',
+  'Clear to trade',
+];
+
+const RISK_BLOCKED_MESSAGES = [
+  'Risk limit reached',
+  'Trade blocked',
+  'Exceeds risk threshold',
+  'Risk rejected',
+  'Waiting for conditions',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Status
+// =============================================================================
+
+const SCANNING_MESSAGES = [
+  'Scanning market...',
+  'Analyzing flow...',
+  'Monitoring structure...',
+  'Watching for setups...',
+  'Evaluating conditions...',
+];
+
+const WAITING_MESSAGES = [
+  'Waiting for confirmation...',
+  'Pending trigger...',
+  'Standby mode...',
+  'Awaiting signal...',
+  'Ready to act...',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Tick Flow
+// =============================================================================
+
+const TICK_FLOW_MESSAGES = [
+  'Processing tick data',
+  'Market data flowing',
+  'Live feed active',
+  'Tick stream healthy',
+  'Data streaming',
+];
+
+const BUILDING_BARS_MESSAGES = [
+  'Building price bars',
+  'Aggregating ticks',
+  'Forming candles',
+  'Bar construction',
+  'Chart building',
+];
+
+const MODEL_ANALYSIS_MESSAGES = [
+  'Running models',
+  'Analyzing patterns',
+  'Computing signals',
+  'Model evaluation',
+  'Strategy analysis',
+];
+
+// =============================================================================
+// SMART LOG GENERATORS
+// =============================================================================
+
+/**
+ * Get a market bias log
+ */
+function getMarketBiasLog(direction, delta, buyPressure) {
+  let pool;
+  switch (direction) {
+    case 'LONG': pool = LONG_BIAS_MESSAGES; break;
+    case 'SHORT': pool = SHORT_BIAS_MESSAGES; break;
+    default: pool = FLAT_BIAS_MESSAGES;
+  }
+
+  const message = getVariedMessage(`bias_${direction}`, pool, `${direction} bias`);
+  const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '=';
+
+  let details;
+  if (delta !== undefined && buyPressure !== undefined) {
+    details = `${arrow} delta: ${delta > 0 ? '+' : ''}${delta} | buy: ${buyPressure.toFixed(0)}%`;
+  }
+
+  return { message, details };
+}
+
+/**
+ * Get a signal log
+ */
+function getSignalLog(direction, symbol, confidence, strategy) {
+  const pool = direction === 'LONG' ? SIGNAL_LONG_MESSAGES : SIGNAL_SHORT_MESSAGES;
+  const message = getVariedMessage(`signal_${direction}`, pool, `${direction} signal`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${symbol} | ${confidence.toFixed(0)}% | ${strategy}`,
+  };
+}
+
+/**
+ * Get an entry log
+ */
+function getEntryLog(direction, symbol, size, price) {
+  const pool = direction === 'LONG' ? ENTRY_LONG_MESSAGES : ENTRY_SHORT_MESSAGES;
+  const message = getVariedMessage(`entry_${direction}`, pool, `${direction} entry`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)}`,
+  };
+}
+
+/**
+ * Get an exit log
+ */
+function getExitLog(isProfit, symbol, size, price, pnl) {
+  const pool = isProfit ? EXIT_PROFIT_MESSAGES : EXIT_LOSS_MESSAGES;
+  const category = isProfit ? 'exit_profit' : 'exit_loss';
+  const message = getVariedMessage(category, pool, isProfit ? 'Profit taken' : 'Loss taken');
+  const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+
+  return {
+    message,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)} | ${pnlStr}`,
+  };
+}
+
+/**
+ * Get a zone approach log
+ */
+function getZoneApproachLog(zoneType, level) {
+  const message = getVariedMessage('zone_approach', ZONE_APPROACH_MESSAGES, 'Zone approach');
+  return { message, details: `${zoneType} @ ${level.toFixed(2)}` };
+}
+
+/**
+ * Get a zone confirmation log
+ */
+function getZoneConfirmationLog(zoneType, level) {
+  const message = getVariedMessage('zone_confirm', ZONE_CONFIRMED_MESSAGES, 'Zone confirmed');
+  return { message, details: `${zoneType} @ ${level.toFixed(2)}` };
+}
+
+/**
+ * Get a volatility log
+ */
+function getVolatilityLog(isHigh, atr) {
+  const pool = isHigh ? HIGH_VOLATILITY_MESSAGES : LOW_VOLATILITY_MESSAGES;
+  const category = isHigh ? 'vol_high' : 'vol_low';
+  const message = getVariedMessage(category, pool, isHigh ? 'High volatility' : 'Low volatility');
+  return { message, details: atr ? `ATR: ${atr.toFixed(2)}` : undefined };
+}
+
+/**
+ * Get a risk check log
+ */
+function getRiskCheckLog(passed, reason) {
+  const pool = passed ? RISK_PASSED_MESSAGES : RISK_BLOCKED_MESSAGES;
+  const category = passed ? 'risk_pass' : 'risk_block';
+  const message = getVariedMessage(category, pool, passed ? 'Passed' : 'Blocked');
+  return { message, details: reason };
+}
+
+/**
+ * Get a scanning/waiting log
+ */
+function getScanningLog(isScanning = true) {
+  const pool = isScanning ? SCANNING_MESSAGES : WAITING_MESSAGES;
+  const category = isScanning ? 'scanning' : 'waiting';
+  const message = getVariedMessage(category, pool, isScanning ? 'Scanning...' : 'Waiting...');
+  return { message };
+}
+
+/**
+ * Get tick flow log
+ */
+function getTickFlowLog(tickCount, ticksPerSecond) {
+  const message = getVariedMessage('tick_flow', TICK_FLOW_MESSAGES, 'Tick flow');
+  return { message, details: `#${tickCount} | ${ticksPerSecond}/sec` };
+}
+
+/**
+ * Get building bars log
+ */
+function getBuildingBarsLog(barCount) {
+  const message = getVariedMessage('building_bars', BUILDING_BARS_MESSAGES, 'Building bars');
+  return { message, details: `${barCount} bars` };
+}
+
+/**
+ * Get model analysis log
+ */
+function getModelAnalysisLog(modelValues) {
+  const message = getVariedMessage('model_analysis', MODEL_ANALYSIS_MESSAGES, 'Analyzing');
+  const details = modelValues 
+    ? `Z:${modelValues.zscore} | VPIN:${modelValues.vpin} | OFI:${modelValues.ofi}`
+    : undefined;
+  return { message, details };
+}
+
+/**
+ * Get position update log with varied messaging
+ */
+function getPositionUpdateLog(side, size, unrealizedPnL, distanceToStop, distanceToTarget, holdTime) {
+  const arrow = side === 'LONG' ? '▲' : '▼';
+  const pnlStr = unrealizedPnL >= 0 ? `+$${unrealizedPnL.toFixed(2)}` : `-$${Math.abs(unrealizedPnL).toFixed(2)}`;
+
+  // Vary the message based on P&L status
+  let prefix;
+  if (unrealizedPnL > 0 && distanceToTarget < distanceToStop) {
+    const targetPct = Math.round((1 - distanceToTarget / (distanceToStop + distanceToTarget)) * 100);
+    prefix = targetPct > 75 ? 'Near target' : targetPct > 50 ? 'Running profit' : 'In profit';
+  } else if (unrealizedPnL < 0 && distanceToStop < distanceToTarget) {
+    const risk = Math.round((1 - distanceToStop / (distanceToStop + distanceToTarget)) * 100);
+    prefix = risk > 75 ? 'Stop risk' : risk > 50 ? 'Underwater' : 'Managing loss';
+  } else if (Math.abs(unrealizedPnL) < 5) {
+    prefix = 'Near entry';
+  } else {
+    prefix = unrealizedPnL > 0 ? 'In profit' : 'Managing';
+  }
+
+  return {
+    message: `${arrow} ${side} ${size}x`,
+    details: `${prefix}: ${pnlStr} | SL: ${distanceToStop.toFixed(0)}t | TP: ${distanceToTarget.toFixed(0)}t | ${holdTime}s`,
+  };
+}
+
+/**
+ * Get price change log
+ */
+function getPriceChangeLog(direction, price, change) {
+  const arrow = direction === 'UP' ? '▲' : '▼';
+  return { message: `${arrow} ${price.toFixed(2)}`, details: `${direction} ${change.toFixed(2)}` };
+}
+
+module.exports = {
+  getMarketBiasLog,
+  getSignalLog,
+  getEntryLog,
+  getExitLog,
+  getZoneApproachLog,
+  getZoneConfirmationLog,
+  getVolatilityLog,
+  getRiskCheckLog,
+  getScanningLog,
+  getTickFlowLog,
+  getBuildingBarsLog,
+  getModelAnalysisLog,
+  getPositionUpdateLog,
+  getPriceChangeLog,
+};

package/src/pages/algo/algo-executor.js

@@ -9,6 +9,7 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { loadStrategy } = require('../../lib/m');
 const { MarketDataFeed } = require('../../lib/data');
 const { SupervisionEngine } = require('../../services/ai-supervision');
+const smartLogs = require('../../lib/smart-logs');
 
 /**
  * Execute algo strategy with market data
@@ -37,7 +38,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   const accountName = showName 
     ? (account.accountName || account.rithmicAccountId || account.accountId) 
     : 'HQX *****';
-  const symbolName = contract.name;
+  const symbolName = contract.name;  // Display name: "Micro E-mini S&P 500"
+  const symbolCode = contract.symbol || contract.id;  // Rithmic symbol: "MESH6"
   const contractId = contract.id;
   const tickSize = contract.tickSize || 0.25;
   
@@ -93,18 +95,24 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
-    ui.addLog('info', `SIGNAL DETECTED: ${signal.direction?.toUpperCase()}`);
+    const dir = signal.direction?.toUpperCase() || 'UNKNOWN';
+    const signalLog = smartLogs.getSignalLog(dir, symbolCode, (signal.confidence || 0) * 100, strategyName);
+    ui.addLog('info', `${signalLog.message}`);
+    ui.addLog('info', signalLog.details);
     
     if (!running) {
-      ui.addLog('info', 'Signal ignored: not running');
+      const riskLog = smartLogs.getRiskCheckLog(false, 'Algo stopped');
+      ui.addLog('info', riskLog.message);
       return;
     }
     if (pendingOrder) {
-      ui.addLog('info', 'Signal ignored: order pending');
+      const riskLog = smartLogs.getRiskCheckLog(false, 'Order pending');
+      ui.addLog('info', riskLog.message);
       return;
     }
     if (currentPosition !== 0) {
-      ui.addLog('info', `Signal ignored: position open (${currentPosition})`);
+      const riskLog = smartLogs.getRiskCheckLog(false, `Position open (${currentPosition})`);
+      ui.addLog('info', riskLog.message);
       return;
     }
     
@@ -114,7 +122,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     aiContext.recentSignals.push({ ...signal, timestamp: Date.now() });
     if (aiContext.recentSignals.length > 10) aiContext.recentSignals.shift();
     
-    ui.addLog('info', `Signal: ${direction.toUpperCase()} @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
+    const riskLog = smartLogs.getRiskCheckLog(true, `${direction.toUpperCase()} @ ${entry.toFixed(2)}`);
+    ui.addLog('info', `${riskLog.message} - ${riskLog.details}`);
     
     // Multi-Agent AI Supervision
     if (supervisionEnabled && supervisionEngine) {
@@ -173,8 +182,9 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       if (orderResult.success) {
         currentPosition = direction === 'long' ? orderSize : -orderSize;
         stats.trades++;
-        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), 
-          `OPENED ${direction.toUpperCase()} ${orderSize}x @ market`);
+        const entryLog = smartLogs.getEntryLog(direction.toUpperCase(), symbolCode, orderSize, entry);
+        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), entryLog.message);
+        ui.addLog('info', entryLog.details);
         
         // Bracket orders
         if (stopLoss && takeProfit) {
@@ -203,6 +213,10 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let lastAsk = null;
   let ticksPerSecond = 0;
   let lastTickSecond = Math.floor(Date.now() / 1000);
+  let lastLogSecond = 0;
+  let buyVolume = 0;
+  let sellVolume = 0;
+  let barCount = 0;
   
   marketFeed.on('tick', (tick) => {
     tickCount++;
@@ -220,32 +234,69 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     aiContext.recentTicks.push(tick);
     if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
     
-    // Smart logs for tick flow
     const price = tick.price || tick.tradePrice;
     const bid = tick.bid || tick.bidPrice;
     const ask = tick.ask || tick.askPrice;
+    const volume = tick.volume || tick.size || 1;
+    
+    // Track buy/sell volume
+    if (tick.side === 'buy' || tick.aggressor === 1) buyVolume += volume;
+    else if (tick.side === 'sell' || tick.aggressor === 2) sellVolume += volume;
+    else if (price && lastPrice) {
+      if (price > lastPrice) buyVolume += volume;
+      else if (price < lastPrice) sellVolume += volume;
+    }
     
     // Log first tick
     if (tickCount === 1) {
-      ui.addLog('info', `First tick received @ ${price?.toFixed(2) || 'N/A'}`);
-      ui.addLog('info', `Tick type: ${tick.type || 'unknown'}`);
+      ui.addLog('connected', `First tick @ ${price?.toFixed(2) || 'N/A'}`);
     }
     
-    // Log price changes
-    if (price && lastPrice && price !== lastPrice) {
-      const direction = price > lastPrice ? 'UP' : 'DOWN';
-      const change = Math.abs(price - lastPrice).toFixed(2);
-      if (tickCount <= 10 || tickCount % 50 === 0) {
-        ui.addLog('info', `Price ${direction} ${change} -> ${price.toFixed(2)}`);
+    // === SMART LOGS EVERY SECOND ===
+    if (currentSecond !== lastLogSecond && tickCount > 1) {
+      lastLogSecond = currentSecond;
+      
+      const totalVol = buyVolume + sellVolume;
+      const buyPressure = totalVol > 0 ? (buyVolume / totalVol) * 100 : 50;
+      const delta = buyVolume - sellVolume;
+      
+      // Determine market bias
+      let bias = 'FLAT';
+      if (buyPressure > 55) bias = 'LONG';
+      else if (buyPressure < 45) bias = 'SHORT';
+      
+      // Get smart log for market bias
+      const biasLog = smartLogs.getMarketBiasLog(bias, delta, buyPressure);
+      ui.addLog('info', `${biasLog.message} ${biasLog.details || ''}`);
+      
+      // Get model values if available
+      const modelValues = strategy.getModelValues?.(contractId);
+      if (modelValues) {
+        barCount = modelValues.bars || barCount;
+        if (barCount >= 50) {
+          const modelLog = smartLogs.getModelAnalysisLog(modelValues);
+          ui.addLog('info', `${modelLog.message} ${modelLog.details || ''}`);
+        } else {
+          const barLog = smartLogs.getBuildingBarsLog(barCount);
+          ui.addLog('info', `${barLog.message} (${barLog.details})`);
+        }
       }
-    }
-    
-    // Log bid/ask spread
-    if (bid && ask && (bid !== lastBid || ask !== lastAsk)) {
-      const spread = (ask - bid).toFixed(2);
-      if (tickCount <= 5) {
-        ui.addLog('info', `Spread: ${spread} (Bid: ${bid.toFixed(2)} / Ask: ${ask.toFixed(2)})`);
+      
+      // Scanning log every 3 seconds
+      if (currentSecond % 3 === 0 && currentPosition === 0) {
+        const scanLog = smartLogs.getScanningLog(true);
+        ui.addLog('info', scanLog.message);
+      }
+      
+      // Tick flow log every 5 seconds
+      if (currentSecond % 5 === 0) {
+        const tickLog = smartLogs.getTickFlowLog(tickCount, ticksPerSecond);
+        ui.addLog('info', `${tickLog.message} ${tickLog.details}`);
       }
+      
+      // Reset volume counters
+      buyVolume = 0;
+      sellVolume = 0;
     }
     
     lastPrice = price;
@@ -255,19 +306,12 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     strategy.processTick({
       contractId: tick.contractId || contractId,
       price: price, bid: bid, ask: ask,
-      volume: tick.volume || tick.size || 1, 
+      volume: volume, 
       side: tick.side || tick.lastTradeSide || 'unknown',
       timestamp: tick.timestamp || Date.now()
     });
     
     stats.latency = Date.now() - latencyStart;
-    
-    // Periodic status logs
-    if (tickCount === 10) ui.addLog('info', `Receiving ticks... (${ticksPerSecond}/sec)`);
-    if (tickCount === 50) ui.addLog('info', `50 ticks processed, strategy analyzing...`);
-    if (tickCount % 200 === 0) {
-      ui.addLog('info', `Tick #${tickCount} @ ${price?.toFixed(2) || 'N/A'} | ${ticksPerSecond}/sec`);
-    }
   });
   
   marketFeed.on('connected', () => { 
@@ -287,7 +331,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       throw new Error('Rithmic credentials not available');
     }
     await marketFeed.connect(rithmicCredentials);
-    await marketFeed.subscribe(symbolName, contract.exchange || 'CME');
+    await marketFeed.subscribe(symbolCode, contract.exchange || 'CME');
+    ui.addLog('info', `Symbol code: ${symbolCode}`);
   } catch (e) {
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }