hedgequantx 2.6.160 → 2.6.162

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

@@ -0,0 +1,195 @@
+/**
+ * Supervisor Data Management
+ * Handles persistence and data operations for AI learning
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DATA_DIR = path.join(os.homedir(), '.hqx');
+const LEARNING_FILE = path.join(DATA_DIR, 'ai-learning.json');
+
+const loadLearningData = () => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    if (fs.existsSync(LEARNING_FILE)) {
+      const data = JSON.parse(fs.readFileSync(LEARNING_FILE, 'utf8'));
+      const oneMonthAgo = Date.now() - (31 * 24 * 60 * 60 * 1000);
+      const sessions = (data.sessions || []).filter(s => 
+        new Date(s.date).getTime() > oneMonthAgo
+      );
+      return {
+        winningPatterns: data.winningPatterns || [],
+        losingPatterns: data.losingPatterns || [],
+        optimizations: data.optimizations || [],
+        symbols: data.symbols || {},
+        sessions,
+        hourlyStats: data.hourlyStats || {},
+        dayOfWeekStats: data.dayOfWeekStats || {},
+        strategyProfile: data.strategyProfile || {
+          bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null
+        },
+        totalSessions: data.totalSessions || 0,
+        totalTrades: data.totalTrades || 0,
+        totalWins: data.totalWins || 0,
+        totalLosses: data.totalLosses || 0,
+        lifetimePnL: data.lifetimePnL || 0,
+        lastUpdated: data.lastUpdated || null,
+        firstSession: data.firstSession || null
+      };
+    }
+  } catch (e) { /* Silent fail */ }
+  return {
+    winningPatterns: [], losingPatterns: [], optimizations: [], symbols: {}, sessions: [],
+    hourlyStats: {}, dayOfWeekStats: {},
+    strategyProfile: { bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null },
+    totalSessions: 0, totalTrades: 0, totalWins: 0, totalLosses: 0, lifetimePnL: 0,
+    lastUpdated: null, firstSession: null
+  };
+};
+
+const getSymbolData = (symbolName) => {
+  const data = loadLearningData();
+  if (!data.symbols[symbolName]) {
+    return {
+      name: symbolName, levels: { support: [], resistance: [] },
+      patterns: { winning: [], losing: [] }, stats: { trades: 0, wins: 0, avgWin: 0, avgLoss: 0 }
+    };
+  }
+  return data.symbols[symbolName];
+};
+
+const recordPriceLevel = (symbolName, price, type, outcome) => {
+  const data = loadLearningData();
+  if (!data.symbols[symbolName]) {
+    data.symbols[symbolName] = {
+      name: symbolName, levels: { support: [], resistance: [] },
+      patterns: { winning: [], losing: [] }, stats: { trades: 0, wins: 0, avgWin: 0, avgLoss: 0 }
+    };
+  }
+  const symbol = data.symbols[symbolName];
+  const levelKey = type === 'support' ? 'support' : 'resistance';
+  const existingLevel = symbol.levels[levelKey].find(l => Math.abs(l.price - price) <= 0.5);
+  if (existingLevel) {
+    existingLevel.touches++;
+    existingLevel.lastTouched = Date.now();
+    if (outcome === 'held') existingLevel.held++;
+    else existingLevel.broken++;
+  } else {
+    symbol.levels[levelKey].push({
+      price, touches: 1, held: outcome === 'held' ? 1 : 0,
+      broken: outcome === 'broken' ? 1 : 0, firstSeen: Date.now(), lastTouched: Date.now()
+    });
+  }
+  symbol.levels[levelKey].sort((a, b) => b.touches - a.touches);
+  if (symbol.levels[levelKey].length > 20) {
+    symbol.levels[levelKey] = symbol.levels[levelKey].slice(0, 20);
+  }
+  saveLearningData(data);
+};
+
+const analyzeNearbyLevels = (symbolName, currentPrice) => {
+  const symbolData = getSymbolData(symbolName);
+  const nearby = { support: [], resistance: [] };
+  const range = 10;
+  symbolData.levels.support.forEach(level => {
+    if (Math.abs(level.price - currentPrice) <= range) {
+      nearby.support.push({ ...level, distance: currentPrice - level.price });
+    }
+  });
+  symbolData.levels.resistance.forEach(level => {
+    if (Math.abs(level.price - currentPrice) <= range) {
+      nearby.resistance.push({ ...level, distance: level.price - currentPrice });
+    }
+  });
+  nearby.support.sort((a, b) => a.distance - b.distance);
+  nearby.resistance.sort((a, b) => a.distance - b.distance);
+  return nearby;
+};
+
+const saveLearningData = (data) => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    data.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(LEARNING_FILE, JSON.stringify(data, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const buildStrategyProfile = (hourlyStats, dayOfWeekStats, sessions) => {
+  const profile = { bestHours: [], worstHours: [], avgWinStreak: 0, avgLossStreak: 0, preferredConditions: null };
+  const hourlyArray = Object.entries(hourlyStats)
+    .filter(([_, stats]) => stats.trades >= 5)
+    .map(([hour, stats]) => ({ hour: parseInt(hour), winRate: stats.wins / stats.trades, trades: stats.trades, pnl: stats.pnl }));
+  hourlyArray.sort((a, b) => b.winRate - a.winRate);
+  profile.bestHours = hourlyArray.slice(0, 3).map(h => ({ hour: h.hour, winRate: Math.round(h.winRate * 100) }));
+  profile.worstHours = hourlyArray.slice(-3).reverse().map(h => ({ hour: h.hour, winRate: Math.round(h.winRate * 100) }));
+  if (sessions.length >= 5) {
+    const winStreaks = sessions.map(s => s.maxWinStreak || 0).filter(Boolean);
+    const lossStreaks = sessions.map(s => s.maxLossStreak || 0).filter(Boolean);
+    profile.avgWinStreak = winStreaks.length > 0 ? winStreaks.reduce((a, b) => a + b, 0) / winStreaks.length : 0;
+    profile.avgLossStreak = lossStreaks.length > 0 ? lossStreaks.reduce((a, b) => a + b, 0) / lossStreaks.length : 0;
+  }
+  return profile;
+};
+
+const mergePatterns = (existing, current, maxCount) => {
+  const merged = [...existing];
+  current.forEach(pattern => {
+    const similar = merged.find(p => p.timeContext?.hour === pattern.timeContext?.hour && p.direction === pattern.direction);
+    if (!similar) merged.push(pattern);
+  });
+  merged.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  return merged.slice(0, maxCount);
+};
+
+const mergeLevels = (existing, current, maxCount) => {
+  const merged = [...existing];
+  current.forEach(level => {
+    const similar = merged.find(l => Math.abs(l.price - level.price) <= 0.5);
+    if (similar) {
+      similar.touches += level.touches || 1;
+      similar.held += level.held || 0;
+      similar.broken += level.broken || 0;
+      similar.lastTouched = Math.max(similar.lastTouched || 0, level.lastTouched || Date.now());
+    } else {
+      merged.push(level);
+    }
+  });
+  merged.sort((a, b) => b.touches - a.touches);
+  return merged.slice(0, maxCount);
+};
+
+const clearLearningData = () => {
+  try {
+    if (fs.existsSync(LEARNING_FILE)) {
+      fs.unlinkSync(LEARNING_FILE);
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+module.exports = {
+  DATA_DIR,
+  LEARNING_FILE,
+  loadLearningData,
+  getSymbolData,
+  recordPriceLevel,
+  analyzeNearbyLevels,
+  saveLearningData,
+  buildStrategyProfile,
+  mergePatterns,
+  mergeLevels,
+  clearLearningData
+};

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

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview AI Supervisor - Optimization & Market Advice
+ * 
+ * Methods for AI-driven strategy optimization and market analysis
+ * In CONSENSUS mode, only unanimous suggestions are applied
+ */
+
+const { analyzePerformance, getMarketAdvice: getMarketAdviceFromClient } = require('./client');
+
+/**
+ * Request strategy optimization from all agents
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} performanceData - Strategy performance data
+ * @returns {Promise<Object|null>} Optimization suggestions
+ */
+const requestOptimization = async (supervisionSessions, performanceData) => {
+  if (supervisionSessions.size === 0) return null;
+  
+  const allSessions = Array.from(supervisionSessions.values());
+  const suggestions = [];
+  
+  // Get optimization suggestions from each agent
+  for (const session of allSessions) {
+    try {
+      const suggestion = await analyzePerformance(session.agent, performanceData);
+      if (suggestion) {
+        suggestions.push({
+          agentId: session.agentId,
+          agentName: session.agent.name,
+          ...suggestion
+        });
+      }
+    } catch (e) {
+      // Silent fail for individual agent
+    }
+  }
+  
+  if (suggestions.length === 0) return null;
+  
+  // If single agent, return its suggestion
+  if (suggestions.length === 1) {
+    return {
+      mode: 'INDIVIDUAL',
+      ...suggestions[0]
+    };
+  }
+  
+  // CONSENSUS MODE: Find common optimizations
+  const consensusOptimizations = [];
+  const allOptimizations = suggestions.flatMap(s => s.optimizations || []);
+  
+  // Group by parameter name
+  const paramGroups = {};
+  for (const opt of allOptimizations) {
+    if (!opt.param) continue;
+    if (!paramGroups[opt.param]) {
+      paramGroups[opt.param] = [];
+    }
+    paramGroups[opt.param].push(opt);
+  }
+  
+  // Find unanimous suggestions (all agents agree on direction)
+  for (const [param, opts] of Object.entries(paramGroups)) {
+    if (opts.length === suggestions.length) {
+      // All agents suggested this param - check if they agree on direction
+      const directions = opts.map(o => {
+        const current = parseFloat(o.current) || 0;
+        const suggested = parseFloat(o.suggested) || 0;
+        return suggested > current ? 'increase' : suggested < current ? 'decrease' : 'same';
+      });
+      
+      const allSame = directions.every(d => d === directions[0]);
+      if (allSame && directions[0] !== 'same') {
+        // Unanimous - use average of suggested values
+        const avgSuggested = opts.reduce((sum, o) => sum + (parseFloat(o.suggested) || 0), 0) / opts.length;
+        consensusOptimizations.push({
+          param,
+          current: opts[0].current,
+          suggested: avgSuggested.toFixed(2),
+          reason: `Unanimous (${suggestions.length} agents agree)`,
+          direction: directions[0]
+        });
+      }
+    }
+  }
+  
+  // Calculate average confidence
+  const avgConfidence = Math.round(
+    suggestions.reduce((sum, s) => sum + (s.confidence || 0), 0) / suggestions.length
+  );
+  
+  // Determine consensus market condition
+  const conditions = suggestions.map(s => s.marketCondition).filter(Boolean);
+  const conditionCounts = {};
+  for (const c of conditions) {
+    conditionCounts[c] = (conditionCounts[c] || 0) + 1;
+  }
+  const consensusCondition = Object.entries(conditionCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
+  
+  return {
+    mode: 'CONSENSUS',
+    agentCount: suggestions.length,
+    isUnanimous: consensusOptimizations.length > 0,
+    optimizations: consensusOptimizations,
+    marketCondition: consensusCondition,
+    confidence: avgConfidence,
+    individualSuggestions: suggestions
+  };
+};
+
+/**
+ * Get real-time market advice from all agents
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} marketData - Current market data
+ * @returns {Promise<Object|null>} Market advice (consensus)
+ */
+const getMarketAdvice = async (supervisionSessions, marketData) => {
+  if (supervisionSessions.size === 0) return null;
+  
+  const allSessions = Array.from(supervisionSessions.values());
+  const advices = [];
+  
+  // Get advice from each agent
+  for (const session of allSessions) {
+    try {
+      const advice = await getMarketAdviceFromClient(session.agent, marketData);
+      if (advice) {
+        advices.push({
+          agentId: session.agentId,
+          agentName: session.agent.name,
+          ...advice
+        });
+      }
+    } catch (e) {
+      // Silent fail
+    }
+  }
+  
+  if (advices.length === 0) return null;
+  
+  // Single agent
+  if (advices.length === 1) {
+    return {
+      mode: 'INDIVIDUAL',
+      ...advices[0]
+    };
+  }
+  
+  // CONSENSUS: All agents must agree on action
+  const actions = advices.map(a => a.action);
+  const allSameAction = actions.every(a => a === actions[0]);
+  
+  if (allSameAction) {
+    // Unanimous action - average the size multiplier
+    const avgMultiplier = advices.reduce((sum, a) => sum + (a.sizeMultiplier || 1), 0) / advices.length;
+    const avgConfidence = Math.round(advices.reduce((sum, a) => sum + (a.confidence || 0), 0) / advices.length);
+    
+    return {
+      mode: 'CONSENSUS',
+      isUnanimous: true,
+      action: actions[0],
+      sizeMultiplier: Math.round(avgMultiplier * 100) / 100,
+      confidence: avgConfidence,
+      reason: `${advices.length} agents unanimous`,
+      agentCount: advices.length
+    };
+  } else {
+    // Agents disagree - be conservative
+    return {
+      mode: 'CONSENSUS',
+      isUnanimous: false,
+      action: 'CAUTIOUS',
+      sizeMultiplier: 0.5,
+      confidence: 0,
+      reason: 'Agents disagree - reducing exposure',
+      agentCount: advices.length,
+      votes: actions.reduce((acc, a) => { acc[a] = (acc[a] || 0) + 1; return acc; }, {})
+    };
+  }
+};
+
+/**
+ * Apply optimization to strategy
+ * @param {Object} strategy - Strategy instance
+ * @param {Object} optimization - Optimization to apply
+ * @returns {boolean} Success
+ */
+const applyOptimization = (strategy, optimization) => {
+  if (!strategy || !optimization) return false;
+  
+  try {
+    // Check if strategy has optimization method
+    if (typeof strategy.applyOptimization === 'function') {
+      strategy.applyOptimization(optimization);
+      return true;
+    }
+    
+    // Fallback: try to set individual parameters
+    if (typeof strategy.setParameter === 'function' && optimization.param) {
+      strategy.setParameter(optimization.param, optimization.suggested);
+      return true;
+    }
+    
+    return false;
+  } catch (e) {
+    return false;
+  }
+};
+
+module.exports = {
+  requestOptimization,
+  getMarketAdvice,
+  applyOptimization,
+};

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

@@ -0,0 +1,178 @@
+/**
+ * @fileoverview AI Supervisor - Strategy Sync
+ * 
+ * Methods to sync AI supervision with trading strategy in real-time
+ * Agents receive the same data as the strategy
+ */
+
+/**
+ * Feed market tick to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} tick - Market tick { price, bid, ask, volume, timestamp }
+ */
+const feedTick = (supervisionSessions, tick) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.marketData) {
+      session.marketData = { ticks: [], lastTick: null };
+    }
+    session.marketData.lastTick = tick;
+    session.marketData.ticks.push(tick);
+    
+    // Keep only last 1000 ticks to prevent memory bloat
+    if (session.marketData.ticks.length > 1000) {
+      session.marketData.ticks = session.marketData.ticks.slice(-1000);
+    }
+  }
+};
+
+/**
+ * Feed strategy signal to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} signal - Strategy signal
+ */
+const feedSignal = (supervisionSessions, signal) => {
+  if (supervisionSessions.size === 0) return;
+  
+  const signalData = {
+    timestamp: Date.now(),
+    direction: signal.direction,
+    entry: signal.entry,
+    stopLoss: signal.stopLoss,
+    takeProfit: signal.takeProfit,
+    confidence: signal.confidence
+  };
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.signals) {
+      session.signals = [];
+    }
+    session.signals.push(signalData);
+    
+    // Keep only last 100 signals
+    if (session.signals.length > 100) {
+      session.signals = session.signals.slice(-100);
+    }
+  }
+};
+
+/**
+ * Feed trade execution to all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} trade - Trade data
+ */
+const feedTrade = (supervisionSessions, trade) => {
+  if (supervisionSessions.size === 0) return;
+  
+  const tradeData = {
+    timestamp: Date.now(),
+    side: trade.side,
+    qty: trade.qty,
+    price: trade.price,
+    pnl: trade.pnl,
+    symbol: trade.symbol
+  };
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    if (!session.trades) {
+      session.trades = [];
+    }
+    session.trades.push(tradeData);
+  }
+};
+
+/**
+ * Update current position for all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Object} position - Position data
+ */
+const updatePosition = (supervisionSessions, position) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    session.currentPosition = {
+      timestamp: Date.now(),
+      qty: position.qty,
+      side: position.side,
+      entryPrice: position.entryPrice,
+      pnl: position.pnl
+    };
+  }
+};
+
+/**
+ * Update P&L for all sessions
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {number} pnl - Current session P&L
+ * @param {number} balance - Account balance
+ */
+const updatePnL = (supervisionSessions, pnl, balance) => {
+  if (supervisionSessions.size === 0) return;
+  
+  for (const [agentId, session] of supervisionSessions.entries()) {
+    session.currentPnL = pnl;
+    session.currentBalance = balance;
+  }
+};
+
+/**
+ * Check if agents recommend intervention
+ * @param {Map} supervisionSessions - Sessions map
+ * @param {Function} getConsensus - Function to get consensus
+ * @returns {Object} Intervention check result
+ */
+const checkIntervention = (supervisionSessions, getConsensus) => {
+  if (supervisionSessions.size === 0) {
+    return { shouldContinue: true, action: 'CONTINUE', reason: 'No AI supervision active' };
+  }
+  
+  const consensus = getConsensus();
+  
+  if (consensus && consensus.isUnanimous) {
+    if (consensus.action === 'PAUSE' || consensus.action === 'STOP') {
+      return { shouldContinue: false, action: consensus.action, reason: 'AI agents recommend pause' };
+    }
+    if (consensus.action === 'REDUCE_SIZE') {
+      return { shouldContinue: true, action: 'REDUCE_SIZE', reason: 'AI agents recommend reducing size' };
+    }
+  } else if (consensus && !consensus.isUnanimous) {
+    return { shouldContinue: false, action: 'HOLD', reason: 'AI agents disagree - waiting for consensus' };
+  }
+  
+  return { shouldContinue: true, action: 'CONTINUE', reason: 'AI supervision active' };
+};
+
+/**
+ * Get real-time sync status
+ * @param {Map} supervisionSessions - Sessions map
+ * @returns {Object} Sync status
+ */
+const getSyncStatus = (supervisionSessions) => {
+  if (supervisionSessions.size === 0) {
+    return { synced: false, agents: 0 };
+  }
+  
+  const firstSession = supervisionSessions.values().next().value;
+  
+  return {
+    synced: true,
+    agents: supervisionSessions.size,
+    lastTick: firstSession?.marketData?.lastTick?.timestamp || null,
+    tickCount: firstSession?.marketData?.ticks?.length || 0,
+    signalCount: firstSession?.signals?.length || 0,
+    tradeCount: firstSession?.trades?.length || 0,
+    currentPnL: firstSession?.currentPnL || 0,
+    currentPosition: firstSession?.currentPosition || null
+  };
+};
+
+module.exports = {
+  feedTick,
+  feedSignal,
+  feedTrade,
+  updatePosition,
+  updatePnL,
+  checkIntervention,
+  getSyncStatus,
+};