@gotza02/sequential-thinking 10000.1.0 → 10000.1.2

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

@@ -1,25 +1,19 @@
 /**
  * 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
- */
+// Simple logger fallback
+const logger = {
+    info: (...args) => console.error('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    debug: (...args) => { }
+};
 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',
@@ -27,7 +21,6 @@ export class MLPredictionEngine {
             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',
@@ -35,7 +28,6 @@ export class MLPredictionEngine {
             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',
@@ -43,7 +35,6 @@ export class MLPredictionEngine {
             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)',
@@ -51,7 +42,6 @@ export class MLPredictionEngine {
             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',
@@ -59,7 +49,6 @@ export class MLPredictionEngine {
             impact: injuryScore > 0 ? 'positive' : injuryScore < 0 ? 'negative' : 'neutral',
             description: this.describeInjuryImpact(input),
         });
-        // Calculate fatigue impact
         const fatigueScore = this.calculateFatigueImpact(input);
         factors.push({
             name: 'Fatigue',
@@ -67,7 +56,6 @@ export class MLPredictionEngine {
             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',
@@ -75,7 +63,6 @@ export class MLPredictionEngine {
             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 },
@@ -85,16 +72,12 @@ export class MLPredictionEngine {
             { 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)}%`);
+            `H:${(probabilities.home * 100).toFixed(1)}% D:${(probabilities.draw * 100).toFixed(1)}% A:${(probabilities.away * 100).toFixed(1)}%`);
         return {
             homeWin: probabilities.home,
             draw: probabilities.draw,
@@ -105,14 +88,10 @@ export class MLPredictionEngine {
             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 maxPoints = 15;
         const homeNormalized = (homePoints / maxPoints) * 2 - 1;
         const awayNormalized = (awayPoints / maxPoints) * 2 - 1;
         return homeNormalized - awayNormalized;
@@ -126,9 +105,6 @@ export class MLPredictionEngine {
             return sum;
         }, 0);
     }
-    /**
-     * Calculate H2H score (-1 to 1)
-     */
     calculateH2HScore(input) {
         const h2h = input.h2h;
         const total = h2h.totalMatches;
@@ -136,210 +112,117 @@ export class MLPredictionEngine {
             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
+        const recentScore = h2h.recentMatches.slice(0, 5).reduce((score, match, index) => {
+            const weight = (5 - index) / 5;
             if (match.score) {
                 if (match.score.home > match.score.away)
-                    recentScore += weight;
-                else if (match.score.home < match.score.away)
-                    recentScore -= weight;
+                    return score + weight;
+                if (match.score.home < match.score.away)
+                    return score - weight;
             }
-        });
-        // Combine historical and recent
+            return score;
+        }, 0);
         const historicalScore = homeWinRate - awayWinRate;
-        const combinedScore = (historicalScore * 0.4) + (recentScore / 5 * 0.6);
-        return Math.max(-1, Math.min(1, combinedScore));
+        return Math.max(-1, Math.min(1, (historicalScore * 0.4) + (recentScore / 5 * 0.6)));
     }
-    /**
-     * 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
-        }
+        if (!homeStats?.homeStats || !awayStats?.awayStats)
+            return 0.1;
         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));
+        const homeXgDiff = input.homeForm.xG - input.homeForm.xGA;
+        const awayXgDiff = input.awayForm.xG - input.awayForm.xGA;
+        return Math.max(-1, Math.min(1, (homeXgDiff - awayXgDiff) / 2));
     }
-    /**
-     * 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;
+        const impact = (input.injuries.away.keyPlayers - input.injuries.home.keyPlayers) * 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));
+        const diff = input.awayStats.matchesPlayed - input.homeStats.matchesPlayed;
+        return Math.max(-1, Math.min(1, diff * 0.02));
     }
-    /**
-     * 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) {
+        if (input.weather.precipitation)
             impact -= 0.1;
-        }
-        // High wind affects passing teams
-        if (weather.windSpeed > 20) {
+        if (input.weather.windSpeed > 20)
             impact -= 0.1;
-        }
-        // Extreme temperatures
-        if (weather.temperature > 30 || weather.temperature < 0) {
+        if (input.weather.temperature > 30 || input.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 drawExp = Math.exp(0);
         const awayExp = Math.exp(-score * 2);
         const total = homeExp + drawExp + awayExp;
-        return {
-            home: homeExp / total,
-            draw: drawExp / total,
-            away: awayExp / total,
-        };
+        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
+        let confidence = 50;
         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
+        const expectedGoals = (input.homeForm.xG / 5 + input.awayForm.xGA / 5 + input.awayForm.xG / 5 + input.homeForm.xGA / 5) / 2;
         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) {
+        if (homePoints > awayPoints + 4)
             return `${input.match.homeTeam.name} in significantly better form`;
-        }
-        else if (awayPoints > homePoints + 4) {
+        if (awayPoints > homePoints + 4)
             return `${input.match.awayTeam.name} in significantly better form`;
-        }
-        else if (Math.abs(homePoints - awayPoints) <= 2) {
+        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) {
+        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) {
+        if (homeKey === 0 && awayKey === 0)
             return 'No key injuries for either team';
-        }
-        else if (homeKey > awayKey) {
+        if (homeKey > awayKey)
             return `${input.match.homeTeam.name} has ${homeKey} key player(s) injured`;
-        }
-        else if (awayKey > homeKey) {
+        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';
@@ -352,29 +235,13 @@ export class MLPredictionEngine {
             conditions.push('hot');
         if (input.weather.temperature < 5)
             conditions.push('cold');
-        if (conditions.length === 0) {
+        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';
+            ? 'home' : prediction.awayWin > prediction.draw ? 'away' : 'draw';
         const wasCorrect = predictedOutcome === actualResult;
         if (wasCorrect) {
             logger.info(`[MLPrediction] Correct prediction at ${odds}x`);
@@ -382,21 +249,12 @@ export class MLPredictionEngine {
         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(),
-        });
+        this.historicalData.set(`result-${Date.now()}`, { prediction, actualResult, odds, wasCorrect, timestamp: Date.now() });
     }
 }
-// Singleton instance
 let globalPredictionEngine = null;
 export function getPredictionEngine() {
-    if (!globalPredictionEngine) {
+    if (!globalPredictionEngine)
         globalPredictionEngine = new MLPredictionEngine();
-    }
     return globalPredictionEngine;
 }

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

@@ -1,6 +1,6 @@
 /**
  * REALTIME DATA MANAGER
- * WebSocket/SSE based real-time data streaming with fallback polling
+ * Polling-based real-time data streaming
  */
 import { EventEmitter } from 'events';
 import type { Match } from './types.js';
@@ -25,74 +25,23 @@ export interface OddsChangeEvent extends LiveEvent {
 }
 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;