hedgequantx 2.6.162 → 2.7.0

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

@@ -1,195 +0,0 @@
-/**
- * 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

@@ -1,215 +0,0 @@
-/**
- * @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

@@ -1,178 +0,0 @@
-/**
- * @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,
-};