@gotza02/sequential-thinking 10000.1.2 → 10000.1.4

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

@@ -14,49 +14,31 @@ export const API_CONFIG = {
     // TheSportsDB
     SPORTS_DB_KEY: process.env.SPORTS_DB_KEY || '',
     SPORTS_DB_BASE: 'https://www.thesportsdb.com/api/v1/json',
-    // Odds API
-    ODDS_API_KEY: process.env.ODDS_API_KEY || '',
-    ODDS_API_BASE: 'https://api.the-odds-api.com/v4',
-    // SportRadar (requires enterprise license)
-    SPORTRADAR_KEY: process.env.SPORTRADAR_KEY || '',
-    SPORTRADAR_BASE: 'https://api.sportradar.us/soccer/trial/v4',
     // Rate limits (requests per minute)
     RATE_LIMITS: {
         API_FOOTBALL: 10,
         FOOTBALL_DATA: 10,
         SPORTS_DB: 30,
-        ODDS_API: 20,
-        SPORTRADAR: 100,
     }
 };
 // ============= Cache Configuration =============
 export const CACHE_CONFIG = {
     // Default TTL in milliseconds
     DEFAULT_TTL: parseInt(process.env.SPORTS_CACHE_TTL || '300000'), // 5 minutes
-    // Specific TTLs for different data types (OPTIMIZED FOR REALTIME)
+    // Specific TTLs for different data types
     TTL: {
-        LIVE_SCORES: 15 * 1000, // 15 seconds (was 1 minute)
-        LIVE_EVENTS: 5 * 1000, // 5 seconds for live match events
-        ODDS: 30 * 1000, // 30 seconds (was 2 minutes)
-        MATCH_DETAILS: 2 * 60 * 1000, // 2 minutes (was 5 minutes)
-        STANDINGS: 15 * 60 * 1000, // 15 minutes (was 30 minutes)
-        TEAM_STATS: 30 * 60 * 1000, // 30 minutes (was 1 hour)
-        PLAYER_STATS: 30 * 60 * 1000, // 30 minutes (was 1 hour)
-        TRANSFER_NEWS: 10 * 60 * 1000, // 10 minutes (was 15 minutes)
-        PREDICTIONS: 60 * 60 * 1000, // 1 hour
-    },
-    // Stale-while-revalidate multipliers
-    STALE_MULTIPLIERS: {
-        LIVE_SCORES: 2, // Stale for 30 seconds (15s * 2)
-        ODDS: 2, // Stale for 1 minute (30s * 2)
-        MATCH_DETAILS: 2, // Stale for 4 minutes
-        STANDINGS: 1.5, // Stale for 22.5 minutes
-        TEAM_STATS: 1.5, // Stale for 45 minutes
+        LIVE_SCORES: 60 * 1000, // 1 minute
+        MATCH_DETAILS: 5 * 60 * 1000, // 5 minutes
+        STANDINGS: 30 * 60 * 1000, // 30 minutes
+        TEAM_STATS: 60 * 60 * 1000, // 1 hour
+        PLAYER_STATS: 60 * 60 * 1000, // 1 hour
+        ODDS: 2 * 60 * 1000, // 2 minutes
+        TRANSFER_NEWS: 15 * 60 * 1000, // 15 minutes
     },
     // Cache file path
     CACHE_PATH: process.env.SPORTS_CACHE_PATH || '.sports_cache.json',
     // Max cache size (number of entries)
-    MAX_SIZE: 2000,
+    MAX_SIZE: 1000,
 };
 // ============= Scraping Configuration =============
 export const SCRAPER_CONFIG = {
@@ -170,67 +152,10 @@ export const ERRORS = {
     TIMEOUT: 'Request timed out.',
     INVALID_RESPONSE: 'Invalid response from API.',
     ALL_PROVIDERS_FAILED: 'All data providers failed.',
-    CIRCUIT_BREAKER_OPEN: 'Service temporarily unavailable due to repeated failures.',
-};
-// ============= Alert Configuration =============
-export const ALERT_CONFIG = {
-    // Check interval for alerts (milliseconds)
-    CHECK_INTERVAL: 10000, // 10 seconds
-    // Default cooldown between same alert (milliseconds)
-    DEFAULT_COOLDOWN: 300000, // 5 minutes
-    // Max alerts per hour per rule
-    MAX_ALERTS_PER_HOUR: 10,
-    // Alert types
-    TYPES: {
-        ODDS_DROP: 'odds_drop',
-        ODDS_VALUE: 'odds_value',
-        GOAL: 'goal',
-        RED_CARD: 'red_card',
-        LINEUP_CHANGE: 'lineup_change',
-        MATCH_START: 'match_start',
-        MATCH_END: 'match_end',
-        CUSTOM: 'custom',
-    },
-};
-// ============= Realtime Configuration =============
-export const REALTIME_CONFIG = {
-    // WebSocket reconnection
-    WS_RECONNECT_INTERVAL: 5000,
-    WS_MAX_RECONNECT_ATTEMPTS: 10,
-    // Polling intervals (fallback when WebSocket unavailable)
-    POLLING_INTERVALS: {
-        LIVE_SCORES: 15000, // 15 seconds
-        ODDS: 30000, // 30 seconds
-        MATCH_EVENTS: 5000, // 5 seconds
-    },
-    // Event batching
-    EVENT_BATCH_SIZE: 10,
-    EVENT_BATCH_TIMEOUT: 1000,
-};
-// ============= ML Prediction Configuration =============
-export const ML_CONFIG = {
-    // Minimum matches for training
-    MIN_TRAINING_MATCHES: 50,
-    // Feature weights
-    FEATURE_WEIGHTS: {
-        form: 0.25,
-        h2h: 0.20,
-        home_advantage: 0.15,
-        xg: 0.15,
-        injuries: 0.10,
-        fatigue: 0.10,
-        weather: 0.05,
-    },
-    // Confidence thresholds
-    CONFIDENCE_THRESHOLDS: {
-        high: 0.70,
-        medium: 0.55,
-        low: 0.40,
-    },
 };
 // ============= Version Info =============
 export const MODULE_INFO = {
     NAME: 'sports-module',
-    VERSION: '3.0.0',
-    DESCRIPTION: 'Football Intelligence System for MCP Server - Realtime Edition',
+    VERSION: '2.0.0',
+    DESCRIPTION: 'Football Intelligence System for MCP Server',
 };

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

@@ -7,7 +7,7 @@ export type MatchStatus = 'scheduled' | 'live' | 'finished' | 'postponed' | 'can
 export type BetType = 'home' | 'draw' | 'away' | 'over' | 'under' | 'btts' | 'handicap';
 export type KellyVariant = 'full' | 'half' | 'quarter';
 export type QueryType = 'general' | 'h2h' | 'form' | 'news' | 'stats' | 'odds' | 'referee' | 'weather' | 'fatigue' | 'setpieces';
-export type ProviderType = 'api-football' | 'football-data' | 'sports-db' | 'odds-api' | 'sportradar' | 'scraper';
+export type ProviderType = 'api-football' | 'football-data' | 'sports-db' | 'scraper';
 export interface SearchQuery {
     type: QueryType;
     query: string;
@@ -175,8 +175,6 @@ export interface Match {
     homeSubstitutes?: Player[];
     awaySubstitutes?: Player[];
     events?: MatchEvent[];
-    dataQuality?: number;
-    lastUpdated?: Date;
 }
 export interface MatchOdds {
     homeWin: number;
@@ -346,7 +344,6 @@ export interface APIResponse<T = any> {
     provider?: ProviderType;
     cached?: boolean;
     rateLimited?: boolean;
-    quality?: number;
 }
 export interface ProviderStatus {
     name: ProviderType;
@@ -355,7 +352,6 @@ export interface ProviderStatus {
     quotaLimit: number;
     rateLimitUntil?: Date;
     lastCall?: Date;
-    circuitBreakerState?: 'closed' | 'open' | 'half-open';
 }
 export interface ComparisonResult {
     teamA: Team;
@@ -381,38 +377,154 @@ export interface LiveScoreUpdate {
     events: MatchEvent[];
     timestamp: Date;
 }
-export interface MLPrediction {
-    matchId: string;
-    homeWinProbability: number;
-    drawProbability: number;
-    awayWinProbability: number;
-    over25Probability?: number;
-    bttsProbability?: number;
+/**
+ * Probability range with uncertainty quantification
+ */
+export interface ProbabilityRange {
+    low: number;
+    mid: number;
+    high: number;
+}
+/**
+ * Data quality assessment
+ */
+export interface DataQuality {
+    score: number;
+    factors: {
+        hasAPIData: boolean;
+        hasRecentData: boolean;
+        sampleSize: 'small' | 'medium' | 'large';
+        dataAge: number;
+        missingDataPoints: string[];
+    };
+}
+/**
+ * Value bet recommendation with full analysis
+ */
+export interface ValueBetRecommendation {
+    selection: string;
+    market: '1x2' | 'over_under' | 'btts' | 'asian_handicap';
+    odds: number;
+    fairOdds: number;
+    value: number;
     confidence: number;
-    factors: PredictionFactor[];
-    timestamp: Date;
+    kellyFraction: number;
+    recommendedStake: number;
+    reasoning: string;
 }
-export interface PredictionFactor {
-    name: string;
-    weight: number;
-    impact: 'positive' | 'negative' | 'neutral';
+/**
+ * Game scenario for skeptic analysis
+ */
+export interface GameScenario {
+    trigger: string;
+    probability: number;
+    impact: 'high' | 'medium' | 'low';
     description: string;
 }
-export interface HistoricalPattern {
-    pattern: string;
-    occurrence: number;
-    successRate: number;
-    avgOdds: number;
-    profit: number;
+/**
+ * Fatigue assessment
+ */
+export interface FatigueAssessment {
+    score: number;
+    daysRest: number;
+    travelDistance?: number;
+    squadDepth: number;
+    keyInjuries: string[];
 }
-export interface TeamHistoricalPerformance {
-    team: Team;
-    totalMatches: number;
-    wins: number;
-    draws: number;
-    losses: number;
-    avgGoalsFor: number;
-    avgGoalsAgainst: number;
-    homeAdvantage: number;
-    patterns: HistoricalPattern[];
+/**
+ * Six-persona analysis output structure
+ */
+export interface SixPersonaAnalysis {
+    dataScientist: {
+        homeWinProbability: ProbabilityRange;
+        drawProbability: ProbabilityRange;
+        awayWinProbability: ProbabilityRange;
+        expectedGoals: {
+            home: number;
+            away: number;
+        };
+        keyStats: ComparisonMetric[];
+    };
+    tacticalScout: {
+        homeFormation?: string;
+        awayFormation?: string;
+        styleMatchup: string;
+        keyBattles: string[];
+        tacticalAdvantage: 'home' | 'away' | 'neutral';
+    };
+    physio: {
+        homeFatigue: FatigueAssessment;
+        awayFatigue: FatigueAssessment;
+        injuryImpact: string;
+    };
+    setPieceAnalyst: {
+        homeStrength: number;
+        awayStrength: number;
+        predictedCorners: number;
+        aerialAdvantage: 'home' | 'away' | 'neutral';
+    };
+    insider: {
+        marketMovement: string;
+        weatherImpact?: string;
+        refereeImpact?: string;
+        managerialContext?: string;
+    };
+    skeptic: {
+        upsetRisk: number;
+        trapIndicators: string[];
+        gameScenarios: GameScenario[];
+    };
+}
+/**
+ * Complete match analysis result (structured output)
+ */
+export interface MatchAnalysisResult {
+    match: {
+        homeTeam: string;
+        awayTeam: string;
+        league?: string;
+        date?: Date;
+        matchId?: string;
+    };
+    dataQuality: DataQuality;
+    analysis: SixPersonaAnalysis;
+    predictions: {
+        matchResult: {
+            homeWin: ProbabilityRange;
+            draw: ProbabilityRange;
+            awayWin: ProbabilityRange;
+        };
+        overUnder25: {
+            over: ProbabilityRange;
+            under: ProbabilityRange;
+        };
+        btts: {
+            yes: ProbabilityRange;
+            no: ProbabilityRange;
+        };
+    };
+    valueBets: ValueBetRecommendation[];
+    verdict: {
+        summary: string;
+        bestBet: string;
+        confidence: number;
+        riskLevel: 'low' | 'medium' | 'high';
+    };
+    metadata: {
+        generatedAt: Date;
+        dataSources: string[];
+    };
+}
+/**
+ * API Match data bundle
+ */
+export interface APIMatchData {
+    match?: Match;
+    h2h?: HeadToHead;
+    homeForm?: Match[];
+    awayForm?: Match[];
+    homeStats?: TeamStats;
+    awayStats?: TeamStats;
+    odds?: MatchOdds;
+    lastUpdated?: Date;
 }

package/dist/tools/sports/providers/api.d.ts

@@ -2,7 +2,7 @@
  * SPORTS MODULE API PROVIDERS
  * Concrete implementations of football API providers
  */
-import { Match, Team, Player, TableEntry, APIResponse } from '../core/types.js';
+import { Match, Team, Player, TableEntry, APIResponse, HeadToHead, MatchOdds } from '../core/types.js';
 import { APIProviderBase, FallbackProvider } from '../core/base.js';
 /**
  * API-Football Provider (via RapidAPI)
@@ -19,12 +19,17 @@ export declare class APIFootballProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatch;
     private transformTeam;
     private transformPlayer;
     private transformTableEntry;
     private mapStatus;
     private mapPosition;
+    private transformH2H;
+    private transformOdds;
 }
 /**
  * Football-Data.org Provider
@@ -41,6 +46,9 @@ export declare class FootballDataProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatchFD;
     private transformTeamFD;
     private transformTableEntryFD;
@@ -61,6 +69,9 @@ export declare class SportsDBProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatchDB;
     private transformTeamDB;
     private transformPlayerDB;

package/dist/tools/sports/providers/api.js

@@ -88,6 +88,58 @@ export class APIFootballProvider extends APIProviderBase {
         }
         return response;
     }
+    // ============= New Methods for Enhanced Analysis =============
+    async getH2H(matchId, team1Id, team2Id) {
+        const cacheKey = `h2h:api-football:${matchId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        // Use team IDs if provided, otherwise fetch match first to get teams
+        let homeId = team1Id;
+        let awayId = team2Id;
+        if (!homeId || !awayId) {
+            const matchResult = await this.getMatch(matchId);
+            if (!matchResult.success || !matchResult.data) {
+                return { success: false, error: 'Could not resolve team IDs for H2H' };
+            }
+            homeId = matchResult.data.homeTeam.id;
+            awayId = matchResult.data.awayTeam.id;
+        }
+        const response = await this.callAPI(`/fixtures/headtohead?h2h=${homeId}-${awayId}`);
+        if (response.success && response.data?.response) {
+            const h2h = this.transformH2H(response.data.response, homeId, awayId);
+            this.cache.set(cacheKey, h2h);
+            return { success: true, data: h2h, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getTeamForm(teamId, last = 5) {
+        const cacheKey = `form:api-football:${teamId}:${last}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        const currentYear = new Date().getFullYear();
+        const response = await this.callAPI(`/fixtures?team=${teamId}&last=${last}&season=${currentYear}`);
+        if (response.success && response.data?.response) {
+            const matches = response.data.response.map((m) => this.transformMatch(m));
+            this.cache.set(cacheKey, matches);
+            return { success: true, data: matches, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getMatchOdds(matchId) {
+        const cacheKey = `odds:api-football:${matchId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        const response = await this.callAPI(`/odds?fixture=${matchId}`);
+        if (response.success && response.data?.response?.[0]) {
+            const odds = this.transformOdds(response.data.response[0]);
+            this.cache.set(cacheKey, odds);
+            return { success: true, data: odds, provider: 'api-football' };
+        }
+        return response;
+    }
     // ============= Transformation Helpers =============
     transformMatch(data) {
         return {
@@ -194,6 +246,87 @@ export class APIFootballProvider extends APIProviderBase {
             return 'FW';
         return 'SUB';
     }
+    transformH2H(data, homeId, awayId) {
+        const matches = data.map(m => this.transformMatch(m));
+        let homeWins = 0;
+        let draws = 0;
+        let awayWins = 0;
+        let homeGoals = 0;
+        let awayGoals = 0;
+        for (const match of matches) {
+            if (!match.score)
+                continue;
+            // Determine which team was home/away in the H2H match
+            const isHomeTeam = match.homeTeam.id === homeId;
+            if (match.score.home === match.score.away) {
+                draws++;
+            }
+            else if (isHomeTeam) {
+                if (match.score.home > match.score.away)
+                    homeWins++;
+                else
+                    awayWins++;
+            }
+            else {
+                if (match.score.away > match.score.home)
+                    homeWins++;
+                else
+                    awayWins++;
+            }
+            homeGoals += isHomeTeam ? match.score.home : match.score.away;
+            awayGoals += isHomeTeam ? match.score.away : match.score.home;
+        }
+        return {
+            homeTeam: matches[0]?.homeTeam.id === homeId ? matches[0].homeTeam : matches[0]?.awayTeam,
+            awayTeam: matches[0]?.homeTeam.id === awayId ? matches[0].homeTeam : matches[0]?.awayTeam,
+            totalMatches: matches.length,
+            homeWins,
+            draws,
+            awayWins,
+            homeGoals,
+            awayGoals,
+            recentMatches: matches.slice(0, 5),
+        };
+    }
+    transformOdds(data) {
+        // Find 1x2 odds from the first bookmaker
+        const bookmaker = data.bookmakers?.[0];
+        const matchWinnerBet = bookmaker?.bets?.find((b) => b.name === 'Match Winner');
+        const homeWinOdds = matchWinnerBet?.values?.find((v) => v.value === 'Home')?.odd;
+        const drawOdds = matchWinnerBet?.values?.find((v) => v.value === 'Draw')?.odd;
+        const awayWinOdds = matchWinnerBet?.values?.find((v) => v.value === 'Away')?.odd;
+        // Default odds if not found
+        const result = {
+            homeWin: parseFloat(homeWinOdds) || 2.0,
+            draw: parseFloat(drawOdds) || 3.0,
+            awayWin: parseFloat(awayWinOdds) || 2.0,
+            provider: bookmaker?.name || 'Unknown',
+            timestamp: new Date(data.update || Date.now()),
+        };
+        // Try to find Asian Handicap odds
+        const ahBet = bookmaker?.bets?.find((b) => b.name?.toLowerCase().includes('asian') ||
+            b.name?.toLowerCase().includes('handicap'));
+        if (ahBet?.values?.[0]) {
+            const ahValue = ahBet.values[0];
+            result.asianHandicap = {
+                home: parseFloat(ahValue.odd) || 2.0,
+                away: parseFloat(ahValue.odd) || 2.0,
+                line: parseFloat(ahValue.value) || 0,
+            };
+        }
+        // Try to find Over/Under odds
+        const ouBet = bookmaker?.bets?.find((b) => b.name?.toLowerCase().includes('over/under'));
+        if (ouBet?.values?.[0]) {
+            const ouValue = ouBet.values[0];
+            const line = parseFloat(ouValue.value?.replace('Over ', '').replace('Under ', '')) || 2.5;
+            result.overUnder = {
+                line,
+                over: parseFloat(ouValue.odd) || 2.0,
+                under: parseFloat(ouValue.odd) || 2.0,
+            };
+        }
+        return result;
+    }
 }
 /**
  * Football-Data.org Provider
@@ -263,6 +396,25 @@ export class FootballDataProvider extends APIProviderBase {
             error: 'Search not available via Football-Data.org',
         };
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        return {
+            success: false,
+            error: 'H2H data not available via Football-Data.org',
+        };
+    }
+    async getTeamForm(teamId, last) {
+        // Football-Data.org has limited form data in match endpoints
+        return {
+            success: false,
+            error: 'Team form not directly available via Football-Data.org',
+        };
+    }
+    async getMatchOdds(matchId) {
+        return {
+            success: false,
+            error: 'Odds not available via Football-Data.org',
+        };
+    }
     // ============= Transformation Helpers (Football-Data.org format) =============
     transformMatchFD(data) {
         return {
@@ -416,6 +568,24 @@ export class SportsDBProvider extends APIProviderBase {
         }
         return response;
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        return {
+            success: false,
+            error: 'H2H data not available via TheSportsDB',
+        };
+    }
+    async getTeamForm(teamId, last) {
+        return {
+            success: false,
+            error: 'Team form not directly available via TheSportsDB',
+        };
+    }
+    async getMatchOdds(matchId) {
+        return {
+            success: false,
+            error: 'Odds not available via TheSportsDB',
+        };
+    }
     // ============= Transformation Helpers (TheSportsDB format) =============
     transformMatchDB(data) {
         return {

package/dist/tools/sports/tools/match.d.ts

@@ -3,8 +3,13 @@
  * Tools for match analysis and live scores
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { MatchAnalysisResult } from '../core/types.js';
 /**
  * Perform comprehensive match analysis using web search
  */
 export declare function performMatchAnalysis(homeTeam: string, awayTeam: string, league?: string, context?: string): Promise<string>;
+/**
+ * Perform structured match analysis with JSON output
+ */
+export declare function performStructuredMatchAnalysis(homeTeam: string, awayTeam: string, league?: string, context?: string): Promise<MatchAnalysisResult>;
 export declare function registerMatchTools(server: McpServer): void;