@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/data-quality.d.ts

@@ -0,0 +1,80 @@
+/**
+ * DATA QUALITY VALIDATOR
+ * Validates and scores data quality for football matches
+ */
+import type { Match, Team, MatchOdds } from './types.js';
+export interface DataQualityReport {
+    overall: number;
+    completeness: number;
+    accuracy: number;
+    freshness: number;
+    consistency: number;
+    issues: DataQualityIssue[];
+    warnings: DataQualityIssue[];
+    suggestions: string[];
+}
+export interface DataQualityIssue {
+    field: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    suggestion?: string;
+    value?: any;
+}
+export declare class DataQualityValidator {
+    private knownTeams;
+    private knownLeagues;
+    constructor();
+    /**
+     * Validate match data and return quality report
+     */
+    validateMatchData(data: Partial<Match>): DataQualityReport;
+    /**
+     * Validate team data
+     */
+    validateTeamData(data: Partial<Team>): DataQualityReport;
+    /**
+     * Validate odds data
+     */
+    validateOddsData(odds: MatchOdds): DataQualityReport;
+    /**
+     * Check data completeness
+     */
+    private checkCompleteness;
+    /**
+     * Check data accuracy
+     */
+    private checkAccuracy;
+    /**
+     * Check data freshness
+     */
+    private checkFreshness;
+    /**
+     * Check data consistency
+     */
+    private checkConsistency;
+    /**
+     * Validate team stats
+     */
+    private validateTeamStats;
+    /**
+     * Generate improvement suggestions
+     */
+    private generateSuggestions;
+    /**
+     * Calculate freshness score from timestamp
+     */
+    private calculateFreshness;
+    /**
+     * Calculate overall score from issues and warnings
+     */
+    private calculateScore;
+    /**
+     * Quick validation - returns true if data passes basic checks
+     */
+    isValid(data: Partial<Match>): boolean;
+    /**
+     * Get quality grade (A-F)
+     */
+    getGrade(score: number): string;
+}
+export declare function getDataQualityValidator(): DataQualityValidator;

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

@@ -0,0 +1,460 @@
+/**
+ * DATA QUALITY VALIDATOR
+ * Validates and scores data quality for football matches
+ */
+import { logger } from '../../../utils.js';
+export class DataQualityValidator {
+    knownTeams = new Set();
+    knownLeagues = new Set();
+    constructor() {
+        // Initialize known leagues
+        this.knownLeagues.add('Premier League');
+        this.knownLeagues.add('La Liga');
+        this.knownLeagues.add('Bundesliga');
+        this.knownLeagues.add('Serie A');
+        this.knownLeagues.add('Ligue 1');
+        this.knownLeagues.add('Champions League');
+        this.knownLeagues.add('Europa League');
+    }
+    /**
+     * Validate match data and return quality report
+     */
+    validateMatchData(data) {
+        const issues = [];
+        const warnings = [];
+        const suggestions = [];
+        // Check completeness
+        const completeness = this.checkCompleteness(data, issues);
+        // Check accuracy
+        const accuracy = this.checkAccuracy(data, issues, warnings);
+        // Check freshness
+        const freshness = this.checkFreshness(data, warnings);
+        // Check consistency
+        const consistency = this.checkConsistency(data, issues, warnings);
+        // Generate suggestions
+        this.generateSuggestions(data, suggestions);
+        // Calculate overall score
+        const overall = Math.round((completeness + accuracy + freshness + consistency) / 4);
+        const report = {
+            overall,
+            completeness,
+            accuracy,
+            freshness,
+            consistency,
+            issues: issues.filter(i => i.severity === 'error'),
+            warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
+            suggestions,
+        };
+        logger.debug(`[DataQuality] Match ${data.id}: Overall=${overall}, Completeness=${completeness}, Accuracy=${accuracy}`);
+        return report;
+    }
+    /**
+     * Validate team data
+     */
+    validateTeamData(data) {
+        const issues = [];
+        const warnings = [];
+        const suggestions = [];
+        // Check required fields
+        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',
+                suggestion: 'Add country information for better filtering',
+            });
+        }
+        // Validate stats if present
+        if (data.stats) {
+            this.validateTeamStats(data.stats, issues, warnings);
+        }
+        const completeness = this.calculateScore(issues, warnings, 3);
+        const accuracy = 100; // Simplified
+        const freshness = 100;
+        const consistency = 100;
+        return {
+            overall: Math.round((completeness + accuracy + freshness + consistency) / 4),
+            completeness,
+            accuracy,
+            freshness,
+            consistency,
+            issues: issues.filter(i => i.severity === 'error'),
+            warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
+            suggestions,
+        };
+    }
+    /**
+     * Validate odds data
+     */
+    validateOddsData(odds) {
+        const issues = [];
+        const warnings = [];
+        // Check required fields
+        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,
+            });
+        }
+        // Check implied probability (overround)
+        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)}%`,
+                suggestion: 'Normal range is 100-115%',
+                value: impliedProb,
+            });
+        }
+        // Check for arbitrage opportunity (unlikely but possible error)
+        if (impliedProb < 0.95) {
+            issues.push({
+                field: 'odds',
+                severity: 'error',
+                message: 'Possible arbitrage opportunity detected - verify odds accuracy',
+                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: [],
+        };
+    }
+    /**
+     * Check data completeness
+     */
+    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: 'lineups', weight: 3 },
+            { 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;
+    }
+    /**
+     * Check data accuracy
+     */
+    checkAccuracy(data, issues, warnings) {
+        let score = 100;
+        // Check score consistency with status
+        if (data.score && data.status === 'scheduled') {
+            score -= 15;
+            warnings.push({
+                field: 'score',
+                severity: 'warning',
+                message: 'Match has score but status is "scheduled"',
+                suggestion: 'Update status to "live" or "finished"',
+            });
+        }
+        // Check for negative scores
+        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,
+                });
+            }
+            // Check for unrealistic scores
+            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}`,
+                });
+            }
+        }
+        // Check date validity
+        if (data.date) {
+            const matchDate = new Date(data.date);
+            const now = new Date();
+            const oneYearAgo = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+            const oneYearFromNow = new Date(now.getFullYear() + 1, now.getMonth(), now.getDate());
+            if (matchDate < oneYearAgo || matchDate > oneYearFromNow) {
+                score -= 10;
+                warnings.push({
+                    field: 'date',
+                    severity: 'warning',
+                    message: 'Match date is outside expected range',
+                    value: data.date,
+                });
+            }
+        }
+        // Check team names
+        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);
+    }
+    /**
+     * Check data freshness
+     */
+    checkFreshness(data, warnings) {
+        if (!data.date)
+            return 50;
+        const matchDate = new Date(data.date).getTime();
+        const now = Date.now();
+        const age = now - matchDate;
+        // For live matches, data should be very fresh
+        if (data.status === 'live') {
+            // Live data older than 2 minutes is stale
+            if (age > 2 * 60 * 1000) {
+                warnings.push({
+                    field: 'freshness',
+                    severity: 'warning',
+                    message: 'Live match data is stale (>2 minutes old)',
+                    suggestion: 'Refresh data from source',
+                });
+                return 50;
+            }
+            return 100;
+        }
+        // For scheduled matches, freshness is less critical
+        if (data.status === 'scheduled') {
+            return 100;
+        }
+        // For finished matches, check if recently completed
+        if (data.status === 'finished') {
+            // Match finished within last hour
+            if (age < 60 * 60 * 1000) {
+                return 100;
+            }
+            // Match finished within last day
+            if (age < 24 * 60 * 60 * 1000) {
+                return 80;
+            }
+            return 60;
+        }
+        return 70;
+    }
+    /**
+     * Check data consistency
+     */
+    checkConsistency(data, issues, warnings) {
+        let score = 100;
+        // Check team stats consistency
+        if (data.homeTeam?.stats && data.awayTeam?.stats) {
+            const homeStats = data.homeTeam.stats;
+            const awayStats = data.awayTeam.stats;
+            // Check if matches played is consistent
+            if (homeStats.matchesPlayed !== awayStats.matchesPlayed &&
+                data.league?.name !== 'Champions League' &&
+                data.league?.name !== 'Europa League') {
+                // This might be OK for cup competitions
+                warnings.push({
+                    field: 'stats',
+                    severity: 'info',
+                    message: 'Teams have different number of matches played',
+                });
+            }
+        }
+        // Check score consistency
+        if (data.score && data.status === 'finished') {
+            const totalGoals = data.score.home + data.score.away;
+            // Very high scoring match - verify
+            if (totalGoals > 10) {
+                score -= 5;
+                warnings.push({
+                    field: 'score',
+                    severity: 'info',
+                    message: `High scoring match: ${totalGoals} total goals`,
+                });
+            }
+        }
+        return Math.max(0, score);
+    }
+    /**
+     * Validate team stats
+     */
+    validateTeamStats(stats, issues, warnings) {
+        // Check matches played
+        if (stats.matchesPlayed < 0) {
+            issues.push({
+                field: 'matchesPlayed',
+                severity: 'error',
+                message: 'Matches played cannot be negative',
+                value: stats.matchesPlayed,
+            });
+        }
+        // Check wins + draws + losses = matches played
+        const totalResults = stats.wins + stats.draws + stats.losses;
+        if (totalResults !== stats.matchesPlayed && stats.matchesPlayed > 0) {
+            warnings.push({
+                field: 'stats',
+                severity: 'warning',
+                message: `Wins+Draws+Losses (${totalResults}) != Matches Played (${stats.matchesPlayed})`,
+            });
+        }
+        // Check goal difference
+        const calculatedGD = stats.goalsFor - stats.goalsAgainst;
+        if (stats.goalDifference !== undefined && stats.goalDifference !== calculatedGD) {
+            warnings.push({
+                field: 'goalDifference',
+                severity: 'warning',
+                message: `Goal difference mismatch: ${stats.goalDifference} vs calculated ${calculatedGD}`,
+            });
+        }
+        // Check points
+        const calculatedPoints = (stats.wins * 3) + stats.draws;
+        if (stats.points !== undefined && stats.points !== calculatedPoints) {
+            warnings.push({
+                field: 'points',
+                severity: 'warning',
+                message: `Points mismatch: ${stats.points} vs calculated ${calculatedPoints}`,
+            });
+        }
+    }
+    /**
+     * Generate improvement suggestions
+     */
+    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.homeTeam?.stats?.xG && !data.awayTeam?.stats?.xG) {
+            suggestions.push('Add expected goals (xG) data for advanced analysis');
+        }
+        if (!data.referee) {
+            suggestions.push('Add referee information for bias analysis');
+        }
+        if (!data.venue) {
+            suggestions.push('Add venue information for home advantage analysis');
+        }
+    }
+    /**
+     * Calculate freshness score from timestamp
+     */
+    calculateFreshness(timestamp) {
+        const ts = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+        const age = Date.now() - ts;
+        if (age < 60000)
+            return 100; // < 1 minute
+        if (age < 300000)
+            return 90; // < 5 minutes
+        if (age < 600000)
+            return 80; // < 10 minutes
+        if (age < 1800000)
+            return 60; // < 30 minutes
+        if (age < 3600000)
+            return 40; // < 1 hour
+        return 20;
+    }
+    /**
+     * Calculate overall score from issues and warnings
+     */
+    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);
+    }
+    /**
+     * Quick validation - returns true if data passes basic checks
+     */
+    isValid(data) {
+        const report = this.validateMatchData(data);
+        return report.issues.length === 0 && report.overall >= 70;
+    }
+    /**
+     * Get quality grade (A-F)
+     */
+    getGrade(score) {
+        if (score >= 90)
+            return 'A';
+        if (score >= 80)
+            return 'B';
+        if (score >= 70)
+            return 'C';
+        if (score >= 60)
+            return 'D';
+        return 'F';
+    }
+}
+// Singleton instance
+let globalValidator = null;
+export function getDataQualityValidator() {
+    if (!globalValidator) {
+        globalValidator = new DataQualityValidator();
+    }
+    return globalValidator;
+}

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

@@ -0,0 +1,108 @@
+/**
+ * HISTORICAL ANALYZER
+ * Analyzes historical data for patterns and trends
+ */
+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;
+}
+/**
+ * Historical Analyzer
+ * Analyzes past matches for patterns and predictive insights
+ */
+export declare class HistoricalAnalyzer {
+    private matchHistory;
+    private patterns;
+    constructor();
+    /**
+     * Analyze team performance over time
+     */
+    analyzeTeamPerformance(teamId: string, query?: HistoricalQuery): TeamHistoricalPerformance;
+    /**
+     * Analyze head-to-head history
+     */
+    analyzeHeadToHead(teamAId: string, teamBId: string, limit?: number): HeadToHead;
+    /**
+     * Analyze trends for a team
+     */
+    analyzeTrends(teamId: string, windowSize?: number): TrendAnalysis;
+    /**
+     * Calculate performance metrics
+     */
+    calculateMetrics(teamId: string, query?: HistoricalQuery): PerformanceMetrics;
+    /**
+     * Find betting patterns
+     */
+    findBettingPatterns(query: HistoricalQuery): HistoricalPattern[];
+    /**
+     * Analyze referee bias
+     */
+    analyzeRefereeBias(refereeName: string, teamId?: string): {
+        referee: string;
+        matches: number;
+        avgCards: number;
+        homeWinRate: number;
+        teamBias?: number;
+    };
+    /**
+     * Analyze weather impact
+     */
+    analyzeWeatherImpact(condition: string, teamId?: string): {
+        condition: string;
+        matches: number;
+        avgGoals: number;
+        homeWinRate: number;
+        teamPerformance?: number;
+    };
+    /**
+     * Get similar matches
+     */
+    findSimilarMatches(match: Match, limit?: number): Match[];
+    /**
+     * Calculate similarity between two matches
+     */
+    private calculateSimilarity;
+    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;
+    private loadHistoricalData;
+    /**
+     * Add match to history
+     */
+    addMatch(match: Match): void;
+}
+export declare function getHistoricalAnalyzer(): HistoricalAnalyzer;