@gotza02/sequential-thinking 10000.1.2 → 10000.1.3

package/dist/tools/sports/core/data-quality.js

@@ -1,243 +0,0 @@
-/**
- * DATA QUALITY VALIDATOR
- */
-// 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 DataQualityValidator {
-    validateMatchData(data) {
-        const issues = [];
-        const warnings = [];
-        const suggestions = [];
-        const completeness = this.checkCompleteness(data, issues);
-        const accuracy = this.checkAccuracy(data, issues, warnings);
-        const freshness = this.checkFreshness(data, warnings);
-        const consistency = this.checkConsistency(data, issues, warnings);
-        this.generateSuggestions(data, suggestions);
-        const overall = Math.round((completeness + accuracy + freshness + consistency) / 4);
-        logger.debug(`[DataQuality] Match ${data.id}: Overall=${overall}`);
-        return {
-            overall,
-            completeness,
-            accuracy,
-            freshness,
-            consistency,
-            issues: issues.filter(i => i.severity === 'error'),
-            warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
-            suggestions,
-        };
-    }
-    validateTeamData(data) {
-        const issues = [];
-        const warnings = [];
-        if (!data.name) {
-            issues.push({ field: 'name', severity: 'error', message: 'Team name is required' });
-        }
-        if (!data.country) {
-            warnings.push({ field: 'country', severity: 'warning', message: 'Team country is missing' });
-        }
-        const completeness = this.calculateScore(issues, warnings, 3);
-        return {
-            overall: completeness,
-            completeness,
-            accuracy: 100,
-            freshness: 100,
-            consistency: 100,
-            issues: issues.filter(i => i.severity === 'error'),
-            warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
-            suggestions: [],
-        };
-    }
-    validateOddsData(odds) {
-        const issues = [];
-        const warnings = [];
-        if (!odds.homeWin || odds.homeWin <= 1) {
-            issues.push({ field: 'homeWin', severity: 'error', message: `Invalid home win odds: ${odds.homeWin}`, value: odds.homeWin });
-        }
-        if (!odds.draw || odds.draw <= 1) {
-            issues.push({ field: 'draw', severity: 'error', message: `Invalid draw odds: ${odds.draw}`, value: odds.draw });
-        }
-        if (!odds.awayWin || odds.awayWin <= 1) {
-            issues.push({ field: 'awayWin', severity: 'error', message: `Invalid away win odds: ${odds.awayWin}`, value: odds.awayWin });
-        }
-        const impliedProb = (1 / odds.homeWin) + (1 / odds.draw) + (1 / odds.awayWin);
-        if (impliedProb < 1 || impliedProb > 1.5) {
-            warnings.push({ field: 'odds', severity: 'warning', message: `Unusual implied probability: ${(impliedProb * 100).toFixed(1)}%` });
-        }
-        if (impliedProb < 0.95) {
-            issues.push({ field: 'odds', severity: 'error', message: 'Possible arbitrage opportunity detected', value: impliedProb });
-        }
-        const completeness = this.calculateScore(issues, warnings, 3);
-        return {
-            overall: completeness,
-            completeness,
-            accuracy: completeness,
-            freshness: odds.timestamp ? this.calculateFreshness(odds.timestamp) : 50,
-            consistency: 100,
-            issues: issues.filter(i => i.severity === 'error'),
-            warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
-            suggestions: [],
-        };
-    }
-    checkCompleteness(data, issues) {
-        const requiredFields = [
-            { key: 'id', weight: 15 },
-            { key: 'homeTeam', weight: 15 },
-            { key: 'awayTeam', weight: 15 },
-            { key: 'date', weight: 15 },
-            { key: 'status', weight: 10 },
-            { key: 'league', weight: 10 },
-        ];
-        const optionalFields = [
-            { key: 'score', weight: 5 },
-            { key: 'odds', weight: 5 },
-            { key: 'homeLineup', weight: 1.5 },
-            { key: 'awayLineup', weight: 1.5 },
-            { key: 'events', weight: 3 },
-            { key: 'venue', weight: 2 },
-            { key: 'referee', weight: 2 },
-        ];
-        let score = 0;
-        requiredFields.forEach(({ key, weight }) => {
-            const value = data[key];
-            if (value !== undefined && value !== null) {
-                score += weight;
-            }
-            else {
-                issues.push({ field: key, severity: 'error', message: `Required field '${key}' is missing` });
-            }
-        });
-        optionalFields.forEach(({ key, weight }) => {
-            const value = data[key];
-            if (value !== undefined && value !== null)
-                score += weight;
-        });
-        return score;
-    }
-    checkAccuracy(data, issues, warnings) {
-        let score = 100;
-        if (data.score && data.status === 'scheduled') {
-            score -= 15;
-            warnings.push({ field: 'score', severity: 'warning', message: 'Match has score but status is "scheduled"' });
-        }
-        if (data.score) {
-            if (data.score.home < 0 || data.score.away < 0) {
-                score -= 20;
-                issues.push({ field: 'score', severity: 'error', message: 'Negative score detected', value: data.score });
-            }
-            if (data.score.home > 15 || data.score.away > 15) {
-                score -= 10;
-                warnings.push({ field: 'score', severity: 'warning', message: 'Unusually high score detected', value: `${data.score.home}-${data.score.away}` });
-            }
-        }
-        if (data.date) {
-            const matchDate = new Date(data.date).getTime();
-            const now = Date.now();
-            const oneYearAgo = now - 365 * 24 * 60 * 60 * 1000;
-            const oneYearFromNow = now + 365 * 24 * 60 * 60 * 1000;
-            if (matchDate < oneYearAgo || matchDate > oneYearFromNow) {
-                score -= 10;
-                warnings.push({ field: 'date', severity: 'warning', message: 'Match date is outside expected range', value: data.date });
-            }
-        }
-        if (data.homeTeam && data.awayTeam) {
-            if (data.homeTeam.name === data.awayTeam.name) {
-                score -= 20;
-                issues.push({ field: 'teams', severity: 'error', message: 'Home and away teams have the same name', value: data.homeTeam.name });
-            }
-        }
-        return Math.max(0, score);
-    }
-    checkFreshness(data, warnings) {
-        if (!data.date)
-            return 50;
-        const matchDate = new Date(data.date).getTime();
-        const now = Date.now();
-        const age = now - matchDate;
-        if (data.status === 'live') {
-            if (age > 2 * 60 * 1000) {
-                warnings.push({ field: 'freshness', severity: 'warning', message: 'Live match data is stale (>2 minutes old)' });
-                return 50;
-            }
-            return 100;
-        }
-        if (data.status === 'scheduled')
-            return 100;
-        if (data.status === 'finished') {
-            if (age < 60 * 60 * 1000)
-                return 100;
-            if (age < 24 * 60 * 60 * 1000)
-                return 80;
-            return 60;
-        }
-        return 70;
-    }
-    checkConsistency(data, issues, warnings) {
-        let score = 100;
-        if (data.score && data.status === 'finished') {
-            const totalGoals = data.score.home + data.score.away;
-            if (totalGoals > 10) {
-                score -= 5;
-                warnings.push({ field: 'score', severity: 'info', message: `High scoring match: ${totalGoals} total goals` });
-            }
-        }
-        return Math.max(0, score);
-    }
-    generateSuggestions(data, suggestions) {
-        if (!data.odds)
-            suggestions.push('Add betting odds for value analysis');
-        if (!data.homeLineup || !data.awayLineup)
-            suggestions.push('Add team lineups for better predictions');
-        if (!data.referee)
-            suggestions.push('Add referee information for bias analysis');
-        if (!data.venue)
-            suggestions.push('Add venue information for home advantage analysis');
-    }
-    calculateFreshness(timestamp) {
-        const ts = timestamp instanceof Date ? timestamp.getTime() : timestamp;
-        const age = Date.now() - ts;
-        if (age < 60000)
-            return 100;
-        if (age < 300000)
-            return 90;
-        if (age < 600000)
-            return 80;
-        if (age < 1800000)
-            return 60;
-        if (age < 3600000)
-            return 40;
-        return 20;
-    }
-    calculateScore(errors, warnings, maxFields) {
-        const errorWeight = 20;
-        const warningWeight = 5;
-        const errorDeduction = errors.filter(i => i.severity === 'error').length * errorWeight;
-        const warningDeduction = warnings.length * warningWeight;
-        return Math.max(0, 100 - errorDeduction - warningDeduction);
-    }
-    isValid(data) {
-        const report = this.validateMatchData(data);
-        return report.issues.length === 0 && report.overall >= 70;
-    }
-    getGrade(score) {
-        if (score >= 90)
-            return 'A';
-        if (score >= 80)
-            return 'B';
-        if (score >= 70)
-            return 'C';
-        if (score >= 60)
-            return 'D';
-        return 'F';
-    }
-}
-let globalValidator = null;
-export function getDataQualityValidator() {
-    if (!globalValidator)
-        globalValidator = new DataQualityValidator();
-    return globalValidator;
-}

package/dist/tools/sports/core/historical-analyzer.d.ts

@@ -1,54 +0,0 @@
-/**
- * HISTORICAL ANALYZER
- */
-import type { Match, HeadToHead, HistoricalPattern, TeamHistoricalPerformance } from './types.js';
-export interface HistoricalQuery {
-    team?: string;
-    league?: string;
-    dateFrom?: Date;
-    dateTo?: Date;
-    opponent?: string;
-    venue?: 'home' | 'away' | 'neutral';
-    minOdds?: number;
-    maxOdds?: number;
-}
-export interface TrendAnalysis {
-    direction: 'up' | 'down' | 'stable';
-    strength: number;
-    confidence: number;
-    dataPoints: number;
-    description: string;
-}
-export interface PerformanceMetrics {
-    winRate: number;
-    drawRate: number;
-    lossRate: number;
-    avgGoalsFor: number;
-    avgGoalsAgainst: number;
-    cleanSheetRate: number;
-    bothTeamsScoreRate: number;
-    over25Rate: number;
-}
-export declare class HistoricalAnalyzer {
-    private matchHistory;
-    analyzeTeamPerformance(teamId: string, query?: HistoricalQuery): TeamHistoricalPerformance;
-    analyzeHeadToHead(teamAId: string, teamBId: string, limit?: number): HeadToHead;
-    analyzeTrends(teamId: string, windowSize?: number): TrendAnalysis;
-    calculateMetrics(teamId: string, query?: HistoricalQuery): PerformanceMetrics;
-    findBettingPatterns(query: HistoricalQuery): HistoricalPattern[];
-    private getTeamMatches;
-    private getH2HMatches;
-    private isWin;
-    private isDraw;
-    private isLoss;
-    private getGoalsFor;
-    private getGoalsAgainst;
-    private getMatchPoints;
-    private calculateHomeAdvantage;
-    private findPatterns;
-    private calculateProfit;
-    private queryMatches;
-    private createEmptyPerformance;
-    addMatch(match: Match): void;
-}
-export declare function getHistoricalAnalyzer(): HistoricalAnalyzer;

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

@@ -1,261 +0,0 @@
-/**
- * HISTORICAL ANALYZER
- */
-// 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 HistoricalAnalyzer {
-    matchHistory = [];
-    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);
-        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: this.findPatterns(teamId, matches),
-        };
-    }
-    analyzeHeadToHead(teamAId, teamBId, limit = 10) {
-        const matches = this.getH2HMatches(teamAId, teamBId, limit);
-        let homeWins = 0, awayWins = 0, draws = 0, homeGoals = 0, 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),
-        };
-    }
-    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' };
-        }
-        const recent = matches.slice(0, Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
-        const older = matches.slice(Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
-        const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
-        const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
-        const difference = recentAvg - olderAvg;
-        const strength = Math.min(1, Math.abs(difference) / 2);
-        const direction = difference > 0.5 ? 'up' : difference < -0.5 ? 'down' : 'stable';
-        return {
-            direction, strength,
-            confidence: Math.min(100, matches.length * 10),
-            dataPoints: matches.length,
-            description: direction === 'up'
-                ? `Improving: ${recentAvg.toFixed(2)} pts/game vs ${olderAvg.toFixed(2)} before`
-                : direction === 'down'
-                    ? `Declining: ${recentAvg.toFixed(2)} pts/game vs ${olderAvg.toFixed(2)} before`
-                    : `Stable: ${recentAvg.toFixed(2)} pts/game`,
-        };
-    }
-    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 => this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId) > 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,
-        };
-    }
-    findBettingPatterns(query) {
-        const patterns = [];
-        const matches = this.queryMatches(query);
-        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'),
-            });
-        }
-        const lowScoring = matches.filter(m => (m.score?.home || 0) + (m.score?.away || 0) < 2.5);
-        if (lowScoring.length >= 10) {
-            patterns.push({
-                pattern: 'Under 2.5 goals',
-                occurrence: lowScoring.length,
-                successRate: lowScoring.length / matches.length,
-                avgOdds: 1.8,
-                profit: (lowScoring.length * 0.8 - (matches.length - lowScoring.length)) * 10,
-            });
-        }
-        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,
-                profit: (bttsMatches.length * 0.9 - (matches.length - bttsMatches.length)) * 10,
-            });
-        }
-        return patterns.sort((a, b) => b.profit - a.profit);
-    }
-    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) {
-        return match.score ? match.score.home === match.score.away : false;
-    }
-    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) {
-        return match.score ? (match.homeTeam.id === teamId ? match.score.home : match.score.away) : 0;
-    }
-    getGoalsAgainst(match, teamId) {
-        return match.score ? (match.homeTeam.id === teamId ? match.score.away : match.score.home) : 0;
-    }
-    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 = [];
-        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 });
-        }
-        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: [],
-        };
-    }
-    addMatch(match) {
-        this.matchHistory.push(match);
-        if (this.matchHistory.length > 1000)
-            this.matchHistory.shift();
-    }
-}
-let globalHistoricalAnalyzer = null;
-export function getHistoricalAnalyzer() {
-    if (!globalHistoricalAnalyzer)
-        globalHistoricalAnalyzer = new HistoricalAnalyzer();
-    return globalHistoricalAnalyzer;
-}

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

@@ -1,13 +0,0 @@
-/**
- * SPORTS MODULE CORE - Exports (FIXED)
- */
-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

@@ -1,16 +0,0 @@
-/**
- * SPORTS MODULE CORE - Exports (FIXED)
- */
-// 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

@@ -1,76 +0,0 @@
-/**
- * ML PREDICTION ENGINE
- */
-import type { Match, TeamStats, 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 PredictionFactor {
-    name: string;
-    weight: number;
-    impact: 'positive' | 'negative' | 'neutral';
-    description: string;
-}
-export interface PredictionResult {
-    homeWin: number;
-    draw: number;
-    awayWin: number;
-    over25: number;
-    btts: number;
-    confidence: number;
-    factors: PredictionFactor[];
-}
-export declare class MLPredictionEngine {
-    private weights;
-    private historicalData;
-    predict(input: PredictionInput): Promise<PredictionResult>;
-    private calculateFormScore;
-    private formToPoints;
-    private calculateH2HScore;
-    private calculateHomeAdvantage;
-    private calculateXgScore;
-    private calculateInjuryImpact;
-    private calculateFatigueImpact;
-    private calculateWeatherImpact;
-    private combineScores;
-    private scoreToProbabilities;
-    private calculateConfidence;
-    private predictOver25;
-    private predictBTTS;
-    private describeFormImpact;
-    private describeH2HImpact;
-    private describeInjuryImpact;
-    private describeWeatherImpact;
-    learnFromResult(prediction: PredictionResult, actualResult: 'home' | 'draw' | 'away', odds: number): void;
-}
-export declare function getPredictionEngine(): MLPredictionEngine;