market-analyzer.js

#!/usr/bin/env node

import { config } from './src/config/config.js';
import { KalshiAPI } from './src/api/kalshiApi.js';
import { KalshiWebSocket } from './src/websocket/kalshiWebSocket.js';
import logger from './src/utils/logger.js';

/**
 * Market Data Analyzer
 * Analyzes live market data to determine the best trading strategy
 */
class MarketAnalyzer {
  constructor() {
    this.api = new KalshiAPI();
    this.websocket = new KalshiWebSocket();
    
    // Data collection
    this.marketData = new Map(); // marketId -> price history
    this.analysisResults = new Map(); // marketId -> analysis
    this.collectionTime = 300000; // 5 minutes of data collection
    this.startTime = Date.now();
    
    // Strategy recommendations
    this.strategyScores = {
      meanReversion: 0,
      momentum: 0,
      arbitrage: 0,
      volatility: 0,
      trendFollowing: 0
    };
    
    // Connect to WebSocket for live data
    this.websocket.on('ticker', (tickerData) => {
      this.processTicker(tickerData);
    });
  }

  /**
   * Process incoming ticker data
   */
  processTicker(tickerData) {
    try {
      const { marketId, marketTicker, price, yesBid, yesAsk } = tickerData;
      
      if (!price || !yesBid || !yesAsk) return;
      
      // Initialize market data collection
      if (!this.marketData.has(marketId)) {
        this.marketData.set(marketId, {
          ticker: marketTicker,
          prices: [],
          bids: [],
          asks: [],
          spreads: [],
          timestamps: []
        });
      }
      
      const market = this.marketData.get(marketId);
      
      // Add new data point
      market.prices.push(parseFloat(price));
      market.bids.push(parseFloat(yesBid));
      market.asks.push(parseFloat(yesAsk));
      market.spreads.push(parseFloat(yesAsk) - parseFloat(yesBid));
      market.timestamps.push(Date.now());
      
      // Keep only last 100 data points
      if (market.prices.length > 100) {
        market.prices.shift();
        market.bids.shift();
        market.asks.shift();
        market.spreads.shift();
        market.timestamps.shift();
      }
      
      // Analyze when we have enough data
      if (market.prices.length >= 20) {
        this.analyzeMarket(marketId);
      }
      
    } catch (error) {
      logger.error('Error processing ticker in analyzer', { error: error.message });
    }
  }

  /**
   * Analyze a specific market
   */
  analyzeMarket(marketId) {
    const market = this.marketData.get(marketId);
    if (!market || market.prices.length < 20) return;
    
    const analysis = {
      ticker: market.ticker,
      dataPoints: market.prices.length,
      priceStats: this.calculatePriceStats(market.prices),
      volatilityStats: this.calculateVolatilityStats(market.prices),
      trendStats: this.calculateTrendStats(market.prices),
      spreadStats: this.calculateSpreadStats(market.spreads),
      strategyRecommendations: []
    };
    
    // Generate strategy recommendations
    analysis.strategyRecommendations = this.generateStrategyRecommendations(analysis);
    
    // Store analysis
    this.analysisResults.set(marketId, analysis);
    
    // Update global strategy scores
    this.updateStrategyScores(analysis);
  }

  /**
   * Calculate price statistics
   */
  calculatePriceStats(prices) {
    const sorted = [...prices].sort((a, b) => a - b);
    const mean = prices.reduce((sum, p) => sum + p, 0) / prices.length;
    const variance = prices.reduce((sum, p) => sum + Math.pow(p - mean, 2), 0) / prices.length;
    const stdDev = Math.sqrt(variance);
    
    return {
      current: prices[prices.length - 1],
      mean,
      median: sorted[Math.floor(sorted.length / 2)],
      min: sorted[0],
      max: sorted[sorted.length - 1],
      stdDev,
      range: sorted[sorted.length - 1] - sorted[0],
      coefficientOfVariation: stdDev / mean
    };
  }

  /**
   * Calculate volatility statistics
   */
  calculateVolatilityStats(prices) {
    if (prices.length < 2) return {};
    
    const returns = [];
    for (let i = 1; i < prices.length; i++) {
      returns.push((prices[i] - prices[i-1]) / prices[i-1]);
    }
    
    const meanReturn = returns.reduce((sum, r) => sum + r, 0) / returns.length;
    const returnVariance = returns.reduce((sum, r) => sum + Math.pow(r - meanReturn, 2), 0) / returns.length;
    const returnStdDev = Math.sqrt(returnVariance);
    
    // Calculate realized volatility (annualized)
    const realizedVol = returnStdDev * Math.sqrt(252 * 24 * 60); // Assuming minute data
    
    return {
      returns,
      meanReturn,
      returnStdDev,
      realizedVol,
      maxGain: Math.max(...returns),
      maxLoss: Math.min(...returns),
      volatilityRegime: this.classifyVolatilityRegime(realizedVol)
    };
  }

  /**
   * Calculate trend statistics
   */
  calculateTrendStats(prices) {
    if (prices.length < 10) return {};
    
    // Linear regression
    const n = prices.length;
    const x = Array.from({length: n}, (_, i) => i);
    const y = prices;
    
    const sumX = x.reduce((sum, xi) => sum + xi, 0);
    const sumY = y.reduce((sum, yi) => sum + yi, 0);
    const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
    const sumX2 = x.reduce((sum, xi) => sum + xi * xi, 0);
    
    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
    const intercept = (sumY - slope * sumX) / n;
    
    // R-squared
    const yMean = sumY / n;
    const ssRes = y.reduce((sum, yi, i) => sum + Math.pow(yi - (slope * i + intercept), 2), 0);
    const ssTot = y.reduce((sum, yi) => sum + Math.pow(yi - yMean, 2), 0);
    const rSquared = 1 - (ssRes / ssTot);
    
    // Trend strength classification
    let trendStrength = 'weak';
    if (rSquared > 0.7) trendStrength = 'strong';
    else if (rSquared > 0.4) trendStrength = 'moderate';
    
    // Trend direction
    let trendDirection = 'sideways';
    if (Math.abs(slope) > 0.001) {
      trendDirection = slope > 0 ? 'uptrend' : 'downtrend';
    }
    
    return {
      slope,
      intercept,
      rSquared,
      trendStrength,
      trendDirection,
      priceChange: prices[prices.length - 1] - prices[0],
      priceChangePercent: ((prices[prices.length - 1] - prices[0]) / prices[0]) * 100
    };
  }

  /**
   * Calculate spread statistics
   */
  calculateSpreadStats(spreads) {
    if (spreads.length === 0) return {};
    
    const mean = spreads.reduce((sum, s) => sum + s, 0) / spreads.length;
    const variance = spreads.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / spreads.length;
    const stdDev = Math.sqrt(variance);
    
    return {
      current: spreads[spreads.length - 1],
      mean,
      stdDev,
      min: Math.min(...spreads),
      max: Math.max(...spreads),
      spreadVolatility: stdDev / mean
    };
  }

  /**
   * Classify volatility regime
   */
  classifyVolatilityRegime(volatility) {
    if (volatility < 0.1) return 'low';
    if (volatility < 0.3) return 'medium';
    if (volatility < 0.5) return 'high';
    return 'extreme';
  }

  /**
   * Generate strategy recommendations
   */
  generateStrategyRecommendations(analysis) {
    const recommendations = [];
    const { priceStats, volatilityStats, trendStats, spreadStats } = analysis;
    
    // Mean Reversion Strategy
    let meanReversionScore = 0;
    if (priceStats.coefficientOfVariation > 0.1) meanReversionScore += 2;
    if (Math.abs(priceStats.current - priceStats.mean) > priceStats.stdDev) meanReversionScore += 2;
    if (volatilityStats.volatilityRegime === 'medium') meanReversionScore += 1;
    if (meanReversionScore > 0) {
      recommendations.push({
        strategy: 'Mean Reversion',
        score: meanReversionScore,
        reasoning: `Price ${priceStats.current > priceStats.mean ? 'above' : 'below'} mean by ${Math.abs(priceStats.current - priceStats.mean).toFixed(4)} (${(Math.abs(priceStats.current - priceStats.mean) / priceStats.stdDev).toFixed(2)} std dev)`,
        action: priceStats.current > priceStats.mean ? 'SELL' : 'BUY'
      });
    }
    
    // Momentum Strategy
    let momentumScore = 0;
    if (trendStats.trendStrength === 'strong') momentumScore += 3;
    if (trendStats.rSquared > 0.6) momentumScore += 2;
    if (Math.abs(trendStats.slope) > 0.001) momentumScore += 1;
    if (momentumScore > 0) {
      recommendations.push({
        strategy: 'Momentum',
        score: momentumScore,
        reasoning: `${trendStats.trendDirection} with ${trendStats.trendStrength} trend (R² = ${trendStats.rSquared.toFixed(3)})`,
        action: trendStats.trendDirection === 'uptrend' ? 'BUY' : 'SELL'
      });
    }
    
    // Volatility Strategy
    let volatilityScore = 0;
    if (volatilityStats.volatilityRegime === 'high' || volatilityStats.volatilityRegime === 'extreme') volatilityScore += 3;
    if (priceStats.range > priceStats.mean * 0.1) volatilityScore += 2;
    if (volatilityScore > 0) {
      recommendations.push({
        strategy: 'Volatility',
        score: volatilityScore,
        reasoning: `${volatilityStats.volatilityRegime} volatility regime with ${(priceStats.range / priceStats.mean * 100).toFixed(1)}% price range`,
        action: 'BUY_STRADDLE' // Buy both sides for volatility
      });
    }
    
    // Arbitrage Strategy
    let arbitrageScore = 0;
    if (spreadStats.spreadVolatility > 0.5) arbitrageScore += 2;
    if (spreadStats.current > spreadStats.mean + spreadStats.stdDev) arbitrageScore += 1;
    if (arbitrageScore > 0) {
      recommendations.push({
        strategy: 'Arbitrage',
        score: arbitrageScore,
        reasoning: `Wide spreads with ${spreadStats.spreadVolatility.toFixed(2)} spread volatility`,
        action: 'EXPLOIT_SPREADS'
      });
    }
    
    // Sort by score
    recommendations.sort((a, b) => b.score - a.score);
    
    return recommendations;
  }

  /**
   * Update global strategy scores
   */
  updateStrategyScores(analysis) {
    analysis.strategyRecommendations.forEach(rec => {
      switch (rec.strategy) {
        case 'Mean Reversion':
          this.strategyScores.meanReversion += rec.score;
          break;
        case 'Momentum':
          this.strategyScores.momentum += rec.score;
          break;
        case 'Volatility':
          this.strategyScores.volatility += rec.score;
          break;
        case 'Arbitrage':
          this.strategyScores.arbitrage += rec.score;
          break;
      }
    });
  }

  /**
   * Start the market analysis
   */
  async start() {
    try {
      console.log('🔍 Starting Market Data Analysis...\n');
      
      // Test API connection
      console.log('📡 Connecting to Kalshi API...');
      await this.api.testConnection();
      console.log('✅ API connected successfully\n');
      
      // Connect WebSocket with retry logic
      console.log('🔌 Connecting to Kalshi WebSocket...');
      let websocketConnected = false;
      let retryCount = 0;
      const maxRetries = 3;
      
      while (!websocketConnected && retryCount < maxRetries) {
        try {
          // Set a longer timeout for WebSocket connection
          const connectionPromise = this.websocket.connect();
          const timeoutPromise = new Promise((_, reject) => 
            setTimeout(() => reject(new Error('Connection timeout')), 15000)
          );
          
          await Promise.race([connectionPromise, timeoutPromise]);
          websocketConnected = true;
          console.log('✅ WebSocket connected successfully\n');
        } catch (error) {
          retryCount++;
          console.log(`⚠️  WebSocket connection attempt ${retryCount} failed: ${error.message}`);
          if (retryCount < maxRetries) {
            console.log(`🔄 Retrying in 2 seconds... (${retryCount}/${maxRetries})`);
            await new Promise(resolve => setTimeout(resolve, 2000));
          }
        }
      }
      
      if (!websocketConnected) {
        throw new Error(`WebSocket connection failed after ${maxRetries} attempts`);
      }
      
      // Subscribe to markets
      console.log('🔍 Discovering and subscribing to markets...');
      await this.subscribeToMarkets();
      console.log('✅ Subscribed to market data\n');
      
      console.log(`⏱️  Collecting market data for ${this.collectionTime / 1000 / 60} minutes...`);
      console.log('📊 Analyzing price patterns, volatility, and trends...');
      console.log('💡 Will recommend the best trading strategy based on data\n');
      
      // Set up data collection timer
      setTimeout(() => {
        this.generateAnalysisReport();
        this.stop();
      }, this.collectionTime);
      
      // Set up progress updates
      const progressInterval = setInterval(() => {
        const elapsed = Date.now() - this.startTime;
        const remaining = this.collectionTime - elapsed;
        const marketsAnalyzed = this.analysisResults.size;
        
        console.log(`⏳ Progress: ${(elapsed / this.collectionTime * 100).toFixed(1)}% | Markets Analyzed: ${marketsAnalyzed} | Time Remaining: ${Math.floor(remaining / 1000 / 60)}m ${Math.floor((remaining / 1000) % 60)}s`);
        
        if (remaining <= 0) {
          clearInterval(progressInterval);
        }
      }, 30000); // Every 30 seconds
      
    } catch (error) {
      console.error('❌ Failed to start market analysis:', error.message);
      process.exit(1);
    }
  }

  /**
   * Subscribe to markets for analysis
   */
  async subscribeToMarkets() {
    try {
      const markets = await this.api.getMarkets(1000);
      
      if (markets.markets) {
        const activeMarkets = markets.markets.filter(market => 
          market.status === 'active'
        ).slice(0, 100); // Analyze top 100 active markets
        
        console.log(`📊 Found ${activeMarkets.length} active markets for analysis`);
        console.log(`🏈 Football markets: ${activeMarkets.filter(m => m.ticker.includes('NFL')).length}`);
        console.log(`💰 Crypto markets: ${activeMarkets.filter(m => m.ticker.includes('BTC') || m.ticker.includes('ETH')).length}`);
        console.log(`📈 Financial markets: ${activeMarkets.filter(m => m.ticker.includes('FED') || m.ticker.includes('NASDAQ')).length}\n`);
        
        // Subscribe to general ticker feed
        this.websocket.subscribe('ticker', {});
      }
      
    } catch (error) {
      console.error('Failed to subscribe to markets:', error.message);
    }
  }

  /**
   * Generate comprehensive analysis report
   */
  generateAnalysisReport() {
    console.log('\n📋 === MARKET ANALYSIS REPORT ===\n');
    
    // Overall strategy recommendations
    console.log('🎯 OVERALL STRATEGY RECOMMENDATIONS:');
    const sortedStrategies = Object.entries(this.strategyScores)
      .sort(([,a], [,b]) => b - a)
      .map(([strategy, score]) => ({ strategy, score }));
    
    sortedStrategies.forEach((strategy, index) => {
      const emoji = index === 0 ? '🥇' : index === 1 ? '🥈' : index === 2 ? '🥉' : '📊';
      console.log(`   ${emoji} ${strategy.strategy}: ${strategy.score} points`);
    });
    
    console.log(`\n🏆 RECOMMENDED STRATEGY: ${sortedStrategies[0].strategy.toUpperCase()}`);
    
    // Market-specific insights
    console.log('\n📊 MARKET-SPECIFIC INSIGHTS:');
    const topMarkets = Array.from(this.analysisResults.values())
      .sort((a, b) => {
        const aScore = a.strategyRecommendations[0]?.score || 0;
        const bScore = b.strategyRecommendations[0]?.score || 0;
        return bScore - aScore;
      })
      .slice(0, 10);
    
    topMarkets.forEach((market, index) => {
      if (market.strategyRecommendations.length > 0) {
        const topRec = market.strategyRecommendations[0];
        console.log(`   ${index + 1}. ${market.ticker}: ${topRec.strategy} (${topRec.score} pts) - ${topRec.reasoning}`);
      }
    });
    
    // Detailed statistics
    console.log('\n📈 MARKET STATISTICS:');
    const totalMarkets = this.analysisResults.size;
    const marketsWithSignals = Array.from(this.analysisResults.values())
      .filter(m => m.strategyRecommendations.length > 0).length;
    
    console.log(`   Total Markets Analyzed: ${totalMarkets}`);
    console.log(`   Markets with Trading Signals: ${marketsWithSignals}`);
    console.log(`   Signal Rate: ${(marketsWithSignals / totalMarkets * 100).toFixed(1)}%`);
    
    // Strategy breakdown
    console.log('\n🔍 STRATEGY BREAKDOWN:');
    const strategyCounts = {};
    this.analysisResults.forEach(market => {
      market.strategyRecommendations.forEach(rec => {
        strategyCounts[rec.strategy] = (strategyCounts[rec.strategy] || 0) + 1;
      });
    });
    
    Object.entries(strategyCounts)
      .sort(([,a], [,b]) => b - a)
      .forEach(([strategy, count]) => {
        console.log(`   ${strategy}: ${count} opportunities`);
      });
    
    console.log('\n💡 NEXT STEPS:');
    console.log(`   1. Focus on ${sortedStrategies[0].strategy} strategy`);
    console.log(`   2. Target markets with highest signal scores`);
    console.log(`   3. Adjust parameters based on volatility analysis`);
    console.log(`   4. Consider market-specific conditions`);
    
    console.log('\n═══════════════════════════════════════════\n');
  }

  /**
   * Stop the analysis
   */
  stop() {
    console.log('🛑 Stopping Market Analysis...\n');
    
    if (this.websocket) {
      this.websocket.disconnect();
    }
    
    console.log('👋 Market analysis completed. Goodbye!');
    process.exit(0);
  }
}

// Run the market analyzer
const analyzer = new MarketAnalyzer();

// Handle graceful shutdown
process.on('SIGINT', () => {
  analyzer.stop();
});

analyzer.start().catch((error) => {
  console.error('❌ Market analysis failed:', error.message);
  process.exit(1);
});