hedgequantx 2.9.230 → 2.9.232

package/package.json

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

package/src/lib/smart-logs-engine.js

@@ -1,320 +1,228 @@
 /**
- * Smart Logs Engine - Unified Event-Driven Intelligent Logs
- * ==========================================================
+ * Smart Logs Engine - Professional HF-Grade Real-Time Logs
+ * =========================================================
  * 
- * UNIFIED SYSTEM for all CLI strategies:
- * - Same engine, same event detection logic
- * - Strategy-specific vocabulary (HQX-2B: bars/swings/zones, QUANT: ticks/Z-Score/VPIN/OFI)
- * - Uses smartLogs.getLiveAnalysisLog() for varied, non-repetitive messages
+ * REAL-TIME logs every second showing:
+ * 1. Current price action
+ * 2. QUANT model states (Z-Score, VPIN, OFI)
+ * 3. Why we're not entering (or why we ARE entering)
+ * 4. Market microstructure insights
  * 
- * Only logs when something SIGNIFICANT happens - no spam, no repetitive messages
- * 
- * COLOR SCHEME:
- * - Symbols: cyan (NQ, ES, CL, GC)
- * - Prices: white bold
- * - Bullish/Long: green
- * - Bearish/Short: red
- * - Neutral/System: gray/dim
- * - Signals: yellow/magenta
- * - Risk/Warnings: red bold
- * - Values: blue (Z-Score, VPIN, OFI numbers)
+ * NO fake messages - everything is derived from real tick data
  */
 
 'use strict';
 
 const chalk = require('chalk');
-const smartLogs = require('./smart-logs');
-const { getContextualMessage } = require('./smart-logs-context');
 
 // Color helpers for consistent styling
 const C = {
-  // Symbols & identifiers
   sym: (s) => chalk.cyan.bold(s),
-  
-  // Prices
   price: (p) => chalk.white.bold(p),
-  
-  // Direction
   long: (s) => chalk.green.bold(s),
   short: (s) => chalk.red.bold(s),
   bull: (s) => chalk.green(s),
   bear: (s) => chalk.red(s),
-  
-  // Values & metrics
   val: (v) => chalk.blue(v),
   valHigh: (v) => chalk.magenta.bold(v),
-  
-  // Status
   ok: (s) => chalk.green(s),
   warn: (s) => chalk.yellow(s),
   danger: (s) => chalk.red.bold(s),
-  
-  // System/neutral
   dim: (s) => chalk.dim(s),
   info: (s) => chalk.gray(s),
-  
-  // Special
   signal: (s) => chalk.yellow.bold(s),
-  zone: (s) => chalk.magenta(s),
-  regime: (s) => chalk.cyan(s),
 };
 
 const CONFIG = { 
-  SESSION_LOG_INTERVAL: 10,
-  // HQX-2B thresholds
-  PRICE_CHANGE_TICKS: 4,
-  DELTA_CHANGE_THRESHOLD: 200,
-  // QUANT thresholds
   Z_EXTREME: 2.0,
   Z_HIGH: 1.5,
   Z_BUILDING: 1.0,
+  OFI_STRONG: 0.20,
   OFI_THRESHOLD: 0.15,
-  VPIN_TOXIC: 0.6,
-  QUANT_WARMUP_TICKS: 250,
-  // Heartbeat interval - frequent updates in scanning mode
-  HEARTBEAT_MS: 5000,  // 5 seconds
-};
-
-const SYMBOLS = {
-  NQ: 'NQ', MNQ: 'MNQ', ES: 'ES', MES: 'MES', YM: 'YM', MYM: 'MYM',
-  CL: 'CL', MCL: 'MCL', GC: 'GC', MGC: 'MGC', SI: 'SI', SIL: 'SIL',
-  RTY: 'RTY', M2K: 'M2K', ZB: 'ZB', ZN: 'ZN',
+  VPIN_TOXIC: 0.65,
+  VPIN_ELEVATED: 0.50,
 };
 
 function getSym(s) {
   if (!s) return 'FUT';
   const b = s.split(':')[0].replace(/[FGHJKMNQUVXZ]\d{1,2}$/, '').toUpperCase();
-  return SYMBOLS[b] || b;
+  const map = { ENQ: 'NQ', EP: 'ES', RTY: 'RTY', EMD: 'EMD', MGC: 'GC', MCL: 'CL' };
+  return map[b] || b;
 }
 
 /**
- * Unified Smart Logs Engine
- * Works with any strategy - adapts vocabulary based on strategyId
+ * Professional HF Smart Logs Engine
  */
 class SmartLogsEngine {
   constructor(strategyId, symbol) {
-    this.strategyId = strategyId || 'hqx-2b';
+    this.strategyId = strategyId || 'ultra-scalping';
     this.symbolCode = symbol;
-    this.counter = 0;
-    this.lastState = null;
-    
-    // State tracking for event detection (both strategies)
-    this.lastBias = null;
-    this.warmupLogged = false;
+    this.lastLogHash = null;
+    this.lastLogTime = 0;
+    this.eventCounter = 0;
     
-    // HQX-2B specific
-    this.lastBars = 0;
-    this.lastSwings = 0;
-    this.lastZones = 0;
-    this.lastNearZone = false;
-    
-    // QUANT specific
-    this.lastZRegime = null;
-    this.lastVpinToxic = false;
+    // State tracking for change detection
+    this.prev = {
+      zRegime: null,
+      ofiDir: null,
+      vpinLevel: null,
+      position: 0,
+      ready: false,
+    };
   }
 
   setSymbol(s) { this.symbolCode = s; }
 
   /**
-   * Get log message - unified entry point
-   * Detects strategy and routes to appropriate handler
+   * Main entry - ALWAYS returns a UNIQUE log showing real-time market state
+   * Each message is different based on actual changing market data
    */
   getLog(state = {}) {
-    this.counter++;
     const sym = getSym(this.symbolCode);
-    const price = state.price > 0 ? state.price.toFixed(2) : '-.--';
-    const { position = 0, delta = 0 } = state;
-
-    // Active position - same for all strategies
+    const price = state.price > 0 ? state.price.toFixed(2) : null;
+    const { position = 0, zScore = 0, vpin = 0, ofi = 0, tickCount = 0, bars = 0, delta = 0, buyPct = 50 } = state;
+    
+    // Track price movement for context
+    const priceNum = state.price || 0;
+    const lastPrice = this._lastPrice || priceNum;
+    const priceDiff = priceNum - lastPrice;
+    const priceDir = priceDiff > 0.01 ? '▲' : priceDiff < -0.01 ? '▼' : '•';
+    const priceDirColor = priceDiff > 0 ? C.bull : priceDiff < 0 ? C.bear : C.dim;
+    this._lastPrice = priceNum;
+    
+    // Track tick velocity
+    const lastTicks = this._lastTicks || 0;
+    const tickVelocity = (tickCount || bars || 0) - lastTicks;
+    this._lastTicks = tickCount || bars || 0;
+    
+    // Not enough data - still warming up
+    const dataPoints = bars || tickCount || 0;
+    if (dataPoints < 50 || !price) {
+      const pct = Math.min(100, Math.round((dataPoints / 50) * 100));
+      const remaining = 50 - dataPoints;
+      return {
+        type: 'system',
+        message: `[${C.sym(sym)}] ${price ? C.price(price) : '-.--'} | Calibrating ${C.val(pct + '%')} | ${remaining} samples to ready | +${tickVelocity}/s`,
+        logToSession: false
+      };
+    }
+    
+    // Compute current states with precision for uniqueness
+    const absZ = Math.abs(zScore);
+    const ofiPct = (ofi * 100).toFixed(0);
+    const vpinPct = (vpin * 100).toFixed(0);
+    const buyPctRound = Math.round(buyPct || 50);
+    const deltaRound = Math.round(delta || 0);
+    
+    // Z-Score color based on level
+    const zColor = absZ >= CONFIG.Z_EXTREME ? C.valHigh : 
+                   absZ >= CONFIG.Z_HIGH ? C.warn : 
+                   absZ >= CONFIG.Z_BUILDING ? C.val : C.dim;
+    const zStr = zColor(`${zScore.toFixed(2)}σ`);
+    
+    // OFI color based on direction
+    const ofiColor = ofi > CONFIG.OFI_THRESHOLD ? C.bull : 
+                     ofi < -CONFIG.OFI_THRESHOLD ? C.bear : C.dim;
+    const ofiStr = ofiColor(`${ofi >= 0 ? '+' : ''}${ofiPct}%`);
+    
+    // VPIN color based on toxicity
+    const vpinColor = vpin > CONFIG.VPIN_TOXIC ? C.danger : 
+                      vpin > CONFIG.VPIN_ELEVATED ? C.warn : C.ok;
+    const vpinStr = vpinColor(`${vpinPct}%`);
+    
+    // Delta (buy-sell imbalance) display
+    const deltaColor = deltaRound > 0 ? C.bull : deltaRound < 0 ? C.bear : C.dim;
+    const deltaStr = deltaColor(`${deltaRound > 0 ? '+' : ''}${deltaRound}`);
+    
+    // Active position - show position management with unique data
     if (position !== 0) {
       const isLong = position > 0;
       const side = isLong ? C.long('LONG') : C.short('SHORT');
-      const flowFavor = (isLong && delta > 0) || (!isLong && delta < 0);
-      const flowLabel = flowFavor ? C.ok('FAVOR') : C.danger('ADVERSE');
-      const deltaStr = delta > 0 ? C.bull(`+${delta}`) : C.bear(`${delta}`);
+      const flowFavor = (isLong && ofi > 0) || (!isLong && ofi < 0);
+      const flowLabel = flowFavor ? C.ok('aligned') : C.warn('adverse');
+      const exitClose = absZ < 0.5;
+      const exitInfo = exitClose ? C.warn('EXIT ZONE') : 'holding';
+      
       return {
         type: 'trade',
-        message: `[${C.sym(sym)}] ${side} ACTIVE @ ${C.price(price)} | Delta: ${deltaStr} | Flow: ${flowLabel}`,
-        logToSession: true
+        message: `[${C.sym(sym)}] ${side} ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} ${exitInfo} | Δ:${deltaStr} | Flow:${flowLabel}`,
+        logToSession: false
       };
     }
-
-    // Route to strategy-specific handler
-    if (this.strategyId === 'ultra-scalping') {
-      return this._getQuantLog(state, sym, price);
-    } else {
-      return this._getHqx2bLog(state, sym, price);
-    }
-  }
-
-  /**
-   * HQX-2B Liquidity Sweep - Bar/Swing/Zone based events
-   */
-  _getHqx2bLog(state, sym, price) {
-    const { bars = 0, swings = 0, zones = 0, nearZone = false, trend = 'neutral', delta = 0 } = state;
     
-    let event = null;
+    // No position - show WHY we're not entering with unique context each time
+    const direction = zScore < 0 ? 'LONG' : 'SHORT';
+    const dirColor = zScore < 0 ? C.long : C.short;
+    
     let logType = 'analysis';
-    let message = null;
-
-    // EVENT 1: Warmup complete (10+ bars)
-    if (bars >= 10 && !this.warmupLogged) {
-      this.warmupLogged = true;
-      event = 'warmup';
-      const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${C.sym(sym)}] ${C.ok('2B ready')} | ${C.val(bars)} bars | ${C.dim(warmupMsg)}`;
-      logType = 'system';
+    let message;
+    
+    // VPIN toxic - highest priority blocker
+    if (vpin > CONFIG.VPIN_TOXIC) {
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | VPIN:${vpinStr} ${C.danger('TOXIC')} | Z:${zStr} | Δ:${deltaStr} | Hold`;
+      logType = 'risk';
     }
-    // EVENT 2: New zone created
-    else if (zones > this.lastZones && zones > 0) {
-      event = 'new_zone';
-      const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.zone('Zone #' + zones)} | ${C.signal(signalMsg)}`;
+    // Z-Score extreme + OFI confirms = SIGNAL
+    else if (absZ >= CONFIG.Z_EXTREME && 
+             ((zScore < 0 && ofi > CONFIG.OFI_THRESHOLD) || (zScore > 0 && ofi < -CONFIG.OFI_THRESHOLD))) {
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} ${C.signal('EXTREME')} | OFI:${ofiStr} ${C.ok('✓')} | ${dirColor(direction)} SIGNAL`;
       logType = 'signal';
     }
-    // EVENT 3: New swing detected
-    else if (swings > this.lastSwings && swings > 0) {
-      event = 'new_swing';
-      const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.info('Swing #' + swings)} | ${C.dim(scanMsg)}`;
-    }
-    // EVENT 4: Zone approach (price near zone)
-    else if (nearZone && !this.lastNearZone && zones > 0) {
-      event = 'zone_approach';
-      const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-      message = `[${C.sym(sym)}] ${C.price(price)} | ${C.warn('Zone approach')} | ${C.signal(signalMsg)}`;
+    // Z-Score extreme but OFI doesn't confirm
+    else if (absZ >= CONFIG.Z_EXTREME) {
+      const ofiNeed = zScore < 0 ? `need >${15}%` : `need <-${15}%`;
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} ${C.signal('!')} | OFI:${ofiStr} ${ofiNeed} | ${C.warn('pending')}`;
       logType = 'signal';
     }
-    // EVENT 5: Bias flip
-    else if (this.lastBias && trend !== this.lastBias && trend !== 'neutral' && this.lastBias !== 'neutral') {
-      event = 'bias_flip';
-      const arrow = trend === 'bullish' ? C.bull('▲') : C.bear('▼');
-      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
-      const newBias = trend === 'bullish' ? C.bull(trend) : C.bear(trend);
-      const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, trend);
-      message = `[${C.sym(sym)}] ${arrow} ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
-    }
-
-    // Update state tracking
-    this.lastBars = bars;
-    this.lastSwings = swings;
-    this.lastZones = zones;
-    this.lastNearZone = nearZone;
-    this.lastBias = trend;
-
-    if (event && message) {
-      return { type: logType, message, logToSession: event === 'new_zone' || event === 'bias_flip' };
-    }
-    return null;
-  }
-
-  /**
-   * QUANT (HQX Ultra Scalping) - Tick/Z-Score/VPIN/OFI based events
-   */
-  _getQuantLog(state, sym, price) {
-    const { tickCount = 0, zScore = 0, vpin = 0, ofi = 0 } = state;
-    const ticks = tickCount || state.bars || 0;
-    
-    const absZ = Math.abs(zScore);
-    const vpinToxic = vpin > CONFIG.VPIN_TOXIC;
-    const zRegime = absZ >= CONFIG.Z_EXTREME ? 'extreme' : absZ >= CONFIG.Z_HIGH ? 'high' : absZ >= CONFIG.Z_BUILDING ? 'building' : 'neutral';
-    const bias = ofi > CONFIG.OFI_THRESHOLD ? 'bullish' : ofi < -CONFIG.OFI_THRESHOLD ? 'bearish' : 'neutral';
-
-    let event = null;
-    let logType = 'analysis';
-    let message = null;
-
-    // Helper for Z-Score color
-    const zColor = (z) => {
-      const absVal = Math.abs(z);
-      const formatted = `${z.toFixed(1)}σ`;
-      if (absVal >= CONFIG.Z_EXTREME) return C.valHigh(formatted);
-      if (absVal >= CONFIG.Z_HIGH) return C.warn(formatted);
-      if (absVal >= CONFIG.Z_BUILDING) return C.val(formatted);
-      return C.dim(formatted);
-    };
-
-    // EVENT 1: Warmup complete (250 ticks for QUANT models)
-    if (ticks >= CONFIG.QUANT_WARMUP_TICKS && !this.warmupLogged) {
-      this.warmupLogged = true;
-      event = 'warmup';
-      const warmupMsg = getContextualMessage(this.symbolCode, this.strategyId, 'warmup');
-      message = `[${C.sym(sym)}] ${C.ok('QUANT ready')} | ${C.val(ticks)} ticks | ${C.dim(warmupMsg)}`;
-      logType = 'system';
-    }
-    // EVENT 2: Z-Score regime change
-    else if (this.lastZRegime !== null && zRegime !== this.lastZRegime) {
-      event = 'z_regime';
-      // Get instrument-specific market context message
-      const marketCtx = bias === 'bullish' ? 'bullish' : bias === 'bearish' ? 'bearish' : 'neutral';
-      const instrumentMsg = getContextualMessage(this.symbolCode, this.strategyId, marketCtx);
-      
-      if (zRegime === 'extreme') {
-        logType = 'signal';
-        const dir = zScore < 0 ? C.long('LONG') : C.short('SHORT');
-        const signalMsg = getContextualMessage(this.symbolCode, this.strategyId, 'signal');
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.signal('EXTREME')} | ${dir} | ${C.signal(signalMsg)}`;
-      } else if (zRegime === 'high') {
-        logType = 'signal';
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.warn('HIGH')} | ${C.dim(instrumentMsg)}`;
-      } else if (zRegime === 'building') {
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${zColor(zScore)} ${C.info('building')} | ${C.dim(instrumentMsg)}`;
-      } else {
-        const scanMsg = getContextualMessage(this.symbolCode, this.strategyId, 'scanning');
-        message = `[${C.sym(sym)}] ${C.price(price)} | Z: ${C.ok('normalized')} | ${C.dim(scanMsg)}`;
-      }
+    // Z-Score high - setup forming
+    else if (absZ >= CONFIG.Z_HIGH) {
+      const needed = (CONFIG.Z_EXTREME - absZ).toFixed(2);
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} +${needed}σ to signal | OFI:${ofiStr} | Δ:${deltaStr}`;
     }
-    // EVENT 3: Bias flip (OFI direction change)
-    else if (this.lastBias !== null && bias !== this.lastBias && bias !== 'neutral' && this.lastBias !== 'neutral') {
-      event = 'bias_flip';
-      const arrow = bias === 'bullish' ? C.bull('▲') : C.bear('▼');
-      const oldBias = this.lastBias === 'bullish' ? C.bull(this.lastBias) : C.bear(this.lastBias);
-      const newBias = bias === 'bullish' ? C.bull(bias) : C.bear(bias);
-      const flipMsg = getContextualMessage(this.symbolCode, this.strategyId, bias);
-      message = `[${C.sym(sym)}] ${arrow} OFI: ${oldBias} → ${newBias} | ${C.dim(flipMsg)}`;
+    // Z-Score building
+    else if (absZ >= CONFIG.Z_BUILDING) {
+      const needed = (CONFIG.Z_HIGH - absZ).toFixed(2);
+      const bias = zScore < 0 ? 'bid' : 'ask';
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} ${bias} pressure | +${needed}σ to setup | Δ:${deltaStr}`;
     }
-    // EVENT 4: VPIN toxicity change
-    else if (this.lastVpinToxic !== null && vpinToxic !== this.lastVpinToxic) {
-      event = 'vpin';
-      const vpinPct = (vpin * 100).toFixed(0);
-      if (vpinToxic) {
-        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.danger(vpinPct + '%')} ${C.danger('TOXIC')} - informed flow`;
-        logType = 'risk';
-      } else {
-        message = `[${C.sym(sym)}] ${C.price(price)} | VPIN: ${C.ok(vpinPct + '%')} ${C.ok('clean')} - normal flow`;
+    // Z-Score neutral - scanning
+    else {
+      // Cycle through different useful info each second to avoid repetition
+      const infoType = Math.floor(Date.now() / 1000) % 4;
+      let context;
+      switch (infoType) {
+        case 0:
+          context = `Δ:${deltaStr} | Buy:${buyPctRound}%`;
+          break;
+        case 1:
+          context = `VPIN:${vpinStr} | OFI:${ofiStr}`;
+          break;
+        case 2:
+          context = `${tickVelocity} ticks/s | Δ:${deltaStr}`;
+          break;
+        default:
+          context = `OFI:${ofiStr} | Buy:${buyPctRound}%`;
       }
-    }
-
-    // Update state tracking
-    this.lastZRegime = zRegime;
-    this.lastBias = bias;
-    this.lastVpinToxic = vpinToxic;
-
-    if (event && message) {
-      return { type: logType, message, logToSession: event === 'z_regime' || event === 'bias_flip' };
+      message = `[${C.sym(sym)}] ${priceDirColor(priceDir)} ${C.price(price)} | Z:${zStr} scanning | ${context}`;
     }
     
-    // EVENT-DRIVEN ONLY: No spam, no repetitive logs
-    // Silence = system is scanning, nothing notable happening
-    // This is professional HF behavior
-    return null;
+    return { type: logType, message, logToSession: logType === 'signal' };
   }
 
   reset() { 
-    this.lastState = null;
-    this.counter = 0;
-    this.lastBias = null;
-    this.warmupLogged = false;
-    // HQX-2B
-    this.lastBars = 0;
-    this.lastSwings = 0;
-    this.lastZones = 0;
-    this.lastNearZone = false;
-    // QUANT
-    this.lastZRegime = null;
-    this.lastVpinToxic = false;
+    this.lastLogHash = null;
+    this.lastLogTime = 0;
+    this.eventCounter = 0;
+    this._lastWarmupMilestone = 0;
+    this.prev = {
+      zRegime: null,
+      ofiDir: null,
+      vpinLevel: null,
+      position: 0,
+      ready: false,
+    };
   }
 }
 
 function createEngine(strategyId, symbol) { return new SmartLogsEngine(strategyId, symbol); }
-module.exports = { SmartLogsEngine, createEngine, CONFIG };
+module.exports = { SmartLogsEngine, createEngine, CONFIG, C };