hedgequantx 2.6.162 → 2.7.0

package/src/services/ai/supervisor-utils.js

@@ -1,158 +0,0 @@
-/**
- * Supervisor Utility Functions
- * Pure functions for market analysis - no state dependencies
- */
-
-'use strict';
-
-const calculateTrendStrength = (ticks) => {
-  if (!ticks || ticks.length < 20) return { strength: 0, direction: 'unknown' };
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 20) return { strength: 0, direction: 'unknown' };
-  const shortTerm = prices.slice(-20);
-  const shortChange = shortTerm[shortTerm.length - 1] - shortTerm[0];
-  const mediumTerm = prices.slice(-50);
-  const mediumChange = mediumTerm[mediumTerm.length - 1] - mediumTerm[0];
-  const aligned = (shortChange > 0 && mediumChange > 0) || (shortChange < 0 && mediumChange < 0);
-  const avgRange = Math.abs(Math.max(...prices) - Math.min(...prices)) || 1;
-  return {
-    strength: aligned ? Math.min(1, (Math.abs(shortChange) + Math.abs(mediumChange)) / avgRange) : 0,
-    direction: mediumChange > 0 ? 'bullish' : mediumChange < 0 ? 'bearish' : 'neutral',
-    shortTermDirection: shortChange > 0 ? 'up' : shortChange < 0 ? 'down' : 'flat',
-    aligned
-  };
-};
-
-const calculateRecentRange = (ticks, count) => {
-  if (!ticks || ticks.length === 0) return { high: 0, low: 0, range: 0 };
-  const prices = ticks.slice(-count).map(t => t.price).filter(Boolean);
-  if (prices.length === 0) return { high: 0, low: 0, range: 0 };
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  return { high, low, range: high - low };
-};
-
-const calculatePriceVelocity = (ticks, count) => {
-  if (!ticks || ticks.length < 2) return { velocity: 0, acceleration: 0 };
-  const recentTicks = ticks.slice(-count);
-  if (recentTicks.length < 2) return { velocity: 0, acceleration: 0 };
-  const prices = recentTicks.map(t => t.price).filter(Boolean);
-  if (prices.length < 2) return { velocity: 0, acceleration: 0 };
-  const totalChange = prices[prices.length - 1] - prices[0];
-  const velocity = totalChange / prices.length;
-  const midPoint = Math.floor(prices.length / 2);
-  const firstHalfVelocity = (prices[midPoint] - prices[0]) / midPoint;
-  const secondHalfVelocity = (prices[prices.length - 1] - prices[midPoint]) / (prices.length - midPoint);
-  const acceleration = secondHalfVelocity - firstHalfVelocity;
-  return { velocity, acceleration };
-};
-
-const getMarketSession = (hour) => {
-  if (hour >= 9 && hour < 12) return 'morning';
-  if (hour >= 12 && hour < 14) return 'midday';
-  if (hour >= 14 && hour < 16) return 'afternoon';
-  if (hour >= 16 && hour < 18) return 'close';
-  if (hour >= 18 || hour < 9) return 'overnight';
-  return 'unknown';
-};
-
-const getMinutesSinceOpen = (hour) => {
-  const now = new Date();
-  const currentMinutes = hour * 60 + now.getMinutes();
-  const openMinutes = 9 * 60 + 30;
-  return Math.max(0, currentMinutes - openMinutes);
-};
-
-const analyzePriceLevelInteraction = (entryPrice, ticks) => {
-  if (!ticks || ticks.length < 20) return null;
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 20) return null;
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  const range = high - low || 1;
-  const positionInRange = (entryPrice - low) / range;
-  let levelType = 'middle';
-  if (positionInRange > 0.8) levelType = 'near_high';
-  else if (positionInRange < 0.2) levelType = 'near_low';
-  else if (positionInRange > 0.6) levelType = 'upper_middle';
-  else if (positionInRange < 0.4) levelType = 'lower_middle';
-  return {
-    positionInRange: Math.round(positionInRange * 100) / 100,
-    distanceToHigh: high - entryPrice,
-    distanceToLow: entryPrice - low,
-    recentHigh: high,
-    recentLow: low,
-    levelType
-  };
-};
-
-const determineLevelType = (price, ticks) => {
-  if (!ticks || ticks.length < 10) return 'unknown';
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 10) return 'unknown';
-  const high = Math.max(...prices);
-  const low = Math.min(...prices);
-  const tickSize = 0.25;
-  if (Math.abs(price - high) <= tickSize * 4) return 'resistance';
-  if (Math.abs(price - low) <= tickSize * 4) return 'support';
-  if (price > high) return 'breakout_high';
-  if (price < low) return 'breakout_low';
-  return 'middle';
-};
-
-const analyzePriceAction = (ticks) => {
-  if (!ticks || ticks.length < 2) return { trend: 'unknown', strength: 0 };
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 2) return { trend: 'unknown', strength: 0 };
-  const first = prices[0];
-  const last = prices[prices.length - 1];
-  const change = last - first;
-  const range = Math.max(...prices) - Math.min(...prices);
-  return {
-    trend: change > 0 ? 'up' : change < 0 ? 'down' : 'flat',
-    strength: range > 0 ? Math.abs(change) / range : 0,
-    range,
-    change
-  };
-};
-
-const analyzeVolume = (ticks) => {
-  if (!ticks || ticks.length === 0) return { total: 0, avg: 0, trend: 'unknown' };
-  const volumes = ticks.map(t => t.volume || 0);
-  const total = volumes.reduce((a, b) => a + b, 0);
-  const avg = total / volumes.length;
-  const mid = Math.floor(volumes.length / 2);
-  const firstHalf = volumes.slice(0, mid).reduce((a, b) => a + b, 0);
-  const secondHalf = volumes.slice(mid).reduce((a, b) => a + b, 0);
-  return {
-    total,
-    avg,
-    trend: secondHalf > firstHalf * 1.2 ? 'increasing' : secondHalf < firstHalf * 0.8 ? 'decreasing' : 'stable'
-  };
-};
-
-const calculateVolatility = (ticks) => {
-  if (!ticks || ticks.length < 2) return 0;
-  const prices = ticks.map(t => t.price).filter(Boolean);
-  if (prices.length < 2) return 0;
-  const returns = [];
-  for (let i = 1; i < prices.length; i++) {
-    returns.push((prices[i] - prices[i-1]) / prices[i-1]);
-  }
-  const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
-  const variance = returns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / returns.length;
-  return Math.sqrt(variance);
-};
-
-module.exports = {
-  calculateTrendStrength,
-  calculateRecentRange,
-  calculatePriceVelocity,
-  getMarketSession,
-  getMinutesSinceOpen,
-  analyzePriceLevelInteraction,
-  determineLevelType,
-  analyzePriceAction,
-  analyzeVolume,
-  calculateVolatility
-};

package/src/services/ai/supervisor.js

@@ -1,484 +0,0 @@
-/**
- * AI Supervisor
- * Manages AI supervision of algo trading
- * 
- * STRICT RULE: NO MOCK DATA, NO SIMULATION, NO ESTIMATION
- * All data comes from real APIs (ProjectX, Rithmic, Tradovate)
- */
-
-const { connections } = require('../session');
-const { analyzeTrading, analyzePerformance, getMarketAdvice: getMarketAdviceClient } = require('./client');
-const { feedTick: feedTickImpl, feedSignal: feedSignalImpl, feedTrade: feedTradeImpl, 
-        updatePosition: updatePositionImpl, updatePnL: updatePnLImpl, 
-        checkIntervention: checkInterventionImpl, getSyncStatus: getSyncStatusImpl } = require('./supervisor-sync');
-const { requestOptimization: requestOptimizationImpl, getMarketAdvice: getMarketAdviceImpl, 
-        applyOptimization: applyOptimizationImpl } = require('./supervisor-optimize');
-
-let aiService = null;
-
-// Lazy load to avoid circular dependency
-const getAIService = () => {
-  if (!aiService) {
-    aiService = require('./index');
-  }
-  return aiService;
-};
-
-// In-memory supervision sessions
-const supervisionSessions = new Map();
-
-// Consensus supervision interval
-let consensusInterval = null;
-
-/**
- * AI Supervisor Class
- * Uses REAL data from connected trading APIs
- */
-class AISupervisor {
-  /**
-   * Start supervision for an agent
-   */
-  static start(agentId, service, accountId) {
-    if (supervisionSessions.has(agentId)) {
-      return { success: false, error: 'Supervision already active' };
-    }
-    
-    const agentInfo = getAIService().getAgent(agentId);
-    if (!agentInfo) {
-      return { success: false, error: 'Agent not found' };
-    }
-    
-    if (!service || !accountId) {
-      return { success: false, error: 'Service and accountId required' };
-    }
-    
-    const session = {
-      agentId,
-      agent: agentInfo,
-      service,
-      accountId,
-      startTime: Date.now(),
-      lastCheck: Date.now(),
-      lastData: null,
-      decisions: [],
-      metrics: {
-        totalDecisions: 0,
-        interventions: 0,
-        optimizations: 0,
-        riskWarnings: 0
-      },
-      interval: null
-    };
-    
-    const currentSessionCount = supervisionSessions.size;
-    
-    if (currentSessionCount === 0) {
-      session.interval = setInterval(() => {
-        this.supervise(agentId);
-      }, 10000);
-      
-      supervisionSessions.set(agentId, session);
-      
-      return { 
-        success: true, 
-        message: `AI supervision started: ${agentInfo.name}`,
-        mode: 'single'
-      };
-      
-    } else {
-      this.switchToConsensusMode();
-      session.interval = null;
-      supervisionSessions.set(agentId, session);
-      
-      return { 
-        success: true, 
-        message: `Added ${agentInfo.name} to supervision`,
-        mode: 'consensus',
-        totalAgents: currentSessionCount + 1
-      };
-    }
-  }
-
-  /**
-   * Switch to consensus mode when multiple agents
-   */
-  static switchToConsensusMode() {
-    for (const [agentId, session] of supervisionSessions.entries()) {
-      if (session.interval) {
-        clearInterval(session.interval);
-        session.interval = null;
-      }
-    }
-    
-    if (!consensusInterval) {
-      consensusInterval = setInterval(() => {
-        this.superviseConsensus();
-      }, 10000);
-    }
-  }
-
-  /**
-   * Stop supervision for an agent
-   */
-  static stop(agentId) {
-    const session = supervisionSessions.get(agentId);
-    if (!session) {
-      return { success: false, error: 'Session not found' };
-    }
-    
-    if (session.interval) {
-      clearInterval(session.interval);
-    }
-    
-    const duration = Date.now() - session.startTime;
-    supervisionSessions.delete(agentId);
-    
-    const remainingSessions = supervisionSessions.size;
-    if (remainingSessions === 1 && consensusInterval) {
-      clearInterval(consensusInterval);
-      consensusInterval = null;
-      
-      const remainingSession = supervisionSessions.values().next().value;
-      if (remainingSession && !remainingSession.interval) {
-        const remainingAgentId = remainingSession.agentId;
-        remainingSession.interval = setInterval(() => {
-          this.supervise(remainingAgentId);
-        }, 10000);
-      }
-    } else if (remainingSessions === 0 && consensusInterval) {
-      clearInterval(consensusInterval);
-      consensusInterval = null;
-    }
-    
-    return { 
-      success: true, 
-      duration: Math.round(duration / 1000),
-      metrics: session.metrics
-    };
-  }
-  
-  /**
-   * Process AI decision and update session metrics
-   */
-  static processDecision(session, aiDecision, data, agentId = null) {
-    const decision = {
-      timestamp: Date.now(),
-      action: aiDecision.action || null,
-      confidence: aiDecision.confidence || null,
-      reason: aiDecision.reason || null,
-      dataSnapshot: {
-        balance: data.account?.balance ?? null,
-        pnl: data.account?.profitAndLoss ?? null,
-        positions: data.positions?.length ?? 0,
-        orders: data.orders?.length ?? 0
-      }
-    };
-    if (agentId) { decision.agentId = agentId; decision.agentName = session.agent.name; }
-    session.decisions.push(decision);
-    session.metrics.totalDecisions++;
-    if (aiDecision.action === 'REDUCE_SIZE' || aiDecision.action === 'PAUSE') session.metrics.interventions++;
-    else if (aiDecision.action === 'CONTINUE') session.metrics.optimizations++;
-    if (aiDecision.confidence !== null && aiDecision.confidence < 50) session.metrics.riskWarnings++;
-    if (session.decisions.length > 100) session.decisions = session.decisions.slice(-100);
-    return decision;
-  }
-
-  /** Main supervision loop - single agent */
-  static async supervise(agentId) {
-    const session = supervisionSessions.get(agentId);
-    if (!session) return;
-    try {
-      session.lastCheck = Date.now();
-      const data = await this.fetchRealData(session.service, session.accountId);
-      if (!data) return;
-      session.lastData = data;
-      session.metrics.lastFetch = Date.now();
-      const aiDecision = await analyzeTrading(session.agent, data);
-      if (aiDecision) this.processDecision(session, aiDecision, data);
-    } catch (error) { /* Silent fail */ }
-  }
-
-  /** Multi-agent consensus supervision loop */
-  static async superviseConsensus() {
-    const allSessions = Array.from(supervisionSessions.entries());
-    if (allSessions.length === 0) return;
-    try {
-      const decisions = [];
-      for (const [agentId, session] of allSessions) {
-        const data = await this.fetchRealData(session.service, session.accountId);
-        if (!data) continue;
-        session.lastData = data;
-        session.lastCheck = Date.now();
-        session.metrics.lastFetch = Date.now();
-        const aiDecision = await analyzeTrading(session.agent, data);
-        if (aiDecision) decisions.push(this.processDecision(session, aiDecision, data, agentId));
-      }
-      if (decisions.length > 1) this.calculateConsensus(decisions);
-    } catch (error) { /* Silent fail */ }
-  }
-  
-  /**
-   * Calculate consensus from multiple agent decisions
-   */
-  static calculateConsensus(decisions) {
-    if (!decisions || decisions.length === 0) return null;
-    
-    const votes = {};
-    let totalConfidence = 0;
-    let validConfidenceCount = 0;
-    
-    for (const decision of decisions) {
-      if (decision.action) {
-        votes[decision.action] = (votes[decision.action] || 0) + 1;
-      }
-      if (decision.confidence !== null) {
-        totalConfidence += decision.confidence;
-        validConfidenceCount++;
-      }
-    }
-    
-    let unanimousAction = null;
-    let isUnanimous = false;
-    
-    for (const [action, count] of Object.entries(votes)) {
-      if (count === decisions.length) {
-        unanimousAction = action;
-        isUnanimous = true;
-        break;
-      }
-    }
-    
-    const avgConfidence = validConfidenceCount > 0 
-      ? Math.round(totalConfidence / validConfidenceCount) 
-      : null;
-    
-    const consensus = {
-      timestamp: Date.now(),
-      action: isUnanimous ? unanimousAction : 'HOLD',
-      confidence: isUnanimous ? avgConfidence : null,
-      votes,
-      agentCount: decisions.length,
-      isUnanimous,
-      agreement: isUnanimous ? 1.0 : 0
-    };
-    
-    const firstSession = supervisionSessions.values().next().value;
-    if (firstSession) {
-      firstSession.lastConsensus = consensus;
-    }
-    
-    return consensus;
-  }
-
-  /**
-   * Fetch REAL data from trading API
-   */
-  static async fetchRealData(service, accountId) {
-    if (!service || !accountId) return null;
-    
-    const data = {
-      timestamp: Date.now(),
-      account: null,
-      positions: [],
-      orders: [],
-      trades: []
-    };
-    
-    try {
-      const accountResult = await service.getTradingAccounts();
-      if (accountResult.success && accountResult.accounts) {
-        data.account = accountResult.accounts.find(a => 
-          a.accountId === accountId || 
-          a.rithmicAccountId === accountId ||
-          String(a.accountId) === String(accountId)
-        );
-      }
-      
-      const posResult = await service.getPositions(accountId);
-      if (posResult.success && posResult.positions) {
-        data.positions = posResult.positions;
-      }
-      
-      const orderResult = await service.getOrders(accountId);
-      if (orderResult.success && orderResult.orders) {
-        data.orders = orderResult.orders;
-      }
-      
-      if (typeof service.getTrades === 'function') {
-        const tradesResult = await service.getTrades(accountId);
-        if (tradesResult.success && tradesResult.trades) {
-          data.trades = tradesResult.trades;
-        }
-      }
-      
-    } catch (error) {
-      return null;
-    }
-    
-    return data;
-  }
-
-  /**
-   * Get supervision status for an agent
-   */
-  static getStatus(agentId) {
-    const session = supervisionSessions.get(agentId);
-    if (!session) {
-      return { active: false };
-    }
-    
-    const duration = Date.now() - session.startTime;
-    return {
-      active: true,
-      agentId: session.agentId,
-      agentName: session.agent.name,
-      accountId: session.accountId,
-      duration,
-      lastCheck: session.lastCheck,
-      lastData: session.lastData,
-      metrics: session.metrics,
-      decisionsCount: session.decisions.length
-    };
-  }
-  
-  /**
-   * Get all active supervision sessions
-   */
-  static getAllStatus() {
-    const sessions = [];
-    const isConsensusMode = supervisionSessions.size > 1 && consensusInterval !== null;
-    
-    for (const [agentId, session] of supervisionSessions.entries()) {
-      sessions.push({
-        active: true,
-        agentId,
-        agentName: session.agent.name,
-        accountId: session.accountId,
-        duration: Date.now() - session.startTime,
-        lastCheck: session.lastCheck,
-        metrics: session.metrics,
-        mode: isConsensusMode ? 'consensus' : 'single'
-      });
-    }
-    
-    return sessions;
-  }
-  
-  /**
-   * Get aggregated data from all supervised accounts
-   */
-  static getAggregatedData() {
-    const result = {
-      totalAccounts: 0,
-      totalBalance: 0,
-      totalPnL: 0,
-      totalPositions: 0,
-      totalOrders: 0,
-      totalTrades: 0,
-      accounts: []
-    };
-    
-    for (const [agentId, session] of supervisionSessions.entries()) {
-      if (session.lastData) {
-        const data = session.lastData;
-        
-        if (data.account) {
-          result.totalAccounts++;
-          result.totalBalance += data.account.balance || 0;
-          result.totalPnL += data.account.profitAndLoss || 0;
-          result.accounts.push({
-            accountId: data.account.accountId,
-            accountName: data.account.accountName,
-            balance: data.account.balance,
-            pnl: data.account.profitAndLoss,
-            platform: data.account.platform
-          });
-        }
-        
-        result.totalPositions += data.positions?.length || 0;
-        result.totalOrders += data.orders?.length || 0;
-        result.totalTrades += data.trades?.length || 0;
-      }
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Get latest AI decision for an agent
-   */
-  static getLatestDecision(agentId) {
-    const session = supervisionSessions.get(agentId);
-    if (!session || session.decisions.length === 0) {
-      return null;
-    }
-    return session.decisions[session.decisions.length - 1];
-  }
-  
-  /**
-   * Get all decisions for an agent
-   */
-  static getDecisions(agentId, limit = 10) {
-    const session = supervisionSessions.get(agentId);
-    if (!session) {
-      return [];
-    }
-    return session.decisions.slice(-limit);
-  }
-  
-  /**
-   * Get latest consensus (multi-agent mode only)
-   */
-  static getConsensus() {
-    if (supervisionSessions.size <= 1) {
-      return null;
-    }
-    const firstSession = supervisionSessions.values().next().value;
-    return firstSession?.lastConsensus || null;
-  }
-  
-  /**
-   * Stop all supervision sessions
-   */
-  static stopAll() {
-    const results = [];
-    const agentIds = Array.from(supervisionSessions.keys());
-    
-    for (const agentId of agentIds) {
-      const result = this.stop(agentId);
-      results.push({ agentId, ...result });
-    }
-    
-    return results;
-  }
-  
-  /**
-   * Check if any supervision is active
-   */
-  static isActive() {
-    return supervisionSessions.size > 0;
-  }
-  
-  /**
-   * Get session count
-   */
-  static getSessionCount() {
-    return supervisionSessions.size;
-  }
-  
-  // Strategy sync methods (delegated to supervisor-sync.js)
-  static feedTick(tick) { feedTickImpl(supervisionSessions, tick); }
-  static feedSignal(signal) { feedSignalImpl(supervisionSessions, signal); }
-  static feedTrade(trade) { feedTradeImpl(supervisionSessions, trade); }
-  static updatePosition(position) { updatePositionImpl(supervisionSessions, position); }
-  static updatePnL(pnl, balance) { updatePnLImpl(supervisionSessions, pnl, balance); }
-  static checkIntervention() { return checkInterventionImpl(supervisionSessions, () => this.getConsensus()); }
-  static getSyncStatus() { return getSyncStatusImpl(supervisionSessions); }
-  
-  // Optimization methods (delegated to supervisor-optimize.js)
-  static async requestOptimization(performanceData) { return requestOptimizationImpl(supervisionSessions, performanceData); }
-  static async getMarketAdvice(marketData) { return getMarketAdviceImpl(supervisionSessions, marketData); }
-  static applyOptimization(strategy, optimization) { return applyOptimizationImpl(strategy, optimization); }
-}
-
-module.exports = AISupervisor;