hedgequantx 2.9.18 → 2.9.20

package/src/services/ai-supervision/consensus.js

@@ -1,284 +0,0 @@
-/**
- * Consensus Calculator for Multi-Agent Supervision
- * 
- * Calculates weighted consensus from multiple AI agent responses.
- * Each agent has a weight, and the final decision is based on
- * the weighted average of all responses.
- */
-
-/**
- * Default consensus when no valid responses
- */
-const DEFAULT_CONSENSUS = {
-  decision: 'approve',
-  confidence: 50,
-  optimizations: null,
-  reason: 'No consensus - default approve',
-  alerts: [],
-  agentCount: 0,
-  respondedCount: 0,
-  unanimous: false
-};
-
-/**
- * Calculate weighted average of a numeric field
- */
-const weightedAverage = (values, weights) => {
-  if (values.length === 0) return 0;
-  
-  let sum = 0;
-  let totalWeight = 0;
-  
-  for (let i = 0; i < values.length; i++) {
-    const val = values[i];
-    const weight = weights[i] || 1;
-    if (val !== null && val !== undefined && !isNaN(val)) {
-      sum += val * weight;
-      totalWeight += weight;
-    }
-  }
-  
-  return totalWeight > 0 ? sum / totalWeight : 0;
-};
-
-/**
- * Calculate weighted mode (most common value by weight)
- */
-const weightedMode = (values, weights) => {
-  if (values.length === 0) return null;
-  
-  const weightMap = {};
-  
-  for (let i = 0; i < values.length; i++) {
-    const val = values[i];
-    const weight = weights[i] || 1;
-    if (val !== null && val !== undefined) {
-      weightMap[val] = (weightMap[val] || 0) + weight;
-    }
-  }
-  
-  let maxWeight = 0;
-  let mode = null;
-  
-  for (const [val, w] of Object.entries(weightMap)) {
-    if (w > maxWeight) {
-      maxWeight = w;
-      mode = val;
-    }
-  }
-  
-  return mode;
-};
-
-/**
- * Merge optimizations from multiple agents
- */
-const mergeOptimizations = (responses, weights) => {
-  const validOpts = responses
-    .map((r, i) => ({ opt: r.optimizations, weight: weights[i] }))
-    .filter(o => o.opt !== null);
-  
-  if (validOpts.length === 0) return null;
-  
-  // Collect values for each field
-  const entries = validOpts.filter(o => o.opt.entry !== null).map(o => ({ val: o.opt.entry, w: o.weight }));
-  const stops = validOpts.filter(o => o.opt.stopLoss !== null).map(o => ({ val: o.opt.stopLoss, w: o.weight }));
-  const targets = validOpts.filter(o => o.opt.takeProfit !== null).map(o => ({ val: o.opt.takeProfit, w: o.weight }));
-  const sizes = validOpts.filter(o => o.opt.size !== null).map(o => ({ val: o.opt.size, w: o.weight }));
-  const timings = validOpts.map(o => ({ val: o.opt.timing, w: o.weight }));
-
-  return {
-    entry: entries.length > 0 
-      ? Math.round(weightedAverage(entries.map(e => e.val), entries.map(e => e.w)) * 100) / 100 
-      : null,
-    stopLoss: stops.length > 0 
-      ? Math.round(weightedAverage(stops.map(s => s.val), stops.map(s => s.w)) * 100) / 100 
-      : null,
-    takeProfit: targets.length > 0 
-      ? Math.round(weightedAverage(targets.map(t => t.val), targets.map(t => t.w)) * 100) / 100 
-      : null,
-    size: sizes.length > 0 
-      ? Math.round(weightedAverage(sizes.map(s => s.val), sizes.map(s => s.w)) * 100) / 100 
-      : null,
-    timing: weightedMode(timings.map(t => t.val), timings.map(t => t.w)) || 'now'
-  };
-};
-
-/**
- * Collect all alerts from responses
- */
-const collectAlerts = (responses) => {
-  const alerts = [];
-  for (const r of responses) {
-    if (r.alerts && Array.isArray(r.alerts)) {
-      alerts.push(...r.alerts);
-    }
-  }
-  return [...new Set(alerts)].slice(0, 10);
-};
-
-/**
- * Build reason summary from all responses
- */
-const buildReasonSummary = (responses, decision) => {
-  const reasons = responses
-    .filter(r => r.decision === decision && r.reason)
-    .map(r => r.reason)
-    .slice(0, 3);
-  
-  if (reasons.length === 0) return `Consensus: ${decision}`;
-  if (reasons.length === 1) return reasons[0];
-  
-  return reasons[0] + (reasons.length > 1 ? ` (+${reasons.length - 1} more)` : '');
-};
-
-/**
- * Calculate consensus from multiple agent responses
- * 
- * @param {Array} agentResponses - Array of { agentId, response, weight }
- * @param {Object} options - Consensus options
- * @returns {Object} Consensus result
- */
-const calculateConsensus = (agentResponses, options = {}) => {
-  const {
-    minAgents = 1,
-    approveThreshold = 0.5,
-    rejectThreshold = 0.6,
-    minConfidence = 30
-  } = options;
-
-  // Filter valid responses
-  const validResponses = agentResponses.filter(ar => 
-    ar && ar.response && ar.response.decision
-  );
-
-  if (validResponses.length === 0) {
-    return { ...DEFAULT_CONSENSUS, reason: 'No valid agent responses' };
-  }
-
-  if (validResponses.length < minAgents) {
-    return { 
-      ...DEFAULT_CONSENSUS, 
-      reason: `Insufficient agents (${validResponses.length}/${minAgents})`,
-      agentCount: agentResponses.length,
-      respondedCount: validResponses.length
-    };
-  }
-
-  // Extract responses and weights
-  const responses = validResponses.map(ar => ar.response);
-  const weights = validResponses.map(ar => ar.weight || 100);
-  const totalWeight = weights.reduce((a, b) => a + b, 0);
-
-  // Calculate weighted votes for each decision
-  const votes = { approve: 0, reject: 0, modify: 0 };
-  for (let i = 0; i < responses.length; i++) {
-    const decision = responses[i].decision;
-    votes[decision] = (votes[decision] || 0) + weights[i];
-  }
-
-  // Normalize votes to percentages
-  const approveRatio = votes.approve / totalWeight;
-  const rejectRatio = votes.reject / totalWeight;
-  const modifyRatio = votes.modify / totalWeight;
-
-  // Determine consensus decision
-  let decision;
-  if (rejectRatio >= rejectThreshold) {
-    decision = 'reject';
-  } else if (approveRatio >= approveThreshold) {
-    decision = modifyRatio > 0 ? 'modify' : 'approve';
-  } else if (modifyRatio > approveRatio) {
-    decision = 'modify';
-  } else {
-    decision = 'approve';
-  }
-
-  // Calculate weighted confidence
-  const confidences = responses.map(r => r.confidence);
-  const avgConfidence = Math.round(weightedAverage(confidences, weights));
-
-  // Apply minimum confidence check
-  if (avgConfidence < minConfidence && decision !== 'reject') {
-    decision = 'reject';
-  }
-
-  // Check unanimity
-  const decisions = responses.map(r => r.decision);
-  const unanimous = new Set(decisions).size === 1;
-
-  // Build consensus result
-  const consensus = {
-    decision,
-    confidence: avgConfidence,
-    optimizations: decision !== 'reject' ? mergeOptimizations(responses, weights) : null,
-    reason: buildReasonSummary(responses, decision),
-    alerts: collectAlerts(responses),
-    
-    // Metadata
-    agentCount: agentResponses.length,
-    respondedCount: validResponses.length,
-    unanimous,
-    
-    // Vote breakdown
-    votes: {
-      approve: Math.round(approveRatio * 100),
-      reject: Math.round(rejectRatio * 100),
-      modify: Math.round(modifyRatio * 100)
-    },
-    
-    // Individual responses for debugging
-    agentDetails: validResponses.map(ar => ({
-      agentId: ar.agentId,
-      decision: ar.response.decision,
-      confidence: ar.response.confidence,
-      weight: ar.weight
-    }))
-  };
-
-  return consensus;
-};
-
-/**
- * Quick check if consensus approves the signal
- */
-const isApproved = (consensus) => {
-  return consensus.decision === 'approve' || consensus.decision === 'modify';
-};
-
-/**
- * Apply consensus optimizations to original signal
- */
-const applyOptimizations = (signal, consensus) => {
-  if (!isApproved(consensus) || !consensus.optimizations) {
-    return signal;
-  }
-
-  const opts = consensus.optimizations;
-  const optimized = { ...signal };
-
-  if (opts.entry !== null) optimized.entry = opts.entry;
-  if (opts.stopLoss !== null) optimized.stopLoss = opts.stopLoss;
-  if (opts.takeProfit !== null) optimized.takeProfit = opts.takeProfit;
-  
-  // Apply size adjustment
-  if (opts.size !== null && signal.size) {
-    optimized.size = Math.max(1, Math.round(signal.size * (1 + opts.size)));
-  }
-
-  optimized.aiOptimized = true;
-  optimized.aiConfidence = consensus.confidence;
-  optimized.aiTiming = opts.timing;
-
-  return optimized;
-};
-
-module.exports = {
-  calculateConsensus,
-  isApproved,
-  applyOptimizations,
-  weightedAverage,
-  weightedMode,
-  mergeOptimizations,
-  DEFAULT_CONSENSUS
-};

package/src/services/ai-supervision/context.js

@@ -1,275 +0,0 @@
-/**
- * Context Builder for AI Supervision
- * 
- * Builds the market context from real Rithmic data
- * to send to AI agents for signal analysis.
- */
-
-const { getSymbol, getCurrentSession, isGoodSessionForSymbol } = require('./symbols');
-
-/**
- * Build DOM (Depth of Market) summary from raw data
- */
-const buildDOMSummary = (domData) => {
-  if (!domData || !domData.bids || !domData.asks) {
-    return { available: false };
-  }
-
-  const bids = domData.bids.slice(0, 10);
-  const asks = domData.asks.slice(0, 10);
-  
-  const totalBidSize = bids.reduce((sum, b) => sum + (b.size || 0), 0);
-  const totalAskSize = asks.reduce((sum, a) => sum + (a.size || 0), 0);
-  const imbalance = totalBidSize - totalAskSize;
-  const imbalanceRatio = totalAskSize > 0 ? totalBidSize / totalAskSize : 1;
-
-  return {
-    available: true,
-    topBid: bids[0]?.price || null,
-    topAsk: asks[0]?.price || null,
-    spread: asks[0] && bids[0] ? asks[0].price - bids[0].price : null,
-    totalBidSize,
-    totalAskSize,
-    imbalance,
-    imbalanceRatio: Math.round(imbalanceRatio * 100) / 100,
-    bidLevels: bids.length,
-    askLevels: asks.length,
-    dominantSide: imbalance > 0 ? 'buyers' : imbalance < 0 ? 'sellers' : 'neutral'
-  };
-};
-
-/**
- * Build Order Flow summary from recent ticks
- */
-const buildOrderFlowSummary = (recentTicks, windowSize = 50) => {
-  if (!recentTicks || recentTicks.length === 0) {
-    return { available: false };
-  }
-
-  const ticks = recentTicks.slice(-windowSize);
-  
-  let buyVolume = 0;
-  let sellVolume = 0;
-  let totalVolume = 0;
-  let highPrice = -Infinity;
-  let lowPrice = Infinity;
-
-  for (const tick of ticks) {
-    const vol = tick.volume || 1;
-    totalVolume += vol;
-    
-    if (tick.side === 'buy' || tick.lastTradeSide === 'buy') {
-      buyVolume += vol;
-    } else if (tick.side === 'sell' || tick.lastTradeSide === 'sell') {
-      sellVolume += vol;
-    }
-    
-    if (tick.price > highPrice) highPrice = tick.price;
-    if (tick.price < lowPrice) lowPrice = tick.price;
-  }
-
-  const delta = buyVolume - sellVolume;
-  const deltaPercent = totalVolume > 0 ? (delta / totalVolume) * 100 : 0;
-
-  return {
-    available: true,
-    tickCount: ticks.length,
-    totalVolume,
-    buyVolume,
-    sellVolume,
-    delta,
-    deltaPercent: Math.round(deltaPercent),
-    highPrice: highPrice === -Infinity ? null : highPrice,
-    lowPrice: lowPrice === Infinity ? null : lowPrice,
-    range: highPrice !== -Infinity && lowPrice !== Infinity ? highPrice - lowPrice : null,
-    lastPrice: ticks[ticks.length - 1]?.price || null,
-    trend: delta > 0 ? 'bullish' : delta < 0 ? 'bearish' : 'neutral'
-  };
-};
-
-/**
- * Build trade history summary from recent signals/trades
- */
-const buildTradeHistory = (recentSignals, recentTrades) => {
-  const signals = recentSignals || [];
-  const trades = recentTrades || [];
-
-  const wins = trades.filter(t => t.pnl > 0).length;
-  const losses = trades.filter(t => t.pnl < 0).length;
-  const totalTrades = wins + losses;
-  const winRate = totalTrades > 0 ? (wins / totalTrades) * 100 : 0;
-
-  const totalPnL = trades.reduce((sum, t) => sum + (t.pnl || 0), 0);
-  const avgWin = wins > 0 ? trades.filter(t => t.pnl > 0).reduce((s, t) => s + t.pnl, 0) / wins : 0;
-  const avgLoss = losses > 0 ? Math.abs(trades.filter(t => t.pnl < 0).reduce((s, t) => s + t.pnl, 0) / losses) : 0;
-
-  return {
-    recentSignals: signals.length,
-    totalTrades,
-    wins,
-    losses,
-    winRate: Math.round(winRate),
-    totalPnL: Math.round(totalPnL * 100) / 100,
-    avgWin: Math.round(avgWin * 100) / 100,
-    avgLoss: Math.round(avgLoss * 100) / 100,
-    profitFactor: avgLoss > 0 ? Math.round((avgWin / avgLoss) * 100) / 100 : 0
-  };
-};
-
-/**
- * Build current position info
- */
-const buildPositionInfo = (position, currentPrice) => {
-  if (!position || position.quantity === 0) {
-    return { hasPosition: false, quantity: 0 };
-  }
-
-  const qty = position.quantity;
-  const entryPrice = position.averagePrice || position.entryPrice;
-  const unrealizedPnL = position.profitAndLoss || 0;
-  const side = qty > 0 ? 'long' : 'short';
-
-  return {
-    hasPosition: true,
-    side,
-    quantity: Math.abs(qty),
-    entryPrice,
-    currentPrice,
-    unrealizedPnL: Math.round(unrealizedPnL * 100) / 100,
-    ticksInProfit: entryPrice && currentPrice 
-      ? Math.round((side === 'long' ? currentPrice - entryPrice : entryPrice - currentPrice) * 4)
-      : 0
-  };
-};
-
-/**
- * Build complete market context for AI analysis
- */
-const buildMarketContext = ({
-  symbolId,
-  signal,
-  recentTicks = [],
-  recentSignals = [],
-  recentTrades = [],
-  domData = null,
-  position = null,
-  stats = {},
-  config = {}
-}) => {
-  const symbol = getSymbol(symbolId);
-  const session = getCurrentSession();
-  const sessionCheck = isGoodSessionForSymbol(symbolId);
-  const orderFlow = buildOrderFlowSummary(recentTicks);
-  const dom = buildDOMSummary(domData);
-  const history = buildTradeHistory(recentSignals, recentTrades);
-  const positionInfo = buildPositionInfo(position, orderFlow.lastPrice);
-
-  return {
-    timestamp: new Date().toISOString(),
-    
-    // Symbol info
-    symbol: {
-      id: symbolId,
-      name: symbol?.name || symbolId,
-      tickSize: symbol?.tickSize || 0.25,
-      tickValue: symbol?.tickValue || 12.50,
-      characteristics: symbol?.characteristics || {},
-      correlations: symbol?.correlations || {}
-    },
-    
-    // Current session
-    session: {
-      name: session.name,
-      description: session.description,
-      isGoodTime: sessionCheck.good,
-      sessionNote: sessionCheck.reason
-    },
-    
-    // The signal to analyze
-    signal: {
-      direction: signal.direction,
-      entry: signal.entry,
-      stopLoss: signal.stopLoss,
-      takeProfit: signal.takeProfit,
-      confidence: signal.confidence,
-      pattern: signal.pattern || 'unknown',
-      timestamp: signal.timestamp || Date.now()
-    },
-    
-    // Market data
-    orderFlow,
-    dom,
-    
-    // Position and history
-    position: positionInfo,
-    history,
-    
-    // Session stats
-    sessionStats: {
-      pnl: stats.pnl || 0,
-      trades: stats.trades || 0,
-      wins: stats.wins || 0,
-      losses: stats.losses || 0,
-      target: config.dailyTarget || stats.target || 500,
-      maxRisk: config.maxRisk || stats.risk || 300,
-      progressToTarget: stats.pnl && config.dailyTarget 
-        ? Math.round((stats.pnl / config.dailyTarget) * 100) 
-        : 0
-    }
-  };
-};
-
-/**
- * Format context as a string for AI prompt
- */
-const formatContextForPrompt = (context) => {
-  return `
-## MARKET CONTEXT
-
-**Symbol**: ${context.symbol.name} (${context.symbol.id})
-**Tick Size**: ${context.symbol.tickSize} | **Tick Value**: $${context.symbol.tickValue}
-**Session**: ${context.session.description} ${context.session.isGoodTime ? '✓' : '⚠'}
-
-### SIGNAL TO ANALYZE
-- Direction: ${context.signal.direction.toUpperCase()}
-- Entry: ${context.signal.entry}
-- Stop Loss: ${context.signal.stopLoss}
-- Take Profit: ${context.signal.takeProfit}
-- Strategy Confidence: ${Math.round(context.signal.confidence * 100)}%
-
-### ORDER FLOW (Last ${context.orderFlow.tickCount || 0} ticks)
-- Delta: ${context.orderFlow.delta || 0} (${context.orderFlow.deltaPercent || 0}%)
-- Buy Volume: ${context.orderFlow.buyVolume || 0}
-- Sell Volume: ${context.orderFlow.sellVolume || 0}
-- Trend: ${context.orderFlow.trend || 'unknown'}
-- Range: ${context.orderFlow.range?.toFixed(2) || 'N/A'}
-
-### DOM ANALYSIS
-${context.dom.available 
-  ? `- Spread: ${context.dom.spread?.toFixed(2) || 'N/A'}
-- Bid Size: ${context.dom.totalBidSize} | Ask Size: ${context.dom.totalAskSize}
-- Imbalance Ratio: ${context.dom.imbalanceRatio}x
-- Dominant Side: ${context.dom.dominantSide}`
-  : '- DOM data not available'}
-
-### POSITION
-${context.position.hasPosition 
-  ? `- ${context.position.side.toUpperCase()} ${context.position.quantity}x @ ${context.position.entryPrice}
-- Unrealized P&L: $${context.position.unrealizedPnL}`
-  : '- No open position'}
-
-### SESSION PERFORMANCE
-- P&L: $${context.sessionStats.pnl} / $${context.sessionStats.target} target
-- Trades: ${context.sessionStats.trades} (W: ${context.sessionStats.wins} / L: ${context.sessionStats.losses})
-- Progress: ${context.sessionStats.progressToTarget}%
-`;
-};
-
-module.exports = {
-  buildMarketContext,
-  formatContextForPrompt,
-  buildDOMSummary,
-  buildOrderFlowSummary,
-  buildTradeHistory,
-  buildPositionInfo
-};