@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/ml-prediction.js

@@ -0,0 +1,402 @@
+/**
+ * ML PREDICTION ENGINE
+ * Machine learning based match outcome prediction
+ */
+import { logger } from '../../../utils.js';
+import { ML_CONFIG } from './constants.js';
+/**
+ * ML Prediction Engine
+ * Uses weighted factors and historical patterns for predictions
+ */
+export class MLPredictionEngine {
+    weights = ML_CONFIG.FEATURE_WEIGHTS;
+    historicalData = new Map();
+    constructor() {
+        this.loadHistoricalData();
+    }
+    /**
+     * Predict match outcome
+     */
+    async predict(input) {
+        const factors = [];
+        // Calculate form score
+        const formScore = this.calculateFormScore(input);
+        factors.push({
+            name: 'Recent Form',
+            weight: this.weights.form,
+            impact: formScore > 0 ? 'positive' : formScore < 0 ? 'negative' : 'neutral',
+            description: this.describeFormImpact(input),
+        });
+        // Calculate H2H score
+        const h2hScore = this.calculateH2HScore(input);
+        factors.push({
+            name: 'Head-to-Head',
+            weight: this.weights.h2h,
+            impact: h2hScore > 0 ? 'positive' : h2hScore < 0 ? 'negative' : 'neutral',
+            description: this.describeH2HImpact(input),
+        });
+        // Calculate home advantage
+        const homeAdvantageScore = this.calculateHomeAdvantage(input);
+        factors.push({
+            name: 'Home Advantage',
+            weight: this.weights.home_advantage,
+            impact: homeAdvantageScore > 0 ? 'positive' : 'neutral',
+            description: `Home advantage factor: ${(homeAdvantageScore * 100).toFixed(1)}%`,
+        });
+        // Calculate xG score
+        const xgScore = this.calculateXgScore(input);
+        factors.push({
+            name: 'Expected Goals (xG)',
+            weight: this.weights.xg,
+            impact: xgScore > 0 ? 'positive' : xgScore < 0 ? 'negative' : 'neutral',
+            description: `xG differential: ${(xgScore * 100).toFixed(1)}%`,
+        });
+        // Calculate injury impact
+        const injuryScore = this.calculateInjuryImpact(input);
+        factors.push({
+            name: 'Injuries',
+            weight: this.weights.injuries,
+            impact: injuryScore > 0 ? 'positive' : injuryScore < 0 ? 'negative' : 'neutral',
+            description: this.describeInjuryImpact(input),
+        });
+        // Calculate fatigue impact
+        const fatigueScore = this.calculateFatigueImpact(input);
+        factors.push({
+            name: 'Fatigue',
+            weight: this.weights.fatigue,
+            impact: fatigueScore > 0 ? 'positive' : fatigueScore < 0 ? 'negative' : 'neutral',
+            description: `Fatigue differential: ${(fatigueScore * 100).toFixed(1)}%`,
+        });
+        // Weather impact
+        const weatherScore = this.calculateWeatherImpact(input);
+        factors.push({
+            name: 'Weather',
+            weight: this.weights.weather,
+            impact: weatherScore !== 0 ? (weatherScore > 0 ? 'positive' : 'negative') : 'neutral',
+            description: this.describeWeatherImpact(input),
+        });
+        // Combine all factors
+        const combinedScore = this.combineScores([
+            { score: formScore, weight: this.weights.form },
+            { score: h2hScore, weight: this.weights.h2h },
+            { score: homeAdvantageScore, weight: this.weights.home_advantage },
+            { score: xgScore, weight: this.weights.xg },
+            { score: injuryScore, weight: this.weights.injuries },
+            { score: fatigueScore, weight: this.weights.fatigue },
+            { score: weatherScore, weight: this.weights.weather },
+        ]);
+        // Calculate probabilities
+        const probabilities = this.scoreToProbabilities(combinedScore);
+        // Calculate confidence
+        const confidence = this.calculateConfidence(factors, input);
+        // Calculate additional markets
+        const over25Prob = this.predictOver25(input);
+        const bttsProb = this.predictBTTS(input);
+        logger.info(`[MLPrediction] ${input.match.homeTeam.name} vs ${input.match.awayTeam.name}: ` +
+            `H:${(probabilities.home * 100).toFixed(1)}% D:${(probabilities.draw * 100).toFixed(1)}% A:${(probabilities.away * 100).toFixed(1)}% ` +
+            `Confidence: ${confidence.toFixed(1)}%`);
+        return {
+            homeWin: probabilities.home,
+            draw: probabilities.draw,
+            awayWin: probabilities.away,
+            over25: over25Prob,
+            btts: bttsProb,
+            confidence,
+            factors,
+        };
+    }
+    /**
+     * Calculate form score (-1 to 1)
+     */
+    calculateFormScore(input) {
+        const homePoints = this.formToPoints(input.homeForm.last5);
+        const awayPoints = this.formToPoints(input.awayForm.last5);
+        // Normalize to -1 to 1
+        const maxPoints = 15; // 5 wins = 15 points
+        const homeNormalized = (homePoints / maxPoints) * 2 - 1;
+        const awayNormalized = (awayPoints / maxPoints) * 2 - 1;
+        return homeNormalized - awayNormalized;
+    }
+    formToPoints(form) {
+        return form.reduce((sum, result) => {
+            if (result === 'W')
+                return sum + 3;
+            if (result === 'D')
+                return sum + 1;
+            return sum;
+        }, 0);
+    }
+    /**
+     * Calculate H2H score (-1 to 1)
+     */
+    calculateH2HScore(input) {
+        const h2h = input.h2h;
+        const total = h2h.totalMatches;
+        if (total === 0)
+            return 0;
+        const homeWinRate = h2h.homeWins / total;
+        const awayWinRate = h2h.awayWins / total;
+        // Weight recent matches more heavily
+        const recentMatches = h2h.recentMatches.slice(0, 5);
+        let recentScore = 0;
+        recentMatches.forEach((match, index) => {
+            const weight = (5 - index) / 5; // More recent = higher weight
+            if (match.score) {
+                if (match.score.home > match.score.away)
+                    recentScore += weight;
+                else if (match.score.home < match.score.away)
+                    recentScore -= weight;
+            }
+        });
+        // Combine historical and recent
+        const historicalScore = homeWinRate - awayWinRate;
+        const combinedScore = (historicalScore * 0.4) + (recentScore / 5 * 0.6);
+        return Math.max(-1, Math.min(1, combinedScore));
+    }
+    /**
+     * Calculate home advantage score (0 to 1)
+     */
+    calculateHomeAdvantage(input) {
+        const homeStats = input.homeStats;
+        const awayStats = input.awayStats;
+        if (!homeStats?.homeStats || !awayStats?.awayStats) {
+            return 0.1; // Default home advantage
+        }
+        const homeWinRate = homeStats.homeStats.wins / (homeStats.homeStats.matchesPlayed || 1);
+        const awayWinRate = awayStats.awayStats.wins / (awayStats.awayStats.matchesPlayed || 1);
+        return Math.max(0, homeWinRate - awayWinRate);
+    }
+    /**
+     * Calculate xG score (-1 to 1)
+     */
+    calculateXgScore(input) {
+        const homeXg = input.homeForm.xG;
+        const homeXga = input.homeForm.xGA;
+        const awayXg = input.awayForm.xG;
+        const awayXga = input.awayForm.xGA;
+        // xG differential (attack - defense)
+        const homeXgDiff = homeXg - homeXga;
+        const awayXgDiff = awayXg - awayXga;
+        // Normalize (typical range is -1 to 1 per game)
+        const normalized = (homeXgDiff - awayXgDiff) / 2;
+        return Math.max(-1, Math.min(1, normalized));
+    }
+    /**
+     * Calculate injury impact (-1 to 1)
+     */
+    calculateInjuryImpact(input) {
+        const homeKeyInjuries = input.injuries.home.keyPlayers;
+        const awayKeyInjuries = input.injuries.away.keyPlayers;
+        // Each key player injury is worth ~0.1
+        const impact = (awayKeyInjuries - homeKeyInjuries) * 0.1;
+        return Math.max(-1, Math.min(1, impact));
+    }
+    /**
+     * Calculate fatigue impact (-1 to 1)
+     */
+    calculateFatigueImpact(input) {
+        // This would need actual fatigue data
+        // For now, use matches played as proxy
+        const homeMatches = input.homeStats.matchesPlayed;
+        const awayMatches = input.awayStats.matchesPlayed;
+        // More matches = more fatigue
+        const diff = awayMatches - homeMatches;
+        const impact = diff * 0.02; // Each match difference = 2%
+        return Math.max(-1, Math.min(1, impact));
+    }
+    /**
+     * Calculate weather impact (-0.5 to 0.5)
+     */
+    calculateWeatherImpact(input) {
+        if (!input.weather)
+            return 0;
+        const weather = input.weather;
+        let impact = 0;
+        // Rain favors defensive teams
+        if (weather.precipitation) {
+            impact -= 0.1;
+        }
+        // High wind affects passing teams
+        if (weather.windSpeed > 20) {
+            impact -= 0.1;
+        }
+        // Extreme temperatures
+        if (weather.temperature > 30 || weather.temperature < 0) {
+            impact -= 0.05;
+        }
+        return impact;
+    }
+    /**
+     * Combine weighted scores
+     */
+    combineScores(scores) {
+        const totalWeight = scores.reduce((sum, s) => sum + s.weight, 0);
+        const weightedSum = scores.reduce((sum, s) => sum + (s.score * s.weight), 0);
+        return weightedSum / totalWeight;
+    }
+    /**
+     * Convert score to probabilities
+     */
+    scoreToProbabilities(score) {
+        // Score is from -1 (away advantage) to 1 (home advantage)
+        // Convert to probabilities using softmax-like function
+        const homeExp = Math.exp(score * 2);
+        const drawExp = Math.exp(0); // Neutral
+        const awayExp = Math.exp(-score * 2);
+        const total = homeExp + drawExp + awayExp;
+        return {
+            home: homeExp / total,
+            draw: drawExp / total,
+            away: awayExp / total,
+        };
+    }
+    /**
+     * Calculate confidence level
+     */
+    calculateConfidence(factors, input) {
+        let confidence = 50; // Base confidence
+        // More data = higher confidence
+        if (input.homeForm.last5.length >= 5)
+            confidence += 10;
+        if (input.awayForm.last5.length >= 5)
+            confidence += 10;
+        if (input.h2h.totalMatches >= 3)
+            confidence += 10;
+        // High impact factors increase confidence
+        const highImpactFactors = factors.filter(f => Math.abs(f.weight) > 0.15 && f.impact !== 'neutral').length;
+        confidence += highImpactFactors * 5;
+        // Cap at 95%
+        return Math.min(95, confidence);
+    }
+    /**
+     * Predict Over 2.5 goals
+     */
+    predictOver25(input) {
+        const homeXg = input.homeForm.xG / 5; // per game
+        const awayXg = input.awayForm.xG / 5;
+        const homeXga = input.homeForm.xGA / 5;
+        const awayXga = input.awayForm.xGA / 5;
+        const expectedGoals = (homeXg + awayXga + awayXg + homeXga) / 2;
+        // Convert to probability
+        return Math.min(0.9, Math.max(0.1, expectedGoals / 3));
+    }
+    /**
+     * Predict Both Teams to Score
+     */
+    predictBTTS(input) {
+        const homeScoring = input.homeForm.goalsFor / 5;
+        const awayScoring = input.awayForm.goalsFor / 5;
+        const homeConceding = input.homeForm.goalsAgainst / 5;
+        const awayConceding = input.awayForm.goalsAgainst / 5;
+        const homeLikelyToScore = homeScoring > 1 ? 0.7 : homeScoring > 0.5 ? 0.5 : 0.3;
+        const awayLikelyToScore = awayScoring > 1 ? 0.7 : awayScoring > 0.5 ? 0.5 : 0.3;
+        return homeLikelyToScore * awayLikelyToScore;
+    }
+    /**
+     * Describe form impact
+     */
+    describeFormImpact(input) {
+        const homePoints = this.formToPoints(input.homeForm.last5);
+        const awayPoints = this.formToPoints(input.awayForm.last5);
+        if (homePoints > awayPoints + 4) {
+            return `${input.match.homeTeam.name} in significantly better form`;
+        }
+        else if (awayPoints > homePoints + 4) {
+            return `${input.match.awayTeam.name} in significantly better form`;
+        }
+        else if (Math.abs(homePoints - awayPoints) <= 2) {
+            return 'Teams in similar form';
+        }
+        return 'Form advantage detected';
+    }
+    /**
+     * Describe H2H impact
+     */
+    describeH2HImpact(input) {
+        const h2h = input.h2h;
+        if (h2h.totalMatches === 0) {
+            return 'No recent head-to-head data';
+        }
+        const homeWinRate = (h2h.homeWins / h2h.totalMatches * 100).toFixed(0);
+        return `${input.match.homeTeam.name} won ${homeWinRate}% of ${h2h.totalMatches} meetings`;
+    }
+    /**
+     * Describe injury impact
+     */
+    describeInjuryImpact(input) {
+        const homeKey = input.injuries.home.keyPlayers;
+        const awayKey = input.injuries.away.keyPlayers;
+        if (homeKey === 0 && awayKey === 0) {
+            return 'No key injuries for either team';
+        }
+        else if (homeKey > awayKey) {
+            return `${input.match.homeTeam.name} has ${homeKey} key player(s) injured`;
+        }
+        else if (awayKey > homeKey) {
+            return `${input.match.awayTeam.name} has ${awayKey} key player(s) injured`;
+        }
+        return 'Both teams have similar injury concerns';
+    }
+    /**
+     * Describe weather impact
+     */
+    describeWeatherImpact(input) {
+        if (!input.weather)
+            return 'Weather data not available';
+        const conditions = [];
+        if (input.weather.precipitation)
+            conditions.push('rain');
+        if (input.weather.windSpeed > 20)
+            conditions.push('high wind');
+        if (input.weather.temperature > 30)
+            conditions.push('hot');
+        if (input.weather.temperature < 5)
+            conditions.push('cold');
+        if (conditions.length === 0) {
+            return 'Good weather conditions';
+        }
+        return `Adverse conditions: ${conditions.join(', ')}`;
+    }
+    /**
+     * Load historical data
+     */
+    loadHistoricalData() {
+        // Would load from database or file
+        // For now, start empty
+    }
+    /**
+     * Learn from past predictions
+     */
+    learnFromResult(prediction, actualResult, odds) {
+        // Update weights based on accuracy
+        // This is a simplified version - real ML would use gradient descent
+        const predictedOutcome = prediction.homeWin > prediction.draw && prediction.homeWin > prediction.awayWin
+            ? 'home'
+            : prediction.awayWin > prediction.draw
+                ? 'away'
+                : 'draw';
+        const wasCorrect = predictedOutcome === actualResult;
+        if (wasCorrect) {
+            logger.info(`[MLPrediction] Correct prediction at ${odds}x`);
+        }
+        else {
+            logger.info(`[MLPrediction] Incorrect prediction. Predicted: ${predictedOutcome}, Actual: ${actualResult}`);
+        }
+        // Store for analysis
+        this.historicalData.set(`result-${Date.now()}`, {
+            prediction,
+            actualResult,
+            odds,
+            wasCorrect,
+            timestamp: Date.now(),
+        });
+    }
+}
+// Singleton instance
+let globalPredictionEngine = null;
+export function getPredictionEngine() {
+    if (!globalPredictionEngine) {
+        globalPredictionEngine = new MLPredictionEngine();
+    }
+    return globalPredictionEngine;
+}

package/dist/tools/sports/core/realtime-manager.d.ts

@@ -0,0 +1,102 @@
+/**
+ * REALTIME DATA MANAGER
+ * WebSocket/SSE based real-time data streaming with fallback polling
+ */
+import { EventEmitter } from 'events';
+import type { Match } from './types.js';
+export interface LiveEvent {
+    type: 'goal' | 'card' | 'substitution' | 'var' | 'injury' | 'whistle' | 'odds_change' | 'status_change';
+    matchId: string;
+    timestamp: number;
+    minute?: number;
+    data: any;
+}
+export interface OddsChangeEvent extends LiveEvent {
+    type: 'odds_change';
+    data: {
+        bookmaker: string;
+        market: string;
+        selection: string;
+        oldOdds: number;
+        newOdds: number;
+        change: number;
+        timestamp: number;
+    };
+}
+export declare class RealtimeDataManager extends EventEmitter {
+    private cache;
+    private wsConnections;
+    private pollingIntervals;
+    private reconnectAttempts;
+    private isRunning;
+    constructor();
+    /**
+     * Start the realtime manager
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the realtime manager
+     */
+    stop(): void;
+    /**
+     * Subscribe to a specific match's events
+     */
+    subscribeToMatch(matchId: string, callback: (event: LiveEvent) => void): () => void;
+    /**
+     * Subscribe to odds changes for a match
+     */
+    subscribeToOdds(matchId: string, callback: (event: OddsChangeEvent) => void): () => void;
+    /**
+     * Subscribe to all live events
+     */
+    subscribeToAllEvents(callback: (event: LiveEvent) => void): () => void;
+    /**
+     * Process and broadcast an event
+     */
+    processEvent(event: LiveEvent): void;
+    /**
+     * Get current live matches
+     */
+    getLiveMatches(): Match[];
+    /**
+     * Get match events history
+     */
+    getMatchEvents(matchId: string): LiveEvent[];
+    /**
+     * Connect to match stream (WebSocket or polling)
+     */
+    private connectToMatchStream;
+    /**
+     * Unsubscribe from a match
+     */
+    private unsubscribeFromMatch;
+    /**
+     * Start polling for live scores
+     */
+    private startLiveScoresPolling;
+    /**
+     * Start polling for odds
+     */
+    private startOddsPolling;
+    /**
+     * Start polling for specific match events
+     */
+    private startMatchEventsPolling;
+    /**
+     * Detect score changes and emit goal events
+     */
+    private detectScoreChanges;
+    /**
+     * Detect odds changes and emit events
+     */
+    private detectOddsChanges;
+    /**
+     * Update cache with event
+     */
+    private updateCache;
+    private fetchLiveScores;
+    private fetchOdds;
+    private fetchMatchEvents;
+}
+export declare function getRealtimeManager(): RealtimeDataManager;
+export declare function resetRealtimeManager(): void;