hedgequantx 2.6.162 → 2.7.0

package/src/lib/o/l2.js

@@ -0,0 +1,427 @@
+/**
+ * =============================================================================
+ * HQX Algo Trading System - Logger (HQX CLI)
+ * =============================================================================
+ * Intelligent logging that only logs on STATE CHANGES
+ * No spam, no repetitive messages - ultra fluid
+ *
+ * Philosophy:
+ * - Only log when something CHANGES
+ * - Track state internally
+ * - Aggregate similar events
+ * - Show clear progression of algo activity
+ * 
+ * COPIED FROM hqx_tg for consistency across platforms
+ */
+
+const EventEmitter = require('events');
+
+// =============================================================================
+// STATE TRACKING
+// =============================================================================
+
+const defaultState = {
+  // Algo status
+  status: 'STOPPED', // 'STARTING' | 'SCANNING' | 'APPROACHING' | 'AT_ZONE' | 'TRADING' | 'IN_POSITION' | 'STOPPING' | 'STOPPED'
+
+  // Market direction
+  direction: 'NEUTRAL', // 'LONG' | 'SHORT' | 'NEUTRAL'
+
+  // Pressure category
+  pressure: 'NEUTRAL', // 'STRONG_BUY' | 'BUY' | 'NEUTRAL' | 'SELL' | 'STRONG_SELL'
+
+  // Zone info
+  nearZone: null,  // e.g., "POC", "VAH", "VAL"
+  zoneDistance: 999,     // ticks from zone
+
+  // Price tracking (rounded)
+  lastPriceLevel: 0,
+
+  // Market regime
+  regime: 'RANGING', // 'TRENDING' | 'RANGING' | 'VOLATILE' | 'QUIET'
+
+  // Session
+  session: '',
+
+  // Spread status
+  spreadOk: true,
+};
+
+// =============================================================================
+// SMART LOGGER CLASS
+// =============================================================================
+
+class SmartLogger extends EventEmitter {
+  constructor() {
+    super();
+    this.state = { ...defaultState };
+    this.lastLogTime = new Map();
+    this.MIN_LOG_INTERVAL = 3000; // Min 3s between same log type
+  }
+
+  /**
+   * Reset state (when algo starts/stops)
+   */
+  reset() {
+    this.state = { ...defaultState };
+    this.lastLogTime.clear();
+  }
+
+  /**
+   * Core log function - emits log events
+   */
+  log(type, message, details) {
+    const logData = {
+      type,
+      message,
+      details,
+      timestamp: Date.now(),
+    };
+    
+    this.emit('log', logData);
+    
+    // Also print to console for CLI
+    this.printToConsole(logData);
+  }
+
+  /**
+   * Print formatted log to console
+   */
+  printToConsole(logData) {
+    const { type, message, details, timestamp } = logData;
+    const time = new Date(timestamp).toLocaleTimeString();
+    
+    // Color codes for terminal
+    const colors = {
+      info: '\x1b[36m',      // Cyan
+      signal: '\x1b[33m',    // Yellow
+      trade: '\x1b[32m',     // Green
+      warning: '\x1b[33m',   // Yellow
+      error: '\x1b[31m',     // Red
+      analysis: '\x1b[35m',  // Magenta
+      reset: '\x1b[0m',
+    };
+
+    const color = colors[type] || colors.info;
+    const icon = this.getIcon(type);
+    
+    let output = `${color}[${time}] ${icon} ${message}${colors.reset}`;
+    if (details) {
+      output += ` | ${details}`;
+    }
+    
+    console.log(output);
+  }
+
+  getIcon(type) {
+    switch (type) {
+      case 'info': return 'ℹ️ ';
+      case 'signal': return '🎯';
+      case 'trade': return '💰';
+      case 'warning': return '⚠️ ';
+      case 'error': return '❌';
+      case 'analysis': return '📊';
+      default: return '•';
+    }
+  }
+
+  /**
+   * Check if we should throttle this log
+   */
+  shouldThrottle(key) {
+    const now = Date.now();
+    const last = this.lastLogTime.get(key) || 0;
+    if (now - last < this.MIN_LOG_INTERVAL) {
+      return true;
+    }
+    this.lastLogTime.set(key, now);
+    return false;
+  }
+
+  // ===========================================================================
+  // STATUS CHANGES (always log)
+  // ===========================================================================
+
+  algoStarting(platform, symbol) {
+    this.state.status = 'STARTING';
+    this.log('info', 'ALGO STARTING...', `${platform} | ${symbol}`);
+  }
+
+  algoRunning() {
+    if (this.state.status !== 'SCANNING') {
+      this.state.status = 'SCANNING';
+      this.log('info', 'ALGO RUNNING', 'Scanning for alpha...');
+    }
+  }
+
+  algoStopping() {
+    if (this.state.status !== 'STOPPING') {
+      this.state.status = 'STOPPING';
+      this.log('warning', 'STOPPING ALGO...', 'Closing positions...');
+    }
+  }
+
+  algoStopped() {
+    this.state.status = 'STOPPED';
+    this.log('info', 'ALGO STOPPED', 'All positions flat');
+    this.reset();
+  }
+
+  // ===========================================================================
+  // MARKET SESSION (log on change)
+  // ===========================================================================
+
+  sessionChange(session, etTime) {
+    if (this.state.session !== session) {
+      this.state.session = session;
+      this.log('info', `MARKET OPEN`, `${session} SESSION | ${etTime} ET`);
+    }
+  }
+
+  marketClosed() {
+    if (this.state.session !== 'CLOSED') {
+      this.state.session = 'CLOSED';
+      this.log('warning', 'MARKET CLOSED', 'Trading paused');
+    }
+  }
+
+  // ===========================================================================
+  // DIRECTION & PRESSURE (log on significant change)
+  // ===========================================================================
+
+  updateMarketContext(direction, buyPressure, delta, bid, ask) {
+    // Determine pressure category
+    let newPressure;
+    if (buyPressure >= 70) newPressure = 'STRONG_BUY';
+    else if (buyPressure >= 55) newPressure = 'BUY';
+    else if (buyPressure <= 30) newPressure = 'STRONG_SELL';
+    else if (buyPressure <= 45) newPressure = 'SELL';
+    else newPressure = 'NEUTRAL';
+
+    // Only log if direction OR pressure category changed
+    const dirChanged = this.state.direction !== direction;
+    const pressureChanged = this.state.pressure !== newPressure;
+
+    if (dirChanged || pressureChanged) {
+      this.state.direction = direction;
+      this.state.pressure = newPressure;
+
+      const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '●';
+      const deltaStr = delta >= 0 ? `+${delta}` : `${delta}`;
+      const pressureIcon = this.getPressureIcon(newPressure);
+
+      this.log('analysis',
+        `${arrow} ${direction} ${pressureIcon}`,
+        `delta: ${deltaStr} | buy: ${buyPressure.toFixed(0)}% | bid: ${bid.toFixed(2)}`
+      );
+    }
+  }
+
+  getPressureIcon(pressure) {
+    switch (pressure) {
+      case 'STRONG_BUY': return '🟢🟢';
+      case 'BUY': return '🟢';
+      case 'STRONG_SELL': return '🔴🔴';
+      case 'SELL': return '🔴';
+      default: return '⚪';
+    }
+  }
+
+  // ===========================================================================
+  // ZONE PROXIMITY (log on state change)
+  // ===========================================================================
+
+  approachingZone(zoneType, distance, entryDistance, price) {
+    const wasApproaching = this.state.status === 'APPROACHING';
+    const sameZone = this.state.nearZone === zoneType;
+
+    if (!wasApproaching || !sameZone) {
+      this.state.status = 'APPROACHING';
+      this.state.nearZone = zoneType;
+      this.state.zoneDistance = distance;
+      this.log('analysis',
+        `APPROACHING ${zoneType}`,
+        `${distance}/${entryDistance} ticks to ${price.toFixed(2)}`
+      );
+    }
+    this.state.zoneDistance = distance;
+  }
+
+  enteredZone(zoneType, price) {
+    if (this.state.status !== 'AT_ZONE' || this.state.nearZone !== zoneType) {
+      this.state.status = 'AT_ZONE';
+      this.state.nearZone = zoneType;
+      this.log('signal', `AT ${zoneType} ZONE`, `@ ${price.toFixed(2)} - checking confirmations...`);
+    }
+  }
+
+  leftZone() {
+    if (this.state.nearZone) {
+      const oldZone = this.state.nearZone;
+      this.state.nearZone = null;
+      this.state.status = 'SCANNING';
+      this.log('info', `LEFT ${oldZone} ZONE`, 'Back to scanning...');
+    }
+  }
+
+  noZonesNearby() {
+    if (this.state.nearZone) {
+      this.state.nearZone = null;
+      this.state.status = 'SCANNING';
+    }
+  }
+
+  // ===========================================================================
+  // ZONE REJECTION REASONS (log with throttle)
+  // ===========================================================================
+
+  zoneNoDirection(zoneType) {
+    if (!this.shouldThrottle('nodir')) {
+      this.log('analysis', `${zoneType} - WAITING`, 'No clear direction yet');
+    }
+  }
+
+  zoneMissingConfirmations(zoneType, have, need, confirmations) {
+    if (!this.shouldThrottle('confirmations')) {
+      const confStr = confirmations.length > 0 ? confirmations.join(', ') : 'none';
+      this.log('analysis', `${zoneType} - ${have}/${need} CONF`, confStr);
+    }
+  }
+
+  zoneLowConfidence(zoneType, confidence, required) {
+    if (!this.shouldThrottle('confidence')) {
+      this.log('analysis', `${zoneType} - LOW CONF`, `${confidence.toFixed(0)}% < ${required.toFixed(0)}%`);
+    }
+  }
+
+  // ===========================================================================
+  // SIGNAL & TRADE EVENTS (always log)
+  // ===========================================================================
+
+  signalGenerated(direction, zoneType, confidence, orderType) {
+    const arrow = direction === 'LONG' ? '▲' : '▼';
+    this.log('signal',
+      `✓ SIGNAL ${arrow} ${direction}`,
+      `${zoneType} @ ${confidence.toFixed(0)}% conf | ${orderType}`
+    );
+  }
+
+  orderPlaced(side, size, symbol, price, type) {
+    this.state.status = 'TRADING';
+    this.log('trade',
+      `ORDER ${type.toUpperCase()}`,
+      `${side} ${size} ${symbol} @ ${price.toFixed(2)}`
+    );
+  }
+
+  orderFilled(side, size, symbol, price) {
+    this.state.status = 'IN_POSITION';
+    this.log('trade',
+      `✓ FILLED`,
+      `${side} ${size} ${symbol} @ ${price.toFixed(2)}`
+    );
+  }
+
+  orderRejected(reason) {
+    this.state.status = 'SCANNING';
+    this.log('error', 'ORDER REJECTED', reason);
+  }
+
+  positionClosed(side, pnl) {
+    this.state.status = 'SCANNING';
+    const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+    const type = pnl >= 0 ? 'trade' : 'warning';
+    this.log(type, 'POSITION CLOSED', `${side} | P&L: ${pnlStr}`);
+  }
+
+  // ===========================================================================
+  // VWAP & STRATEGY SPECIFIC (for Ultra Scalping V2)
+  // ===========================================================================
+
+  vwapUpdate(zScore, regime, confidence) {
+    if (!this.shouldThrottle('vwap')) {
+      const deviationStr = zScore >= 0 ? `+${zScore.toFixed(2)}σ` : `${zScore.toFixed(2)}σ`;
+      this.log('analysis', `VWAP: ${deviationStr}`, `Regime: ${regime} | Conf: ${(confidence * 100).toFixed(0)}%`);
+    }
+  }
+
+  strategySignal(direction, vwapZ, confidence, stopTicks, targetTicks) {
+    const arrow = direction === 'long' ? '▲' : '▼';
+    this.log('signal',
+      `${arrow} SIGNAL ${direction.toUpperCase()}`,
+      `VWAP: ${vwapZ.toFixed(2)}σ | Conf: ${(confidence * 100).toFixed(0)}% | SL: ${stopTicks}t TP: ${targetTicks}t`
+    );
+  }
+
+  // ===========================================================================
+  // RISK EVENTS (always log)
+  // ===========================================================================
+
+  riskPassed() {
+    // Don't log every risk check - too noisy
+  }
+
+  riskBlocked(reason) {
+    if (!this.shouldThrottle('risk_blocked')) {
+      this.log('warning', 'RISK BLOCKED', reason);
+    }
+  }
+
+  spreadWarning(spread) {
+    if (this.state.spreadOk) {
+      this.state.spreadOk = false;
+      this.log('warning', 'WIDE SPREAD', `${spread.toFixed(2)} pts - waiting...`);
+    }
+  }
+
+  spreadOk() {
+    if (!this.state.spreadOk) {
+      this.state.spreadOk = true;
+    }
+  }
+
+  // ===========================================================================
+  // PRICE MOVEMENTS (only significant)
+  // ===========================================================================
+
+  significantMove(direction, ticks, from, to) {
+    if (Math.abs(ticks) >= 3) {
+      const arrow = direction === 'up' ? '▲' : '▼';
+      this.log('info',
+        `PRICE ${arrow} ${Math.abs(ticks)} ticks`,
+        `${from.toFixed(2)} → ${to.toFixed(2)}`
+      );
+    }
+  }
+
+  // ===========================================================================
+  // CONNECTION EVENTS (always log)
+  // ===========================================================================
+
+  connected(source) {
+    this.log('info', 'CONNECTED', source);
+  }
+
+  disconnected(source) {
+    this.log('error', 'DISCONNECTED', source);
+  }
+
+  reconnecting(source) {
+    if (!this.shouldThrottle('reconnect')) {
+      this.log('warning', 'RECONNECTING...', source);
+    }
+  }
+
+  // ===========================================================================
+  // UTILITY
+  // ===========================================================================
+
+  getState() {
+    return { ...this.state };
+  }
+}
+
+// Singleton instance
+const smartLogger = new SmartLogger();
+
+module.exports = { SmartLogger, smartLogger };

package/src/lib/python-bridge.js

@@ -0,0 +1,206 @@
+/**
+ * X Algo - Python Bridge
+ * Wrapper to call Cython-compiled algo-core from Node.js
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const EventEmitter = require('events');
+
+// Path to algo-core Python module
+const ALGO_CORE_PATH = path.join(__dirname, '../../algo-core');
+
+class PythonBridge extends EventEmitter {
+  constructor() {
+    super();
+    this.process = null;
+    this.ready = false;
+    this.pendingCallbacks = new Map();
+    this.callId = 0;
+  }
+
+  /**
+   * Start the Python process
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      // Spawn Python process running the bridge server
+      this.process = spawn('python3', [
+        '-u',  // Unbuffered output
+        path.join(ALGO_CORE_PATH, 'bridge_server.py')
+      ], {
+        cwd: ALGO_CORE_PATH,
+        env: { ...process.env, PYTHONPATH: ALGO_CORE_PATH }
+      });
+
+      let startupOutput = '';
+
+      this.process.stdout.on('data', (data) => {
+        const lines = data.toString().split('\n').filter(l => l.trim());
+        
+        for (const line of lines) {
+          try {
+            const msg = JSON.parse(line);
+            
+            if (msg.type === 'ready') {
+              this.ready = true;
+              resolve();
+            } else if (msg.type === 'response') {
+              const callback = this.pendingCallbacks.get(msg.id);
+              if (callback) {
+                this.pendingCallbacks.delete(msg.id);
+                if (msg.error) {
+                  callback.reject(new Error(msg.error));
+                } else {
+                  callback.resolve(msg.result);
+                }
+              }
+            } else if (msg.type === 'signal') {
+              this.emit('signal', msg.data);
+            } else if (msg.type === 'log') {
+              this.emit('log', msg.data);
+            }
+          } catch (e) {
+            // Not JSON, just log output
+            startupOutput += line + '\n';
+          }
+        }
+      });
+
+      this.process.stderr.on('data', (data) => {
+        console.error('[Python Bridge Error]', data.toString());
+      });
+
+      this.process.on('error', (err) => {
+        this.ready = false;
+        reject(err);
+      });
+
+      this.process.on('close', (code) => {
+        this.ready = false;
+        if (code !== 0) {
+          console.error(`[Python Bridge] Process exited with code ${code}`);
+        }
+        this.emit('close', code);
+      });
+
+      // Timeout for startup
+      setTimeout(() => {
+        if (!this.ready) {
+          reject(new Error('Python bridge startup timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  /**
+   * Stop the Python process
+   */
+  stop() {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+      this.ready = false;
+    }
+  }
+
+  /**
+   * Call a method on the Python side
+   */
+  async call(method, args = {}) {
+    if (!this.ready || !this.process) {
+      throw new Error('Python bridge not ready');
+    }
+
+    const id = ++this.callId;
+    
+    return new Promise((resolve, reject) => {
+      this.pendingCallbacks.set(id, { resolve, reject });
+
+      const message = JSON.stringify({
+        id,
+        method,
+        args
+      }) + '\n';
+
+      this.process.stdin.write(message);
+
+      // Timeout for call
+      setTimeout(() => {
+        if (this.pendingCallbacks.has(id)) {
+          this.pendingCallbacks.delete(id);
+          reject(new Error(`Call timeout: ${method}`));
+        }
+      }, 30000);
+    });
+  }
+
+  // =========================================================================
+  // Strategy Methods
+  // =========================================================================
+
+  // tickSize for tick calculations, P&L comes from API
+  async initialize(contractId, tickSize = 0.25) {
+    return this.call('initialize', { contractId, tickSize });
+  }
+
+  async processBar(contractId, bar) {
+    return this.call('process_bar', { contractId, bar });
+  }
+
+  async processTick(tick) {
+    return this.call('process_tick', { tick });
+  }
+
+  async recordTradeResult(pnl) {
+    return this.call('record_trade_result', { pnl });
+  }
+
+  async getStats() {
+    return this.call('get_stats', {});
+  }
+
+  async getAnalysisState(contractId, currentPrice) {
+    return this.call('get_analysis_state', { contractId, currentPrice });
+  }
+
+  async reset(contractId) {
+    return this.call('reset', { contractId });
+  }
+
+  // =========================================================================
+  // Smart Logs Methods
+  // =========================================================================
+
+  async getSmartLog(condition, data) {
+    return this.call('get_smart_log', { condition, data });
+  }
+
+  async getMarketCondition(delta, buyPressure, sellPressure, deltaChange) {
+    return this.call('get_market_condition', { delta, buyPressure, sellPressure, deltaChange });
+  }
+}
+
+// Singleton instance
+let bridgeInstance = null;
+
+async function getPythonBridge() {
+  if (!bridgeInstance) {
+    bridgeInstance = new PythonBridge();
+    await bridgeInstance.start();
+  }
+  return bridgeInstance;
+}
+
+function closePythonBridge() {
+  if (bridgeInstance) {
+    bridgeInstance.stop();
+    bridgeInstance = null;
+  }
+}
+
+module.exports = {
+  PythonBridge,
+  getPythonBridge,
+  closePythonBridge
+};