hedgequantx 2.9.140 → 2.9.142

package/src/lib/smart-logs.js

@@ -37,6 +37,15 @@ const {
   STRATEGY_MESSAGES,
 } = require('./smart-logs-messages');
 
+const {
+  LIVE_BULLISH,
+  LIVE_BEARISH,
+  LIVE_NEUTRAL,
+  LIVE_BUILDING,
+  LIVE_ZONES,
+  LIVE_READY,
+} = require('./smart-logs-live');
+
 // Current strategy ID for context-aware messages
 let currentStrategyId = null;
 
@@ -245,6 +254,66 @@ function getPriceChangeLog(direction, price, change) {
   return { message: `${arrow} ${price.toFixed(2)}`, details: `${direction} ${change.toFixed(2)}` };
 }
 
+/**
+ * Get live analysis log based on market and strategy state
+ * @param {Object} state - Current state
+ * @param {string} state.trend - 'bullish', 'bearish', or 'neutral'
+ * @param {number} state.bars - Number of bars processed
+ * @param {number} state.swings - Number of swings detected
+ * @param {number} state.zones - Number of active zones
+ * @param {number} state.price - Current price
+ * @param {boolean} state.nearZone - Whether price is near a zone
+ * @param {boolean} state.setupForming - Whether a setup is forming
+ * @returns {string} Contextual analysis message
+ */
+function getLiveAnalysisLog(state = {}) {
+  const { trend, bars, swings, zones, nearZone, setupForming } = state;
+  
+  let pool;
+  let category;
+  
+  // Determine which pool to use based on state priority
+  if (setupForming && zones > 0) {
+    // Setup is forming - high priority
+    pool = LIVE_READY;
+    category = 'live_ready';
+  } else if (nearZone && zones > 0) {
+    // Near a zone - watching
+    pool = LIVE_ZONES;
+    category = 'live_zones';
+  } else if (zones > 0 && swings >= 2) {
+    // Have zones and swings - market pool based on trend
+    if (trend === 'bullish') {
+      pool = LIVE_BULLISH;
+      category = 'live_bullish';
+    } else if (trend === 'bearish') {
+      pool = LIVE_BEARISH;
+      category = 'live_bearish';
+    } else {
+      pool = LIVE_NEUTRAL;
+      category = 'live_neutral';
+    }
+  } else if (bars < 10 || swings < 2) {
+    // Still building structure
+    pool = LIVE_BUILDING;
+    category = 'live_building';
+  } else {
+    // Default to market trend
+    if (trend === 'bullish') {
+      pool = LIVE_BULLISH;
+      category = 'live_bullish';
+    } else if (trend === 'bearish') {
+      pool = LIVE_BEARISH;
+      category = 'live_bearish';
+    } else {
+      pool = LIVE_NEUTRAL;
+      category = 'live_neutral';
+    }
+  }
+  
+  return getVariedMessage(category, pool, 'Analyzing market conditions...');
+}
+
 module.exports = {
   getMarketBiasLog,
   getSignalLog,
@@ -260,5 +329,6 @@ module.exports = {
   getModelAnalysisLog,
   getPositionUpdateLog,
   getPriceChangeLog,
+  getLiveAnalysisLog,
   setStrategy,
 };

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

@@ -7,6 +7,7 @@ const { loadStrategy } = require('../../lib/m');
 const { MarketDataFeed } = require('../../lib/data');
 const { SupervisionEngine } = require('../../services/ai-supervision');
 const smartLogs = require('../../lib/smart-logs');
+const { createEngine: createLogsEngine } = require('../../lib/smart-logs-engine');
 const { sessionLogger } = require('../../services/session-logger');
 
 /**
@@ -45,29 +46,13 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   });
   
   const stats = {
-    accountName,
-    symbol: symbolName,
-    qty: contracts,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: account.platform || 'Rithmic',
-    pnl: 0,
-    trades: 0,
-    wins: 0,
-    losses: 0,
-    latency: 0,
-    connected: false,
-    startTime: Date.now()
+    accountName, symbol: symbolName, qty: contracts, target: dailyTarget, risk: maxRisk,
+    propfirm: account.propfirm || 'Unknown', platform: account.platform || 'Rithmic',
+    pnl: 0, trades: 0, wins: 0, losses: 0, latency: 0, connected: false, startTime: Date.now()
   };
   
-  let running = true;
-  let stopReason = null;
-  let startingPnL = null;
-  let currentPosition = 0;
-  let pendingOrder = false;
-  let tickCount = 0;
-  let lastBias = 'FLAT';
+  let running = true, stopReason = null, startingPnL = null;
+  let currentPosition = 0, pendingOrder = false, tickCount = 0, lastBias = 'FLAT';
   
   const aiContext = { recentTicks: [], recentSignals: [], recentTrades: [], maxTicks: 100 };
   
@@ -76,6 +61,7 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   // Set strategy for context-aware smart logs
   smartLogs.setStrategy(strategyId);
+  const logsEngine = createLogsEngine(strategyId, symbolCode);
   
   // Start session logger for persistent logs
   const logFile = sessionLogger.start({
@@ -234,28 +220,18 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     pendingOrder = false;
   });
   
-  let lastPrice = null;
-  let lastBid = null;
-  let lastAsk = null;
-  let ticksPerSecond = 0;
-  let lastTickSecond = Math.floor(Date.now() / 1000);
-  let lastBiasLogSecond = 0;
-  let lastDebugLogSecond = 0;
-  let lastStateLogSecond = 0;
-  let buyVolume = 0;
-  let sellVolume = 0;
-  
-  
-  let lastTickTime = 0;
-  let tickLatencies = [];
+  let lastPrice = null, lastBid = null, lastAsk = null;
+  let ticksPerSecond = 0, lastTickSecond = Math.floor(Date.now() / 1000);
+  let lastBiasLogSecond = 0, lastStateLogSecond = 0;
+  let buyVolume = 0, sellVolume = 0, lastTickTime = 0, tickLatencies = [];
   
   marketFeed.on('tick', (tick) => {
     tickCount++;
     const now = Date.now();
     const currentSecond = Math.floor(now / 1000);
     
-    // Debug first 5 ticks to verify data
-    if (tickCount <= 5) {
+    // Debug first tick
+    if (tickCount === 1) {
       const p = Number(tick.price) || Number(tick.tradePrice) || 'NULL';
       sessionLogger.log('TICK', `#${tickCount} price=${p} symbol=${tick.symbol || tick.contractId || 'N/A'}`);
     }
@@ -284,66 +260,27 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       else if (price < lastPrice) sellVolume += volume;
     }
     
-    // Log first tick and periodic tick count
+    // Log first tick
     if (tickCount === 1) {
       ui.addLog('connected', `First tick @ ${price?.toFixed(2) || 'N/A'}`);
     }
     
-    // Log tick count every 60 seconds to confirm data flow
-    if (currentSecond - lastDebugLogSecond >= 60) {
-      lastDebugLogSecond = currentSecond;
-      const state = strategy.getAnalysisState?.(contractId, price);
-      const bars = state?.barsProcessed || 0;
-      ui.addLog('debug', `Ticks: ${tickCount} | Bars: ${bars} | Price: ${price?.toFixed(2)}`);
-    }
-    
-    // === SMART LOGS - REDUCED FREQUENCY ===
-    // Log bias every 30 seconds (was 5s - too verbose)
+    // Update bias from volume + log tick stats (every 30s)
     if (currentSecond - lastBiasLogSecond >= 30 && tickCount > 1) {
       lastBiasLogSecond = currentSecond;
-      
       const totalVol = buyVolume + sellVolume;
       const buyPressure = totalVol > 0 ? (buyVolume / totalVol) * 100 : 50;
-      const delta = buyVolume - sellVolume;
-      
-      let bias = buyPressure > 55 ? 'LONG' : buyPressure < 45 ? 'SHORT' : 'FLAT';
-      const biasLog = smartLogs.getMarketBiasLog(bias, delta, buyPressure);
-      const biasType = bias === 'LONG' ? 'bullish' : bias === 'SHORT' ? 'bearish' : 'analysis';
-      ui.addLog(biasType, `${biasLog.message} ${biasLog.details || ''}`);
-      lastBias = bias;
-      // Reset volume after logging to avoid accumulation
-      buyVolume = 0;
-      sellVolume = 0;
+      lastBias = buyPressure > 55 ? 'LONG' : buyPressure < 45 ? 'SHORT' : 'FLAT';
+      sessionLogger.log('TICK', `count=${tickCount} last=${price?.toFixed(2)} bias=${lastBias} vol=${totalVol}`);
+      buyVolume = 0; sellVolume = 0;
     }
     
-    // Strategy state log every 60 seconds (was 30s - too verbose)
+    // Strategy state log for session logger (every 60s)
     if (currentSecond - lastStateLogSecond >= 60 && tickCount > 1) {
       lastStateLogSecond = currentSecond;
       const state = strategy.getAnalysisState?.(contractId, price);
       if (state) {
-        const bars = state.barsProcessed || 0;
-        sessionLogger.state(state.activeZones || 0, state.swingsDetected || 0, bars, lastBias);
-        if (!state.ready) {
-          ui.addLog('system', `${state.message} (${bars} bars)`);
-        } else {
-          const resStr = state.nearestResistance ? state.nearestResistance.toFixed(2) : '--';
-          const supStr = state.nearestSupport ? state.nearestSupport.toFixed(2) : '--';
-          
-          ui.addLog('analysis', `Zones: ${state.activeZones} | R: ${resStr} | S: ${supStr} | Swings: ${state.swingsDetected}`);
-          if (price && state.nearestResistance) {
-            const gapR = state.nearestResistance - price, ticksR = Math.abs(Math.round(gapR / tickSize));
-            if (ticksR <= 50) ui.addLog('analysis', `PROX R: ${Math.abs(gapR).toFixed(2)} pts (${ticksR} ticks) | Sweep ABOVE then reject`);
-          }
-          if (price && state.nearestSupport) {
-            const gapS = price - state.nearestSupport, ticksS = Math.abs(Math.round(gapS / tickSize));
-            if (ticksS <= 50) ui.addLog('analysis', `PROX S: ${Math.abs(gapS).toFixed(2)} pts (${ticksS} ticks) | Sweep BELOW then reject`);
-          }
-          if (state.activeZones === 0) ui.addLog('risk', 'Building liquidity map...');
-          else if (!state.nearestSupport && !state.nearestResistance) ui.addLog('risk', 'Zones outside range');
-          else if (!state.nearestSupport) ui.addLog('analysis', 'Monitoring R for SHORT sweep');
-          else if (!state.nearestResistance) ui.addLog('analysis', 'Monitoring S for LONG sweep');
-          else ui.addLog('ready', 'Both zones active - awaiting sweep');
-        }
+        sessionLogger.state(state.activeZones || 0, state.swingsDetected || 0, state.barsProcessed || 0, lastBias);
       }
     }
     
@@ -468,6 +405,33 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
   pollPnL();
   
+  // Live analysis logs every 1 second
+  let lastLiveLogSecond = 0;
+  const liveLogInterval = setInterval(() => {
+    if (!running) return;
+    const now = Math.floor(Date.now() / 1000);
+    if (now === lastLiveLogSecond) return;
+    lastLiveLogSecond = now;
+    
+    // Get strategy state for context
+    const state = strategy.getAnalysisState?.(contractId, lastPrice);
+    const logState = {
+      bars: state?.barsProcessed || 0,
+      swings: state?.swingsDetected || 0,
+      zones: state?.activeZones || 0,
+      trend: lastBias === 'LONG' ? 'bullish' : lastBias === 'SHORT' ? 'bearish' : 'neutral',
+      nearZone: (state?.nearestSupport || state?.nearestResistance) ? true : false,
+      setupForming: state?.ready && state?.activeZones > 0,
+      position: currentPosition,
+      price: lastPrice || 0,
+      tickCount,
+    };
+    
+    const log = logsEngine.getLog(logState);
+    ui.addLog(log.type, log.message);
+    if (log.logToSession) sessionLogger.log('ANALYSIS', log.message);
+  }, 1000);
+  
   const setupKeyHandler = () => {
     if (!process.stdin.isTTY) return null;
     readline.emitKeypressEvents(process.stdin);
@@ -493,6 +457,7 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
+  clearInterval(liveLogInterval);
   await marketFeed.disconnect();
   if (cleanupKeys) cleanupKeys();
   ui.cleanup();

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

@@ -7,6 +7,7 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { loadStrategy } = require('../../lib/m');
 const { MarketDataFeed } = require('../../lib/data');
 const smartLogs = require('../../lib/smart-logs');
+const { createEngine: createLogsEngine } = require('../../lib/smart-logs-engine');
 const { sessionLogger } = require('../../services/session-logger');
 
 /**
@@ -106,6 +107,7 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
   });
   
   smartLogs.setStrategy(strategyId);
+  const logsEngine = createLogsEngine(strategyId);
   
   // Start session logger
   const logFile = sessionLogger.start({
@@ -212,6 +214,7 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     
     if (data.stats.tickCount === 1) {
       ui.addLog('connected', `[${symbolCode}] First tick @ ${price?.toFixed(2) || 'N/A'}`);
+      sessionLogger.log('TICK', `[${symbolCode}] #1 price=${price} symbol=${symbolCode}`);
     }
     
     data.stats.lastPrice = price;
@@ -237,23 +240,24 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     }
   });
   
-  // Log aggregated stats periodically (every 3 minutes)
+  // Log aggregated stats periodically (every 30s to session, every 3min to UI)
   const logInterval = setInterval(() => {
     const now = Math.floor(Date.now() / 1000);
-    if (now - lastLogSecond >= 180) {
-      lastLogSecond = now;
-      let totalTicks = 0;
-      let totalBars = 0;
-      let totalZones = 0;
-      let totalSwings = 0;
-      for (const [sym, data] of symbolData) {
-        totalTicks += data.stats.tickCount;
-        const state = data.strategy.getAnalysisState?.(sym, data.stats.lastPrice);
-        totalBars += state?.barsProcessed || 0;
-        totalZones += state?.activeZones || 0;
-        totalSwings += state?.swingsDetected || 0;
+    let totalTicks = 0, totalBars = 0, totalZones = 0, totalSwings = 0;
+    for (const [sym, data] of symbolData) {
+      totalTicks += data.stats.tickCount;
+      const state = data.strategy.getAnalysisState?.(sym, data.stats.lastPrice);
+      totalBars += state?.barsProcessed || 0;
+      totalZones += state?.activeZones || 0;
+      totalSwings += state?.swingsDetected || 0;
+    }
+    // Session log every 30s
+    if (now - lastLogSecond >= 30) {
+      sessionLogger.log('TICK', `count=${totalTicks} bars=${totalBars} zones=${totalZones} swings=${totalSwings}`);
+      if (now - lastLogSecond >= 180) {
+        ui.addLog('analysis', `Stats: ${totalTicks} ticks | ${totalBars} bars | ${totalZones} zones | ${totalSwings} swings`);
       }
-      ui.addLog('analysis', `Stats: ${totalTicks} ticks | ${totalBars} bars | ${totalZones} zones | ${totalSwings} swings`);
+      lastLogSecond = now;
     }
   }, 10000);
   
@@ -314,6 +318,44 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
   const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
   pollPnL();
   
+  // Live analysis logs every 1 second (rotates through symbols)
+  let liveLogSymbolIndex = 0;
+  let lastLiveLogSecond = 0;
+  const liveLogInterval = setInterval(() => {
+    if (!running) return;
+    const now = Math.floor(Date.now() / 1000);
+    if (now === lastLiveLogSecond) return;
+    lastLiveLogSecond = now;
+    
+    // Get a symbol to log (rotate through all)
+    const symbolCodes = Array.from(symbolData.keys());
+    if (symbolCodes.length === 0) return;
+    
+    const symbolCode = symbolCodes[liveLogSymbolIndex % symbolCodes.length];
+    liveLogSymbolIndex++;
+    
+    const data = symbolData.get(symbolCode);
+    if (!data) return;
+    
+    const state = data.strategy.getAnalysisState?.(symbolCode, data.stats.lastPrice);
+    const logState = {
+      bars: state?.barsProcessed || 0,
+      swings: state?.swingsDetected || 0,
+      zones: state?.activeZones || 0,
+      trend: 'neutral',
+      nearZone: (state?.nearestSupport || state?.nearestResistance) ? true : false,
+      setupForming: state?.ready && state?.activeZones > 0,
+      position: data.stats.position || 0,
+      price: data.stats.lastPrice || 0,
+      tickCount: data.stats.tickCount || 0,
+    };
+    
+    logsEngine.setSymbol(symbolCode);
+    const log = logsEngine.getLog(logState);
+    ui.addLog(log.type, log.message);
+    if (log.logToSession) sessionLogger.log('ANALYSIS', `[${symbolCode}] ${log.message}`);
+  }, 1000);
+  
   // Key handler
   const setupKeyHandler = () => {
     if (!process.stdin.isTTY) return null;
@@ -344,6 +386,7 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
   clearInterval(logInterval);
+  clearInterval(liveLogInterval);
   await marketFeed.disconnect();
   if (cleanupKeys) cleanupKeys();
   ui.cleanup();