@gotza02/sequential-thinking 10000.1.0 → 10000.1.2

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

@@ -1,41 +1,26 @@
 /**
  * DATA QUALITY VALIDATOR
- * Validates and scores data quality for football matches
  */
-import { logger } from '../../../utils.js';
+// 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 {
-    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 = {
+        logger.debug(`[DataQuality] Match ${data.id}: Overall=${overall}`);
+        return {
             overall,
             completeness,
             accuracy,
@@ -45,101 +30,46 @@ export class DataQualityValidator {
             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',
-            });
+            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);
+            warnings.push({ field: 'country', severity: 'warning', message: 'Team country is missing' });
         }
         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),
+            overall: completeness,
             completeness,
-            accuracy,
-            freshness,
-            consistency,
+            accuracy: 100,
+            freshness: 100,
+            consistency: 100,
             issues: issues.filter(i => i.severity === 'error'),
             warnings: [...issues.filter(i => i.severity === 'warning'), ...warnings],
-            suggestions,
+            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,
-            });
+            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,
-            });
+            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,
-            });
+            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,
-            });
+            warnings.push({ field: 'odds', severity: 'warning', message: `Unusual implied probability: ${(impliedProb * 100).toFixed(1)}%` });
         }
-        // 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,
-            });
+            issues.push({ field: 'odds', severity: 'error', message: 'Possible arbitrage opportunity detected', value: impliedProb });
         }
         const completeness = this.calculateScore(issues, warnings, 3);
         return {
@@ -153,9 +83,6 @@ export class DataQualityValidator {
             suggestions: [],
         };
     }
-    /**
-     * Check data completeness
-     */
     checkCompleteness(data, issues) {
         const requiredFields = [
             { key: 'id', weight: 15 },
@@ -168,7 +95,8 @@ export class DataQualityValidator {
         const optionalFields = [
             { key: 'score', weight: 5 },
             { key: 'odds', weight: 5 },
-            { key: 'lineups', weight: 3 },
+            { key: 'homeLineup', weight: 1.5 },
+            { key: 'awayLineup', weight: 1.5 },
             { key: 'events', weight: 3 },
             { key: 'venue', weight: 2 },
             { key: 'referee', weight: 2 },
@@ -180,247 +108,110 @@ export class DataQualityValidator {
                 score += weight;
             }
             else {
-                issues.push({
-                    field: key,
-                    severity: 'error',
-                    message: `Required field '${key}' is missing`,
-                });
+                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) {
+            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"',
-            });
+            warnings.push({ field: 'score', severity: 'warning', message: 'Match has score but status is "scheduled"' });
         }
-        // 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,
-                });
+                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}`,
-                });
+                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());
+            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,
-                });
+                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,
-                });
+                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',
-                });
+                warnings.push({ field: 'freshness', severity: 'warning', message: 'Live match data is stale (>2 minutes old)' });
                 return 50;
             }
             return 100;
         }
-        // For scheduled matches, freshness is less critical
-        if (data.status === 'scheduled') {
+        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) {
+            if (age < 60 * 60 * 1000)
                 return 100;
-            }
-            // Match finished within last day
-            if (age < 24 * 60 * 60 * 1000) {
+            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`,
-                });
+                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) {
+        if (!data.odds)
             suggestions.push('Add betting odds for value analysis');
-        }
-        if (!data.homeLineup && !data.awayLineup) {
+        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) {
+        if (!data.referee)
             suggestions.push('Add referee information for bias analysis');
-        }
-        if (!data.venue) {
+        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
+            return 100;
         if (age < 300000)
-            return 90; // < 5 minutes
+            return 90;
         if (age < 600000)
-            return 80; // < 10 minutes
+            return 80;
         if (age < 1800000)
-            return 60; // < 30 minutes
+            return 60;
         if (age < 3600000)
-            return 40; // < 1 hour
+            return 40;
         return 20;
     }
-    /**
-     * Calculate overall score from issues and warnings
-     */
     calculateScore(errors, warnings, maxFields) {
         const errorWeight = 20;
         const warningWeight = 5;
@@ -428,16 +219,10 @@ export class DataQualityValidator {
         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';
@@ -450,11 +235,9 @@ export class DataQualityValidator {
         return 'F';
     }
 }
-// Singleton instance
 let globalValidator = null;
 export function getDataQualityValidator() {
-    if (!globalValidator) {
+    if (!globalValidator)
         globalValidator = new DataQualityValidator();
-    }
     return globalValidator;
 }

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

@@ -1,6 +1,5 @@
 /**
  * HISTORICAL ANALYZER
- * Analyzes historical data for patterns and trends
  */
 import type { Match, HeadToHead, HistoricalPattern, TeamHistoricalPerformance } from './types.js';
 export interface HistoricalQuery {
@@ -30,62 +29,13 @@ export interface PerformanceMetrics {
     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;
@@ -99,10 +49,6 @@ export declare class HistoricalAnalyzer {
     private calculateProfit;
     private queryMatches;
     private createEmptyPerformance;
-    private loadHistoricalData;
-    /**
-     * Add match to history
-     */
     addMatch(match: Match): void;
 }
 export declare function getHistoricalAnalyzer(): HistoricalAnalyzer;