hedgequantx 2.9.19 → 2.9.20

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

@@ -1,278 +0,0 @@
-/**
- * AI Response Parser
- * 
- * Parses responses from AI agents (JSON or text)
- * and normalizes them to a standard format.
- */
-
-/**
- * Default response when parsing fails
- */
-const DEFAULT_RESPONSE = {
-  decision: 'approve',
-  confidence: 50,
-  optimizations: null,
-  reason: 'Parse failed - defaulting to approve',
-  alerts: null,
-  parseSuccess: false
-};
-
-/**
- * Extract JSON from a string that may contain markdown or extra text
- */
-const extractJSON = (text) => {
-  if (!text || typeof text !== 'string') return null;
-
-  // Try direct parse first
-  try {
-    return JSON.parse(text.trim());
-  } catch (e) { /* continue */ }
-
-  // Try to find JSON in markdown code blocks
-  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (codeBlockMatch) {
-    try {
-      return JSON.parse(codeBlockMatch[1].trim());
-    } catch (e) { /* continue */ }
-  }
-
-  // Try to find JSON object pattern
-  const jsonMatch = text.match(/\{[\s\S]*"decision"[\s\S]*\}/);
-  if (jsonMatch) {
-    try {
-      return JSON.parse(jsonMatch[0]);
-    } catch (e) { /* continue */ }
-  }
-
-  return null;
-};
-
-/**
- * Validate and normalize the decision field
- */
-const normalizeDecision = (decision) => {
-  if (!decision) return 'approve';
-  
-  const d = String(decision).toLowerCase().trim();
-  
-  if (d === 'approve' || d === 'yes' || d === 'accept' || d === 'go') return 'approve';
-  if (d === 'reject' || d === 'no' || d === 'deny' || d === 'stop') return 'reject';
-  if (d === 'modify' || d === 'adjust' || d === 'optimize') return 'modify';
-  
-  return 'approve';
-};
-
-/**
- * Validate and normalize confidence score
- */
-const normalizeConfidence = (confidence) => {
-  if (confidence === undefined || confidence === null) return 50;
-  
-  const c = Number(confidence);
-  if (isNaN(c)) return 50;
-  
-  // Handle percentage strings like "85%"
-  if (typeof confidence === 'string' && confidence.includes('%')) {
-    const parsed = parseFloat(confidence);
-    if (!isNaN(parsed)) return Math.min(100, Math.max(0, parsed));
-  }
-  
-  // Normalize to 0-100 range
-  if (c >= 0 && c <= 1) return Math.round(c * 100);
-  return Math.min(100, Math.max(0, Math.round(c)));
-};
-
-/**
- * Validate and normalize optimizations
- */
-const normalizeOptimizations = (opts, signal) => {
-  if (!opts) return null;
-  
-  const normalized = {
-    entry: null,
-    stopLoss: null,
-    takeProfit: null,
-    size: null,
-    timing: 'now'
-  };
-
-  // Entry price
-  if (opts.entry !== undefined && opts.entry !== null) {
-    const entry = Number(opts.entry);
-    if (!isNaN(entry) && entry > 0) normalized.entry = entry;
-  }
-
-  // Stop loss
-  if (opts.stopLoss !== undefined && opts.stopLoss !== null) {
-    const sl = Number(opts.stopLoss);
-    if (!isNaN(sl) && sl > 0) normalized.stopLoss = sl;
-  }
-
-  // Take profit
-  if (opts.takeProfit !== undefined && opts.takeProfit !== null) {
-    const tp = Number(opts.takeProfit);
-    if (!isNaN(tp) && tp > 0) normalized.takeProfit = tp;
-  }
-
-  // Size adjustment (-0.5 to +0.5)
-  if (opts.size !== undefined && opts.size !== null) {
-    const size = Number(opts.size);
-    if (!isNaN(size)) {
-      normalized.size = Math.min(0.5, Math.max(-0.5, size));
-    }
-  }
-
-  // Timing
-  if (opts.timing) {
-    const t = String(opts.timing).toLowerCase().trim();
-    if (t === 'now' || t === 'immediate') normalized.timing = 'now';
-    else if (t === 'wait' || t === 'delay') normalized.timing = 'wait';
-    else if (t === 'cancel' || t === 'abort') normalized.timing = 'cancel';
-    else normalized.timing = 'now';
-  }
-
-  return normalized;
-};
-
-/**
- * Normalize reason string
- */
-const normalizeReason = (reason) => {
-  if (!reason) return 'No reason provided';
-  
-  const r = String(reason).trim();
-  if (r.length > 100) return r.substring(0, 97) + '...';
-  return r;
-};
-
-/**
- * Normalize alerts array
- */
-const normalizeAlerts = (alerts) => {
-  if (!alerts) return null;
-  if (!Array.isArray(alerts)) {
-    if (typeof alerts === 'string') return [alerts];
-    return null;
-  }
-  return alerts.filter(a => a && typeof a === 'string').slice(0, 5);
-};
-
-/**
- * Parse text response when JSON parsing fails
- * Attempts to extract decision from natural language
- */
-const parseTextResponse = (text, signal) => {
-  if (!text) return DEFAULT_RESPONSE;
-  
-  const lower = text.toLowerCase();
-  
-  // Determine decision from keywords
-  let decision = 'approve';
-  if (lower.includes('reject') || lower.includes('do not') || lower.includes("don't") || 
-      lower.includes('avoid') || lower.includes('skip') || lower.includes('no trade')) {
-    decision = 'reject';
-  } else if (lower.includes('modify') || lower.includes('adjust') || lower.includes('optimize') ||
-             lower.includes('tighten') || lower.includes('widen')) {
-    decision = 'modify';
-  }
-
-  // Try to extract confidence
-  let confidence = 60;
-  const confMatch = lower.match(/confidence[:\s]*(\d+)/i) || 
-                    lower.match(/(\d+)%?\s*confiden/i) ||
-                    lower.match(/score[:\s]*(\d+)/i);
-  if (confMatch) {
-    confidence = normalizeConfidence(confMatch[1]);
-  }
-
-  // Extract reason (first sentence or up to 100 chars)
-  let reason = text.split(/[.!?\n]/)[0]?.trim() || 'Parsed from text response';
-  reason = normalizeReason(reason);
-
-  return {
-    decision,
-    confidence,
-    optimizations: decision === 'modify' ? {
-      entry: signal?.entry || null,
-      stopLoss: signal?.stopLoss || null,
-      takeProfit: signal?.takeProfit || null,
-      size: null,
-      timing: 'now'
-    } : null,
-    reason,
-    alerts: null,
-    parseSuccess: false,
-    parsedFromText: true
-  };
-};
-
-/**
- * Main parser function - parse AI response to standard format
- */
-const parseAgentResponse = (response, signal = null) => {
-  // Handle empty response
-  if (!response) {
-    return { ...DEFAULT_RESPONSE, reason: 'Empty response from agent' };
-  }
-
-  // Handle response object with content field (common API format)
-  let text = response;
-  if (typeof response === 'object') {
-    if (response.content) text = response.content;
-    else if (response.text) text = response.text;
-    else if (response.message) text = response.message;
-    else text = JSON.stringify(response);
-  }
-
-  // Try to extract and parse JSON
-  const json = extractJSON(text);
-  
-  if (json && json.decision) {
-    // Successfully parsed JSON
-    return {
-      decision: normalizeDecision(json.decision),
-      confidence: normalizeConfidence(json.confidence),
-      optimizations: normalizeOptimizations(json.optimizations, signal),
-      reason: normalizeReason(json.reason),
-      alerts: normalizeAlerts(json.alerts),
-      parseSuccess: true
-    };
-  }
-
-  // Fallback to text parsing
-  return parseTextResponse(text, signal);
-};
-
-/**
- * Validate a parsed response
- */
-const validateResponse = (parsed) => {
-  const errors = [];
-  
-  if (!['approve', 'reject', 'modify'].includes(parsed.decision)) {
-    errors.push(`Invalid decision: ${parsed.decision}`);
-  }
-  
-  if (parsed.confidence < 0 || parsed.confidence > 100) {
-    errors.push(`Invalid confidence: ${parsed.confidence}`);
-  }
-  
-  if (parsed.decision === 'modify' && !parsed.optimizations) {
-    errors.push('Modify decision requires optimizations');
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-};
-
-module.exports = {
-  parseAgentResponse,
-  validateResponse,
-  extractJSON,
-  normalizeDecision,
-  normalizeConfidence,
-  normalizeOptimizations,
-  DEFAULT_RESPONSE
-};

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

@@ -1,259 +0,0 @@
-/**
- * Symbol Data for AI Supervision
- * 
- * Contains detailed information about tradeable symbols
- * including tick sizes, sessions, correlations, and characteristics.
- */
-
-const SYMBOLS = {
-  NQ: {
-    id: 'NQ',
-    name: 'E-mini Nasdaq 100',
-    exchange: 'CME',
-    tickSize: 0.25,
-    tickValue: 5.00,
-    pointValue: 20.00,
-    margin: 15000,
-    characteristics: {
-      volatility: 'high',
-      sector: 'technology',
-      behavior: 'momentum-driven, gap-prone',
-      avgRange: '150-300 points'
-    },
-    correlations: {
-      positive: ['ES', 'YM'],
-      negative: ['VIX'],
-      related: ['QQQ', 'AAPL', 'MSFT', 'NVDA']
-    },
-    sessions: {
-      most_active: ['us_open', 'us_close'],
-      avoid: ['asia_lunch', 'low_volume']
-    }
-  },
-
-  ES: {
-    id: 'ES',
-    name: 'E-mini S&P 500',
-    exchange: 'CME',
-    tickSize: 0.25,
-    tickValue: 12.50,
-    pointValue: 50.00,
-    margin: 12000,
-    characteristics: {
-      volatility: 'medium',
-      sector: 'broad_market',
-      behavior: 'reference index, institutional flow',
-      avgRange: '30-60 points'
-    },
-    correlations: {
-      positive: ['NQ', 'YM', 'RTY'],
-      negative: ['VIX', 'ZB'],
-      related: ['SPY', 'SPX']
-    },
-    sessions: {
-      most_active: ['us_open', 'us_close', 'london_us_overlap'],
-      avoid: ['asia_session']
-    }
-  },
-
-  YM: {
-    id: 'YM',
-    name: 'E-mini Dow',
-    exchange: 'CME',
-    tickSize: 1.00,
-    tickValue: 5.00,
-    pointValue: 5.00,
-    margin: 10000,
-    characteristics: {
-      volatility: 'medium-low',
-      sector: 'value_stocks',
-      behavior: 'slower than ES/NQ, less spiky',
-      avgRange: '200-400 points'
-    },
-    correlations: {
-      positive: ['ES', 'NQ'],
-      negative: ['VIX'],
-      related: ['DIA', 'DJIA']
-    },
-    sessions: {
-      most_active: ['us_open', 'us_close'],
-      avoid: ['overnight']
-    }
-  },
-
-  RTY: {
-    id: 'RTY',
-    name: 'E-mini Russell 2000',
-    exchange: 'CME',
-    tickSize: 0.10,
-    tickValue: 5.00,
-    pointValue: 50.00,
-    margin: 8000,
-    characteristics: {
-      volatility: 'high',
-      sector: 'small_caps',
-      behavior: 'more volatile than ES, liquidity gaps',
-      avgRange: '20-40 points'
-    },
-    correlations: {
-      positive: ['ES', 'NQ'],
-      negative: ['VIX'],
-      related: ['IWM', 'RUT']
-    },
-    sessions: {
-      most_active: ['us_open'],
-      avoid: ['overnight', 'low_volume']
-    }
-  },
-
-  GC: {
-    id: 'GC',
-    name: 'Gold Futures',
-    exchange: 'COMEX',
-    tickSize: 0.10,
-    tickValue: 10.00,
-    pointValue: 100.00,
-    margin: 11000,
-    characteristics: {
-      volatility: 'medium',
-      sector: 'precious_metals',
-      behavior: 'safe haven, inverse USD, central bank sensitive',
-      avgRange: '15-30 points'
-    },
-    correlations: {
-      positive: ['SI', 'EURUSD'],
-      negative: ['DXY', 'US10Y'],
-      related: ['GLD', 'XAUUSD']
-    },
-    sessions: {
-      most_active: ['london', 'us_open', 'asia_open'],
-      avoid: ['us_afternoon']
-    }
-  },
-
-  SI: {
-    id: 'SI',
-    name: 'Silver Futures',
-    exchange: 'COMEX',
-    tickSize: 0.005,
-    tickValue: 25.00,
-    pointValue: 5000.00,
-    margin: 9000,
-    characteristics: {
-      volatility: 'high',
-      sector: 'precious_metals',
-      behavior: 'follows gold with more volatility, industrial demand',
-      avgRange: '0.30-0.60 points'
-    },
-    correlations: {
-      positive: ['GC'],
-      negative: ['DXY'],
-      related: ['SLV', 'XAGUSD']
-    },
-    sessions: {
-      most_active: ['london', 'us_open'],
-      avoid: ['asia_lunch']
-    }
-  },
-
-  CL: {
-    id: 'CL',
-    name: 'Crude Oil Futures',
-    exchange: 'NYMEX',
-    tickSize: 0.01,
-    tickValue: 10.00,
-    pointValue: 1000.00,
-    margin: 7000,
-    characteristics: {
-      volatility: 'high',
-      sector: 'energy',
-      behavior: 'news-driven, inventories, geopolitical, OPEC',
-      avgRange: '1.50-3.00 points'
-    },
-    correlations: {
-      positive: ['BZ', 'XLE'],
-      negative: [],
-      related: ['USO', 'WTI']
-    },
-    sessions: {
-      most_active: ['us_open', 'inventory_report'],
-      avoid: ['overnight_thin']
-    }
-  }
-};
-
-/**
- * Trading sessions with times (Eastern Time)
- */
-const SESSIONS = {
-  asia_open: { start: '18:00', end: '20:00', description: 'Asia market open' },
-  asia_session: { start: '20:00', end: '03:00', description: 'Asia main session' },
-  asia_lunch: { start: '00:00', end: '01:00', description: 'Asia lunch (low volume)' },
-  london: { start: '03:00', end: '08:00', description: 'London session' },
-  london_us_overlap: { start: '08:00', end: '11:30', description: 'London/US overlap' },
-  us_open: { start: '09:30', end: '11:30', description: 'US market open (high volume)' },
-  us_midday: { start: '11:30', end: '14:00', description: 'US midday (lower volume)' },
-  us_afternoon: { start: '14:00', end: '15:00', description: 'US afternoon' },
-  us_close: { start: '15:00', end: '16:00', description: 'US close (rebalancing)' },
-  overnight: { start: '16:00', end: '18:00', description: 'Overnight transition' }
-};
-
-/**
- * Get symbol data by ID
- */
-const getSymbol = (symbolId) => {
-  const key = symbolId?.toUpperCase?.()?.replace(/[0-9]/g, '') || '';
-  return SYMBOLS[key] || null;
-};
-
-/**
- * Get current session based on time
- */
-const getCurrentSession = (date = new Date()) => {
-  const et = new Date(date.toLocaleString('en-US', { timeZone: 'America/New_York' }));
-  const hours = et.getHours();
-  const minutes = et.getMinutes();
-  const time = hours * 60 + minutes;
-
-  for (const [name, session] of Object.entries(SESSIONS)) {
-    const [startH, startM] = session.start.split(':').map(Number);
-    const [endH, endM] = session.end.split(':').map(Number);
-    const start = startH * 60 + startM;
-    const end = endH * 60 + endM;
-
-    if (start <= end) {
-      if (time >= start && time < end) return { name, ...session };
-    } else {
-      if (time >= start || time < end) return { name, ...session };
-    }
-  }
-  return { name: 'unknown', description: 'Unknown session' };
-};
-
-/**
- * Check if current time is good for trading a symbol
- */
-const isGoodSessionForSymbol = (symbolId, date = new Date()) => {
-  const symbol = getSymbol(symbolId);
-  if (!symbol) return { good: true, reason: 'Unknown symbol' };
-
-  const session = getCurrentSession(date);
-  
-  if (symbol.sessions.avoid?.includes(session.name)) {
-    return { good: false, reason: `${session.description} - typically low volume for ${symbolId}` };
-  }
-  
-  if (symbol.sessions.most_active?.includes(session.name)) {
-    return { good: true, reason: `${session.description} - optimal for ${symbolId}` };
-  }
-
-  return { good: true, reason: session.description };
-};
-
-module.exports = {
-  SYMBOLS,
-  SESSIONS,
-  getSymbol,
-  getCurrentSession,
-  isGoodSessionForSymbol
-};