@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/historical-analyzer.js

@@ -0,0 +1,461 @@
+/**
+ * HISTORICAL ANALYZER
+ * Analyzes historical data for patterns and trends
+ */
+/**
+ * Historical Analyzer
+ * Analyzes past matches for patterns and predictive insights
+ */
+export class HistoricalAnalyzer {
+    matchHistory = [];
+    patterns = new Map();
+    constructor() {
+        this.loadHistoricalData();
+    }
+    /**
+     * Analyze team performance over time
+     */
+    analyzeTeamPerformance(teamId, query) {
+        const matches = this.getTeamMatches(teamId, query);
+        if (matches.length === 0) {
+            return this.createEmptyPerformance(teamId);
+        }
+        const wins = matches.filter(m => this.isWin(m, teamId)).length;
+        const draws = matches.filter(m => this.isDraw(m)).length;
+        const losses = matches.filter(m => this.isLoss(m, teamId)).length;
+        const totalGoalsFor = matches.reduce((sum, m) => sum + this.getGoalsFor(m, teamId), 0);
+        const totalGoalsAgainst = matches.reduce((sum, m) => sum + this.getGoalsAgainst(m, teamId), 0);
+        const patterns = this.findPatterns(teamId, matches);
+        return {
+            team: matches[0].homeTeam.id === teamId ? matches[0].homeTeam : matches[0].awayTeam,
+            totalMatches: matches.length,
+            wins,
+            draws,
+            losses,
+            avgGoalsFor: totalGoalsFor / matches.length,
+            avgGoalsAgainst: totalGoalsAgainst / matches.length,
+            homeAdvantage: this.calculateHomeAdvantage(teamId, matches),
+            patterns,
+        };
+    }
+    /**
+     * Analyze head-to-head history
+     */
+    analyzeHeadToHead(teamAId, teamBId, limit = 10) {
+        const matches = this.getH2HMatches(teamAId, teamBId, limit);
+        let homeWins = 0;
+        let awayWins = 0;
+        let draws = 0;
+        let homeGoals = 0;
+        let awayGoals = 0;
+        matches.forEach(match => {
+            if (!match.score)
+                return;
+            const isTeamAHome = match.homeTeam.id === teamAId;
+            if (match.score.home > match.score.away) {
+                if (isTeamAHome)
+                    homeWins++;
+                else
+                    awayWins++;
+            }
+            else if (match.score.home < match.score.away) {
+                if (isTeamAHome)
+                    awayWins++;
+                else
+                    homeWins++;
+            }
+            else {
+                draws++;
+            }
+            homeGoals += isTeamAHome ? match.score.home : match.score.away;
+            awayGoals += isTeamAHome ? match.score.away : match.score.home;
+        });
+        return {
+            homeTeam: matches[0]?.homeTeam || { id: teamAId, name: '', country: '' },
+            awayTeam: matches[0]?.awayTeam || { id: teamBId, name: '', country: '' },
+            totalMatches: matches.length,
+            homeWins,
+            draws,
+            awayWins,
+            homeGoals,
+            awayGoals,
+            recentMatches: matches.slice(0, 5),
+        };
+    }
+    /**
+     * Analyze trends for a team
+     */
+    analyzeTrends(teamId, windowSize = 5) {
+        const matches = this.getTeamMatches(teamId).slice(0, windowSize);
+        if (matches.length < 3) {
+            return {
+                direction: 'stable',
+                strength: 0,
+                confidence: 0,
+                dataPoints: matches.length,
+                description: 'Insufficient data for trend analysis',
+            };
+        }
+        // Calculate performance in recent matches
+        const recentPerformance = matches.slice(0, Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
+        const olderPerformance = matches.slice(Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
+        const recentAvg = recentPerformance.reduce((a, b) => a + b, 0) / recentPerformance.length;
+        const olderAvg = olderPerformance.reduce((a, b) => a + b, 0) / olderPerformance.length;
+        const difference = recentAvg - olderAvg;
+        const strength = Math.min(1, Math.abs(difference) / 2);
+        let direction;
+        if (difference > 0.5)
+            direction = 'up';
+        else if (difference < -0.5)
+            direction = 'down';
+        else
+            direction = 'stable';
+        const description = direction === 'up'
+            ? `Team improving: ${recentAvg.toFixed(2)} pts/game recently vs ${olderAvg.toFixed(2)} before`
+            : direction === 'down'
+                ? `Team declining: ${recentAvg.toFixed(2)} pts/game recently vs ${olderAvg.toFixed(2)} before`
+                : `Team stable: ${recentAvg.toFixed(2)} pts/game`;
+        return {
+            direction,
+            strength,
+            confidence: Math.min(100, matches.length * 10),
+            dataPoints: matches.length,
+            description,
+        };
+    }
+    /**
+     * Calculate performance metrics
+     */
+    calculateMetrics(teamId, query) {
+        const matches = this.getTeamMatches(teamId, query);
+        if (matches.length === 0) {
+            return {
+                winRate: 0,
+                drawRate: 0,
+                lossRate: 0,
+                avgGoalsFor: 0,
+                avgGoalsAgainst: 0,
+                cleanSheetRate: 0,
+                bothTeamsScoreRate: 0,
+                over25Rate: 0,
+            };
+        }
+        const wins = matches.filter(m => this.isWin(m, teamId)).length;
+        const draws = matches.filter(m => this.isDraw(m)).length;
+        const losses = matches.filter(m => this.isLoss(m, teamId)).length;
+        const totalGoalsFor = matches.reduce((sum, m) => sum + this.getGoalsFor(m, teamId), 0);
+        const totalGoalsAgainst = matches.reduce((sum, m) => sum + this.getGoalsAgainst(m, teamId), 0);
+        const cleanSheets = matches.filter(m => this.getGoalsAgainst(m, teamId) === 0).length;
+        const btts = matches.filter(m => this.getGoalsFor(m, teamId) > 0 && this.getGoalsAgainst(m, teamId) > 0).length;
+        const over25 = matches.filter(m => {
+            const total = this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId);
+            return total > 2.5;
+        }).length;
+        return {
+            winRate: wins / matches.length,
+            drawRate: draws / matches.length,
+            lossRate: losses / matches.length,
+            avgGoalsFor: totalGoalsFor / matches.length,
+            avgGoalsAgainst: totalGoalsAgainst / matches.length,
+            cleanSheetRate: cleanSheets / matches.length,
+            bothTeamsScoreRate: btts / matches.length,
+            over25Rate: over25 / matches.length,
+        };
+    }
+    /**
+     * Find betting patterns
+     */
+    findBettingPatterns(query) {
+        const patterns = [];
+        const matches = this.queryMatches(query);
+        // Pattern: Home favorites
+        const homeFavorites = matches.filter(m => m.odds && m.odds.homeWin < 1.5 && m.score && m.score.home > m.score.away);
+        if (homeFavorites.length >= 5) {
+            patterns.push({
+                pattern: 'Home favorites win',
+                occurrence: homeFavorites.length,
+                successRate: homeFavorites.length / matches.filter(m => m.odds?.homeWin < 1.5).length,
+                avgOdds: homeFavorites.reduce((sum, m) => sum + (m.odds?.homeWin || 0), 0) / homeFavorites.length,
+                profit: this.calculateProfit(homeFavorites, 'home'),
+            });
+        }
+        // Pattern: Under 2.5 in low-scoring leagues
+        const lowScoringMatches = matches.filter(m => {
+            const total = (m.score?.home || 0) + (m.score?.away || 0);
+            return total < 2.5;
+        });
+        if (lowScoringMatches.length >= 10) {
+            patterns.push({
+                pattern: 'Under 2.5 goals',
+                occurrence: lowScoringMatches.length,
+                successRate: lowScoringMatches.length / matches.length,
+                avgOdds: 1.8, // Typical under 2.5 odds
+                profit: (lowScoringMatches.length * 0.8 - (matches.length - lowScoringMatches.length)) * 10,
+            });
+        }
+        // Pattern: BTTS
+        const bttsMatches = matches.filter(m => (m.score?.home || 0) > 0 && (m.score?.away || 0) > 0);
+        if (bttsMatches.length >= 10) {
+            patterns.push({
+                pattern: 'Both teams score',
+                occurrence: bttsMatches.length,
+                successRate: bttsMatches.length / matches.length,
+                avgOdds: 1.9, // Typical BTTS odds
+                profit: (bttsMatches.length * 0.9 - (matches.length - bttsMatches.length)) * 10,
+            });
+        }
+        return patterns.sort((a, b) => b.profit - a.profit);
+    }
+    /**
+     * Analyze referee bias
+     */
+    analyzeRefereeBias(refereeName, teamId) {
+        const matches = this.matchHistory.filter(m => m.referee?.name === refereeName && m.status === 'finished');
+        const homeWins = matches.filter(m => m.score && m.score.home > m.score.away).length;
+        // Calculate team bias if teamId provided
+        let teamBias;
+        if (teamId) {
+            const teamMatches = matches.filter(m => m.homeTeam.id === teamId || m.awayTeam.id === teamId);
+            const teamWins = teamMatches.filter(m => this.isWin(m, teamId)).length;
+            teamBias = teamWins / (teamMatches.length || 1);
+        }
+        return {
+            referee: refereeName,
+            matches: matches.length,
+            avgCards: 3.5, // Placeholder
+            homeWinRate: homeWins / (matches.length || 1),
+            teamBias,
+        };
+    }
+    /**
+     * Analyze weather impact
+     */
+    analyzeWeatherImpact(condition, teamId) {
+        const matches = this.matchHistory.filter(m => m.weather?.condition === condition && m.status === 'finished');
+        const totalGoals = matches.reduce((sum, m) => sum + (m.score?.home || 0) + (m.score?.away || 0), 0);
+        const homeWins = matches.filter(m => m.score && m.score.home > m.score.away).length;
+        let teamPerformance;
+        if (teamId) {
+            const teamMatches = matches.filter(m => m.homeTeam.id === teamId || m.awayTeam.id === teamId);
+            const points = teamMatches.reduce((sum, m) => sum + this.getMatchPoints(m, teamId), 0);
+            teamPerformance = points / (teamMatches.length || 1);
+        }
+        return {
+            condition,
+            matches: matches.length,
+            avgGoals: totalGoals / (matches.length || 1),
+            homeWinRate: homeWins / (matches.length || 1),
+            teamPerformance,
+        };
+    }
+    /**
+     * Get similar matches
+     */
+    findSimilarMatches(match, limit = 5) {
+        return this.matchHistory
+            .filter(m => m.id !== match.id &&
+            m.status === 'finished' &&
+            m.league.id === match.league.id)
+            .map(m => ({
+            match: m,
+            similarity: this.calculateSimilarity(match, m),
+        }))
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit)
+            .map(r => r.match);
+    }
+    /**
+     * Calculate similarity between two matches
+     */
+    calculateSimilarity(matchA, matchB) {
+        let score = 0;
+        // Same league
+        if (matchA.league.id === matchB.league.id)
+            score += 0.3;
+        // Similar odds
+        if (matchA.odds && matchB.odds) {
+            const oddsDiff = Math.abs(matchA.odds.homeWin - matchB.odds.homeWin);
+            score += Math.max(0, 0.3 - oddsDiff);
+        }
+        // Similar teams (by position)
+        if (matchA.homeTeam.stats?.position && matchB.homeTeam.stats?.position) {
+            const posDiff = Math.abs(matchA.homeTeam.stats.position - matchB.homeTeam.stats.position);
+            score += Math.max(0, 0.2 - (posDiff / 20));
+        }
+        // Same venue type
+        if (matchA.venue && matchB.venue)
+            score += 0.2;
+        return score;
+    }
+    // Helper methods
+    getTeamMatches(teamId, query) {
+        let matches = this.matchHistory.filter(m => (m.homeTeam.id === teamId || m.awayTeam.id === teamId) &&
+            m.status === 'finished');
+        if (query?.dateFrom) {
+            matches = matches.filter(m => m.date >= query.dateFrom);
+        }
+        if (query?.dateTo) {
+            matches = matches.filter(m => m.date <= query.dateTo);
+        }
+        if (query?.venue) {
+            matches = matches.filter(m => query.venue === 'home' ? m.homeTeam.id === teamId :
+                query.venue === 'away' ? m.awayTeam.id === teamId :
+                    true);
+        }
+        return matches.sort((a, b) => b.date.getTime() - a.date.getTime());
+    }
+    getH2HMatches(teamAId, teamBId, limit) {
+        return this.matchHistory
+            .filter(m => ((m.homeTeam.id === teamAId && m.awayTeam.id === teamBId) ||
+            (m.homeTeam.id === teamBId && m.awayTeam.id === teamAId)) &&
+            m.status === 'finished')
+            .sort((a, b) => b.date.getTime() - a.date.getTime())
+            .slice(0, limit);
+    }
+    isWin(match, teamId) {
+        if (!match.score)
+            return false;
+        const isHome = match.homeTeam.id === teamId;
+        return isHome
+            ? match.score.home > match.score.away
+            : match.score.away > match.score.home;
+    }
+    isDraw(match) {
+        if (!match.score)
+            return false;
+        return match.score.home === match.score.away;
+    }
+    isLoss(match, teamId) {
+        if (!match.score)
+            return false;
+        const isHome = match.homeTeam.id === teamId;
+        return isHome
+            ? match.score.home < match.score.away
+            : match.score.away < match.score.home;
+    }
+    getGoalsFor(match, teamId) {
+        if (!match.score)
+            return 0;
+        return match.homeTeam.id === teamId
+            ? match.score.home
+            : match.score.away;
+    }
+    getGoalsAgainst(match, teamId) {
+        if (!match.score)
+            return 0;
+        return match.homeTeam.id === teamId
+            ? match.score.away
+            : match.score.home;
+    }
+    getMatchPoints(match, teamId) {
+        if (this.isWin(match, teamId))
+            return 3;
+        if (this.isDraw(match))
+            return 1;
+        return 0;
+    }
+    calculateHomeAdvantage(teamId, matches) {
+        const homeMatches = matches.filter(m => m.homeTeam.id === teamId);
+        const awayMatches = matches.filter(m => m.awayTeam.id === teamId);
+        if (homeMatches.length === 0 || awayMatches.length === 0)
+            return 0;
+        const homeWinRate = homeMatches.filter(m => this.isWin(m, teamId)).length / homeMatches.length;
+        const awayWinRate = awayMatches.filter(m => this.isWin(m, teamId)).length / awayMatches.length;
+        return homeWinRate - awayWinRate;
+    }
+    findPatterns(teamId, matches) {
+        const patterns = [];
+        // Pattern: Strong at home
+        const homeMatches = matches.filter(m => m.homeTeam.id === teamId);
+        const homeWins = homeMatches.filter(m => this.isWin(m, teamId)).length;
+        if (homeMatches.length >= 5 && homeWins / homeMatches.length > 0.6) {
+            patterns.push({
+                pattern: 'Strong home record',
+                occurrence: homeWins,
+                successRate: homeWins / homeMatches.length,
+                avgOdds: 1.8,
+                profit: 0,
+            });
+        }
+        // Pattern: High scoring
+        const highScoring = matches.filter(m => this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId) > 2.5);
+        if (highScoring.length / matches.length > 0.6) {
+            patterns.push({
+                pattern: 'High scoring matches',
+                occurrence: highScoring.length,
+                successRate: highScoring.length / matches.length,
+                avgOdds: 1.9,
+                profit: 0,
+            });
+        }
+        return patterns;
+    }
+    calculateProfit(matches, betOn) {
+        let profit = 0;
+        matches.forEach(m => {
+            if (!m.odds || !m.score)
+                return;
+            const won = betOn === 'home' && m.score.home > m.score.away ||
+                betOn === 'away' && m.score.away > m.score.home ||
+                betOn === 'draw' && m.score.home === m.score.away;
+            if (won) {
+                profit += (m.odds[betOn === 'home' ? 'homeWin' : betOn === 'away' ? 'awayWin' : 'draw'] - 1) * 10;
+            }
+            else {
+                profit -= 10;
+            }
+        });
+        return profit;
+    }
+    queryMatches(query) {
+        let matches = this.matchHistory.filter(m => m.status === 'finished');
+        if (query.team) {
+            matches = matches.filter(m => m.homeTeam.name === query.team || m.awayTeam.name === query.team);
+        }
+        if (query.league) {
+            matches = matches.filter(m => m.league.name === query.league);
+        }
+        if (query.dateFrom) {
+            matches = matches.filter(m => m.date >= query.dateFrom);
+        }
+        if (query.dateTo) {
+            matches = matches.filter(m => m.date <= query.dateTo);
+        }
+        return matches;
+    }
+    createEmptyPerformance(teamId) {
+        return {
+            team: { id: teamId, name: '', country: '' },
+            totalMatches: 0,
+            wins: 0,
+            draws: 0,
+            losses: 0,
+            avgGoalsFor: 0,
+            avgGoalsAgainst: 0,
+            homeAdvantage: 0,
+            patterns: [],
+        };
+    }
+    loadHistoricalData() {
+        // Would load from database
+        // For now, start empty
+    }
+    /**
+     * Add match to history
+     */
+    addMatch(match) {
+        this.matchHistory.push(match);
+        // Keep only last 1000 matches
+        if (this.matchHistory.length > 1000) {
+            this.matchHistory.shift();
+        }
+    }
+}
+// Singleton instance
+let globalHistoricalAnalyzer = null;
+export function getHistoricalAnalyzer() {
+    if (!globalHistoricalAnalyzer) {
+        globalHistoricalAnalyzer = new HistoricalAnalyzer();
+    }
+    return globalHistoricalAnalyzer;
+}

package/dist/tools/sports/core/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SPORTS MODULE CORE - Exports
+ */
+export * from './types.js';
+export { CacheService, getGlobalCache, resetGlobalCache } from './cache.js';
+export { CircuitBreaker, CircuitBreakerOpenError, getCircuitBreaker, getAllCircuitBreakerStatus } from './circuit-breaker.js';
+export { withRetry, withRetryAndCircuitBreaker, createRetryable, DEFAULT_RETRY_CONFIG, AGGRESSIVE_RETRY_CONFIG, LIVE_DATA_RETRY_CONFIG } from './retry.js';
+export { RealtimeDataManager, getRealtimeManager, resetRealtimeManager } from './realtime-manager.js';
+export { AlertManager, getAlertManager, resetAlertManager } from './alert-manager.js';
+export { DataQualityValidator, getDataQualityValidator } from './data-quality.js';
+export { MLPredictionEngine, getPredictionEngine } from './ml-prediction.js';
+export { HistoricalAnalyzer, getHistoricalAnalyzer } from './historical-analyzer.js';
+export { API_CONFIG, CACHE_CONFIG, SCRAPER_CONFIG, LEAGUES, QUERY_TYPES, BETTING, POSITIONS, MATCH_STATUS, ERRORS, ALERT_CONFIG, REALTIME_CONFIG, ML_CONFIG, MODULE_INFO } from './constants.js';

package/dist/tools/sports/core/index.js

@@ -0,0 +1,16 @@
+/**
+ * SPORTS MODULE CORE - Exports
+ */
+// Types
+export * from './types.js';
+// Core classes
+export { CacheService, getGlobalCache, resetGlobalCache } from './cache.js';
+export { CircuitBreaker, CircuitBreakerOpenError, getCircuitBreaker, getAllCircuitBreakerStatus } from './circuit-breaker.js';
+export { withRetry, withRetryAndCircuitBreaker, createRetryable, DEFAULT_RETRY_CONFIG, AGGRESSIVE_RETRY_CONFIG, LIVE_DATA_RETRY_CONFIG } from './retry.js';
+export { RealtimeDataManager, getRealtimeManager, resetRealtimeManager } from './realtime-manager.js';
+export { AlertManager, getAlertManager, resetAlertManager } from './alert-manager.js';
+export { DataQualityValidator, getDataQualityValidator } from './data-quality.js';
+export { MLPredictionEngine, getPredictionEngine } from './ml-prediction.js';
+export { HistoricalAnalyzer, getHistoricalAnalyzer } from './historical-analyzer.js';
+// Constants
+export { API_CONFIG, CACHE_CONFIG, SCRAPER_CONFIG, LEAGUES, QUERY_TYPES, BETTING, POSITIONS, MATCH_STATUS, ERRORS, ALERT_CONFIG, REALTIME_CONFIG, ML_CONFIG, MODULE_INFO } from './constants.js';

package/dist/tools/sports/core/ml-prediction.d.ts

@@ -0,0 +1,134 @@
+/**
+ * ML PREDICTION ENGINE
+ * Machine learning based match outcome prediction
+ */
+import type { Match, TeamStats, PredictionFactor, HeadToHead } from './types.js';
+export interface PredictionInput {
+    match: Match;
+    homeForm: FormData;
+    awayForm: FormData;
+    h2h: HeadToHead;
+    homeStats: TeamStats;
+    awayStats: TeamStats;
+    injuries: InjuryData;
+    weather?: WeatherData;
+}
+export interface FormData {
+    last5: ('W' | 'D' | 'L')[];
+    goalsFor: number;
+    goalsAgainst: number;
+    xG: number;
+    xGA: number;
+}
+export interface InjuryData {
+    home: {
+        keyPlayers: number;
+        total: number;
+    };
+    away: {
+        keyPlayers: number;
+        total: number;
+    };
+}
+export interface WeatherData {
+    temperature: number;
+    condition: string;
+    windSpeed: number;
+    precipitation: boolean;
+}
+export interface PredictionResult {
+    homeWin: number;
+    draw: number;
+    awayWin: number;
+    over25: number;
+    btts: number;
+    confidence: number;
+    factors: PredictionFactor[];
+}
+/**
+ * ML Prediction Engine
+ * Uses weighted factors and historical patterns for predictions
+ */
+export declare class MLPredictionEngine {
+    private weights;
+    private historicalData;
+    constructor();
+    /**
+     * Predict match outcome
+     */
+    predict(input: PredictionInput): Promise<PredictionResult>;
+    /**
+     * Calculate form score (-1 to 1)
+     */
+    private calculateFormScore;
+    private formToPoints;
+    /**
+     * Calculate H2H score (-1 to 1)
+     */
+    private calculateH2HScore;
+    /**
+     * Calculate home advantage score (0 to 1)
+     */
+    private calculateHomeAdvantage;
+    /**
+     * Calculate xG score (-1 to 1)
+     */
+    private calculateXgScore;
+    /**
+     * Calculate injury impact (-1 to 1)
+     */
+    private calculateInjuryImpact;
+    /**
+     * Calculate fatigue impact (-1 to 1)
+     */
+    private calculateFatigueImpact;
+    /**
+     * Calculate weather impact (-0.5 to 0.5)
+     */
+    private calculateWeatherImpact;
+    /**
+     * Combine weighted scores
+     */
+    private combineScores;
+    /**
+     * Convert score to probabilities
+     */
+    private scoreToProbabilities;
+    /**
+     * Calculate confidence level
+     */
+    private calculateConfidence;
+    /**
+     * Predict Over 2.5 goals
+     */
+    private predictOver25;
+    /**
+     * Predict Both Teams to Score
+     */
+    private predictBTTS;
+    /**
+     * Describe form impact
+     */
+    private describeFormImpact;
+    /**
+     * Describe H2H impact
+     */
+    private describeH2HImpact;
+    /**
+     * Describe injury impact
+     */
+    private describeInjuryImpact;
+    /**
+     * Describe weather impact
+     */
+    private describeWeatherImpact;
+    /**
+     * Load historical data
+     */
+    private loadHistoricalData;
+    /**
+     * Learn from past predictions
+     */
+    learnFromResult(prediction: PredictionResult, actualResult: 'home' | 'draw' | 'away', odds: number): void;
+}
+export declare function getPredictionEngine(): MLPredictionEngine;