hedgequantx 2.9.20 → 2.9.22

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

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

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

@@ -0,0 +1,167 @@
+/**
+ * AI Supervision Directive - The 7 Phases
+ * 
+ * This directive is sent to ALL AI agents for trading supervision.
+ * Each agent receives the same instructions and analyzes signals in parallel.
+ */
+
+const DIRECTIVE_PHASES = {
+  phase1_strategy: `
+## PHASE 1: MAÎTRISER LA STRATÉGIE
+Tu connais cette stratégie par coeur. Tu sais exactement:
+- Les conditions d'entrée (setup patterns, confirmations requises)
+- Les règles de sortie (targets, stops, trailing)
+- La gestion du risque (sizing, max loss, drawdown limits)
+- Les filtres de marché (sessions, volatilité, corrélations)
+Tu ne devines jamais. Tu appliques la stratégie avec précision chirurgicale.
+`,
+
+  phase2_role: `
+## PHASE 2: TON RÔLE
+Tu es une arme de précision intégrée à l'algo de trading.
+Tu n'es PAS un conseiller - tu es un avantage décisif.
+Ton job: optimiser chaque signal pour maximiser le edge.
+Tu travailles EN TEMPS RÉEL avec latence minimale.
+Chaque milliseconde compte. Chaque tick compte.
+`,
+
+  phase3_analysis: `
+## PHASE 3: CE QUE TU ANALYSES
+Pour chaque signal reçu, tu analyses:
+- DOM (Depth of Market): déséquilibres bid/ask, absorption, spoofing
+- Order Flow: delta, CVD, volume profile, footprint
+- Manipulations: stop hunts, fakeouts, liquidity grabs
+- Patterns: structure de marché, S/R, pivots, VWAP
+- Historique: trades récents, winrate par setup, performance horaire
+- Corrélations: autres symboles liés (ES/NQ, GC/SI, etc.)
+`,
+
+  phase4_output: `
+## PHASE 4: CE QUE TU FOURNIS
+Pour chaque signal, tu retournes:
+1. DECISION: approve/reject/modify
+2. CONFIDENCE: score 0-100
+3. OPTIMIZATIONS (si approve/modify):
+   - entry: prix d'entrée optimisé (ou null)
+   - stopLoss: stop optimisé (ou null)
+   - takeProfit: target optimisé (ou null)
+   - size: ajustement de taille (-50% à +50%)
+   - timing: "now" | "wait" | "cancel"
+4. REASON: explication courte (max 50 chars)
+5. ALERTS: warnings importants (optionnel)
+`,
+
+  phase5_restrictions: `
+## PHASE 5: CE QUE TU NE FAIS JAMAIS
+- Tu ne BLOQUES jamais l'algo sans raison valide
+- Tu ne RALENTIS jamais l'exécution (réponse < 2 secondes)
+- Tu ne fais pas de VAGUE - décision claire et directe
+- Tu n'INVENTES pas de données - utilise uniquement ce qui est fourni
+- Tu ne CHANGES pas la stratégie - tu l'optimises dans ses règles
+`,
+
+  phase6_symbols: `
+## PHASE 6: CONNAISSANCE DES SYMBOLES
+Tu trades ces symboles avec leurs caractéristiques:
+- NQ (Nasdaq): volatile, tech-driven, corrélé ES
+- ES (S&P500): référence, plus stable, leader
+- YM (Dow): value stocks, moins volatile
+- RTY (Russell): small caps, plus volatile que ES
+- GC (Gold): safe haven, inverse USD, sessions Asia/London
+- SI (Silver): suit GC avec plus de volatilité
+- CL (Crude): news-driven, inventories, géopolitique
+
+Sessions importantes:
+- Asia: 18:00-03:00 ET (GC/SI actifs)
+- London: 03:00-08:00 ET (préparation US)
+- US Open: 09:30-11:30 ET (max volatilité)
+- US Close: 15:00-16:00 ET (rebalancing)
+`,
+
+  phase7_mindset: `
+## PHASE 7: TA MENTALITÉ
+- OBJECTIF: Gagner. Pas "essayer". Gagner.
+- PRÉCISION: Chaque décision compte
+- RAPIDITÉ: Temps = argent. Sois rapide.
+- RESPONSABILITÉ: Tu assumes tes recommandations
+- ADAPTATION: Le marché change, tu t'adaptes
+- DISCIPLINE: Les règles sont les règles
+`
+};
+
+/**
+ * Build the complete directive string
+ */
+const buildDirective = () => {
+  return Object.values(DIRECTIVE_PHASES).join('\n');
+};
+
+/**
+ * Expected output format from AI agents
+ */
+const OUTPUT_FORMAT = {
+  schema: {
+    decision: 'approve | reject | modify',
+    confidence: 'number 0-100',
+    optimizations: {
+      entry: 'number | null',
+      stopLoss: 'number | null',
+      takeProfit: 'number | null',
+      size: 'number (-0.5 to 0.5) | null',
+      timing: 'now | wait | cancel'
+    },
+    reason: 'string (max 50 chars)',
+    alerts: 'string[] | null'
+  },
+  example: {
+    decision: 'modify',
+    confidence: 85,
+    optimizations: {
+      entry: 21450.25,
+      stopLoss: 21445.00,
+      takeProfit: 21462.50,
+      size: 0,
+      timing: 'now'
+    },
+    reason: 'Strong bid stack, tighten stop',
+    alerts: null
+  }
+};
+
+/**
+ * Build the output format instructions
+ */
+const buildOutputInstructions = () => {
+  return `
+## OUTPUT FORMAT (JSON STRICT)
+Tu dois TOUJOURS répondre en JSON valide avec ce format exact:
+
+\`\`\`json
+${JSON.stringify(OUTPUT_FORMAT.example, null, 2)}
+\`\`\`
+
+IMPORTANT:
+- decision: "approve" (exécuter tel quel), "reject" (ne pas exécuter), "modify" (exécuter avec optimisations)
+- confidence: 0-100, ton niveau de confiance dans la décision
+- optimizations: null si decision="reject", sinon les ajustements
+- size: 0 = garder la taille, -0.5 = réduire de 50%, +0.5 = augmenter de 50%
+- timing: "now" = exécuter immédiatement, "wait" = attendre meilleur prix, "cancel" = annuler
+- reason: TOUJOURS fournir une raison courte
+- Pas de texte avant ou après le JSON
+`;
+};
+
+/**
+ * Get the complete directive with output format
+ */
+const getFullDirective = () => {
+  return buildDirective() + '\n' + buildOutputInstructions();
+};
+
+module.exports = {
+  DIRECTIVE_PHASES,
+  OUTPUT_FORMAT,
+  buildDirective,
+  buildOutputInstructions,
+  getFullDirective
+};

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

@@ -10,7 +10,7 @@
  */
 
 const cliproxy = require('../cliproxy');
-const { extractJSON } = require('./parser');
+const https = require('https');
 
 /** Test prompt to verify agent understands directive format */
 const TEST_PROMPT = `You are being tested. Respond ONLY with this exact JSON, nothing else:
@@ -161,7 +161,6 @@ const testAgentConnection = async (agent) => {
 
 /**
  * Validate that response matches expected JSON format
- * Uses robust extractJSON from parser.js to handle MiniMax <think> tags and other edge cases
  * @param {string} content - Response content from agent
  * @returns {Object} { valid, error }
  */
@@ -170,40 +169,53 @@ const validateResponseFormat = (content) => {
     return { valid: false, error: 'Empty response' };
   }
   
-  // Use robust JSON extraction from parser.js
-  // Handles: direct JSON, markdown code blocks, JSON with extra text (MiniMax <think> tags)
-  const json = extractJSON(content);
-  
-  if (!json) {
-    return { valid: false, error: 'No valid JSON found in response' };
-  }
-  
-  // Check required fields
-  if (!json.decision) {
-    return { valid: false, error: 'Missing "decision" field' };
-  }
-  
-  if (json.confidence === undefined) {
-    return { valid: false, error: 'Missing "confidence" field' };
-  }
-  
-  if (!json.reason) {
-    return { valid: false, error: 'Missing "reason" field' };
-  }
-  
-  // Validate decision value
-  const validDecisions = ['approve', 'reject', 'modify'];
-  if (!validDecisions.includes(json.decision)) {
-    return { valid: false, error: `Invalid decision: ${json.decision}` };
-  }
-  
-  // Validate confidence is number 0-100
-  const conf = Number(json.confidence);
-  if (isNaN(conf) || conf < 0 || conf > 100) {
-    return { valid: false, error: `Invalid confidence: ${json.confidence}` };
+  try {
+    // Try to extract JSON from response
+    let json;
+    
+    // Direct parse
+    try {
+      json = JSON.parse(content.trim());
+    } catch (e) {
+      // Try to find JSON in response
+      const match = content.match(/\{[\s\S]*\}/);
+      if (match) {
+        json = JSON.parse(match[0]);
+      } else {
+        return { valid: false, error: 'No JSON in response' };
+      }
+    }
+    
+    // Check required fields
+    if (!json.decision) {
+      return { valid: false, error: 'Missing "decision" field' };
+    }
+    
+    if (json.confidence === undefined) {
+      return { valid: false, error: 'Missing "confidence" field' };
+    }
+    
+    if (!json.reason) {
+      return { valid: false, error: 'Missing "reason" field' };
+    }
+    
+    // Validate decision value
+    const validDecisions = ['approve', 'reject', 'modify'];
+    if (!validDecisions.includes(json.decision)) {
+      return { valid: false, error: `Invalid decision: ${json.decision}` };
+    }
+    
+    // Validate confidence is number 0-100
+    const conf = Number(json.confidence);
+    if (isNaN(conf) || conf < 0 || conf > 100) {
+      return { valid: false, error: `Invalid confidence: ${json.confidence}` };
+    }
+    
+    return { valid: true, error: null };
+    
+  } catch (error) {
+    return { valid: false, error: `Parse error: ${error.message}` };
   }
-  
-  return { valid: true, error: null };
 };
 
 /**