hedgequantx 2.6.159 → 2.6.161

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-utils.js

@@ -0,0 +1,158 @@
+/**
+ * Supervisor Utility Functions
+ * Pure functions for market analysis - no state dependencies
+ */
+
+'use strict';
+
+const calculateTrendStrength = (ticks) => {
+  if (!ticks || ticks.length < 20) return { strength: 0, direction: 'unknown' };
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 20) return { strength: 0, direction: 'unknown' };
+  const shortTerm = prices.slice(-20);
+  const shortChange = shortTerm[shortTerm.length - 1] - shortTerm[0];
+  const mediumTerm = prices.slice(-50);
+  const mediumChange = mediumTerm[mediumTerm.length - 1] - mediumTerm[0];
+  const aligned = (shortChange > 0 && mediumChange > 0) || (shortChange < 0 && mediumChange < 0);
+  const avgRange = Math.abs(Math.max(...prices) - Math.min(...prices)) || 1;
+  return {
+    strength: aligned ? Math.min(1, (Math.abs(shortChange) + Math.abs(mediumChange)) / avgRange) : 0,
+    direction: mediumChange > 0 ? 'bullish' : mediumChange < 0 ? 'bearish' : 'neutral',
+    shortTermDirection: shortChange > 0 ? 'up' : shortChange < 0 ? 'down' : 'flat',
+    aligned
+  };
+};
+
+const calculateRecentRange = (ticks, count) => {
+  if (!ticks || ticks.length === 0) return { high: 0, low: 0, range: 0 };
+  const prices = ticks.slice(-count).map(t => t.price).filter(Boolean);
+  if (prices.length === 0) return { high: 0, low: 0, range: 0 };
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  return { high, low, range: high - low };
+};
+
+const calculatePriceVelocity = (ticks, count) => {
+  if (!ticks || ticks.length < 2) return { velocity: 0, acceleration: 0 };
+  const recentTicks = ticks.slice(-count);
+  if (recentTicks.length < 2) return { velocity: 0, acceleration: 0 };
+  const prices = recentTicks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return { velocity: 0, acceleration: 0 };
+  const totalChange = prices[prices.length - 1] - prices[0];
+  const velocity = totalChange / prices.length;
+  const midPoint = Math.floor(prices.length / 2);
+  const firstHalfVelocity = (prices[midPoint] - prices[0]) / midPoint;
+  const secondHalfVelocity = (prices[prices.length - 1] - prices[midPoint]) / (prices.length - midPoint);
+  const acceleration = secondHalfVelocity - firstHalfVelocity;
+  return { velocity, acceleration };
+};
+
+const getMarketSession = (hour) => {
+  if (hour >= 9 && hour < 12) return 'morning';
+  if (hour >= 12 && hour < 14) return 'midday';
+  if (hour >= 14 && hour < 16) return 'afternoon';
+  if (hour >= 16 && hour < 18) return 'close';
+  if (hour >= 18 || hour < 9) return 'overnight';
+  return 'unknown';
+};
+
+const getMinutesSinceOpen = (hour) => {
+  const now = new Date();
+  const currentMinutes = hour * 60 + now.getMinutes();
+  const openMinutes = 9 * 60 + 30;
+  return Math.max(0, currentMinutes - openMinutes);
+};
+
+const analyzePriceLevelInteraction = (entryPrice, ticks) => {
+  if (!ticks || ticks.length < 20) return null;
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 20) return null;
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  const range = high - low || 1;
+  const positionInRange = (entryPrice - low) / range;
+  let levelType = 'middle';
+  if (positionInRange > 0.8) levelType = 'near_high';
+  else if (positionInRange < 0.2) levelType = 'near_low';
+  else if (positionInRange > 0.6) levelType = 'upper_middle';
+  else if (positionInRange < 0.4) levelType = 'lower_middle';
+  return {
+    positionInRange: Math.round(positionInRange * 100) / 100,
+    distanceToHigh: high - entryPrice,
+    distanceToLow: entryPrice - low,
+    recentHigh: high,
+    recentLow: low,
+    levelType
+  };
+};
+
+const determineLevelType = (price, ticks) => {
+  if (!ticks || ticks.length < 10) return 'unknown';
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 10) return 'unknown';
+  const high = Math.max(...prices);
+  const low = Math.min(...prices);
+  const tickSize = 0.25;
+  if (Math.abs(price - high) <= tickSize * 4) return 'resistance';
+  if (Math.abs(price - low) <= tickSize * 4) return 'support';
+  if (price > high) return 'breakout_high';
+  if (price < low) return 'breakout_low';
+  return 'middle';
+};
+
+const analyzePriceAction = (ticks) => {
+  if (!ticks || ticks.length < 2) return { trend: 'unknown', strength: 0 };
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return { trend: 'unknown', strength: 0 };
+  const first = prices[0];
+  const last = prices[prices.length - 1];
+  const change = last - first;
+  const range = Math.max(...prices) - Math.min(...prices);
+  return {
+    trend: change > 0 ? 'up' : change < 0 ? 'down' : 'flat',
+    strength: range > 0 ? Math.abs(change) / range : 0,
+    range,
+    change
+  };
+};
+
+const analyzeVolume = (ticks) => {
+  if (!ticks || ticks.length === 0) return { total: 0, avg: 0, trend: 'unknown' };
+  const volumes = ticks.map(t => t.volume || 0);
+  const total = volumes.reduce((a, b) => a + b, 0);
+  const avg = total / volumes.length;
+  const mid = Math.floor(volumes.length / 2);
+  const firstHalf = volumes.slice(0, mid).reduce((a, b) => a + b, 0);
+  const secondHalf = volumes.slice(mid).reduce((a, b) => a + b, 0);
+  return {
+    total,
+    avg,
+    trend: secondHalf > firstHalf * 1.2 ? 'increasing' : secondHalf < firstHalf * 0.8 ? 'decreasing' : 'stable'
+  };
+};
+
+const calculateVolatility = (ticks) => {
+  if (!ticks || ticks.length < 2) return 0;
+  const prices = ticks.map(t => t.price).filter(Boolean);
+  if (prices.length < 2) return 0;
+  const returns = [];
+  for (let i = 1; i < prices.length; i++) {
+    returns.push((prices[i] - prices[i-1]) / prices[i-1]);
+  }
+  const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const variance = returns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / returns.length;
+  return Math.sqrt(variance);
+};
+
+module.exports = {
+  calculateTrendStrength,
+  calculateRecentRange,
+  calculatePriceVelocity,
+  getMarketSession,
+  getMinutesSinceOpen,
+  analyzePriceLevelInteraction,
+  determineLevelType,
+  analyzePriceAction,
+  analyzeVolume,
+  calculateVolatility
+};