hedgequantx 2.6.160 → 2.6.162

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
+};