@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/realtime-manager.js

@@ -0,0 +1,331 @@
+/**
+ * REALTIME DATA MANAGER
+ * WebSocket/SSE based real-time data streaming with fallback polling
+ */
+import { EventEmitter } from 'events';
+import { CacheService } from './cache.js';
+import { logger } from '../../../utils.js';
+import { REALTIME_CONFIG, CACHE_CONFIG } from './constants.js';
+export class RealtimeDataManager extends EventEmitter {
+    cache;
+    wsConnections = new Map();
+    pollingIntervals = new Map();
+    reconnectAttempts = new Map();
+    isRunning = false;
+    constructor() {
+        super();
+        this.cache = new CacheService();
+        this.setMaxListeners(100);
+    }
+    /**
+     * Start the realtime manager
+     */
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        logger.info('[RealtimeManager] Started');
+        // Start polling for live data
+        this.startLiveScoresPolling();
+        this.startOddsPolling();
+    }
+    /**
+     * Stop the realtime manager
+     */
+    stop() {
+        this.isRunning = false;
+        // Close all WebSocket connections
+        for (const [matchId, ws] of this.wsConnections.entries()) {
+            ws.close();
+        }
+        this.wsConnections.clear();
+        // Clear all polling intervals
+        for (const [key, interval] of this.pollingIntervals.entries()) {
+            clearInterval(interval);
+        }
+        this.pollingIntervals.clear();
+        logger.info('[RealtimeManager] Stopped');
+    }
+    /**
+     * Subscribe to a specific match's events
+     */
+    subscribeToMatch(matchId, callback) {
+        const eventName = `match:${matchId}`;
+        this.on(eventName, callback);
+        // Try to establish WebSocket connection if available
+        this.connectToMatchStream(matchId);
+        // Return unsubscribe function
+        return () => {
+            this.off(eventName, callback);
+            this.unsubscribeFromMatch(matchId);
+        };
+    }
+    /**
+     * Subscribe to odds changes for a match
+     */
+    subscribeToOdds(matchId, callback) {
+        const eventName = `odds:${matchId}`;
+        this.on(eventName, callback);
+        return () => {
+            this.off(eventName, callback);
+        };
+    }
+    /**
+     * Subscribe to all live events
+     */
+    subscribeToAllEvents(callback) {
+        this.on('event', callback);
+        return () => this.off('event', callback);
+    }
+    /**
+     * Process and broadcast an event
+     */
+    processEvent(event) {
+        // Update cache
+        this.updateCache(event);
+        // Emit to specific match listeners
+        this.emit(`match:${event.matchId}`, event);
+        // Emit to odds listeners if it's an odds change
+        if (event.type === 'odds_change') {
+            this.emit(`odds:${event.matchId}`, event);
+        }
+        // Emit to global listeners
+        this.emit('event', event);
+        // Log event
+        logger.debug(`[Realtime] Event: ${event.type} | Match: ${event.matchId} | Min: ${event.minute}`);
+    }
+    /**
+     * Get current live matches
+     */
+    getLiveMatches() {
+        const cached = this.cache.get('live:all');
+        return cached || [];
+    }
+    /**
+     * Get match events history
+     */
+    getMatchEvents(matchId) {
+        const cached = this.cache.get(`events:${matchId}`);
+        return cached || [];
+    }
+    /**
+     * Connect to match stream (WebSocket or polling)
+     */
+    async connectToMatchStream(matchId) {
+        // For now, use polling fallback
+        // In production, this would try WebSocket first
+        this.startMatchEventsPolling(matchId);
+    }
+    /**
+     * Unsubscribe from a match
+     */
+    unsubscribeFromMatch(matchId) {
+        // Close WebSocket if exists
+        const ws = this.wsConnections.get(matchId);
+        if (ws) {
+            ws.close();
+            this.wsConnections.delete(matchId);
+        }
+        // Clear polling if no more listeners
+        const listenerCount = this.listenerCount(`match:${matchId}`);
+        if (listenerCount === 0) {
+            const interval = this.pollingIntervals.get(`events:${matchId}`);
+            if (interval) {
+                clearInterval(interval);
+                this.pollingIntervals.delete(`events:${matchId}`);
+            }
+        }
+    }
+    /**
+     * Start polling for live scores
+     */
+    startLiveScoresPolling() {
+        const interval = setInterval(async () => {
+            if (!this.isRunning)
+                return;
+            try {
+                // Fetch live scores from API
+                // This would call your API provider
+                const liveScores = await this.fetchLiveScores();
+                // Update cache
+                this.cache.set('live:all', liveScores, CACHE_CONFIG.TTL.LIVE_SCORES);
+                // Emit update
+                this.emit('live_scores', liveScores);
+                // Check for score changes and emit events
+                this.detectScoreChanges(liveScores);
+            }
+            catch (error) {
+                logger.error('[Realtime] Failed to fetch live scores:', error);
+            }
+        }, REALTIME_CONFIG.POLLING_INTERVALS.LIVE_SCORES);
+        this.pollingIntervals.set('live_scores', interval);
+    }
+    /**
+     * Start polling for odds
+     */
+    startOddsPolling() {
+        const interval = setInterval(async () => {
+            if (!this.isRunning)
+                return;
+            try {
+                const liveMatches = this.getLiveMatches();
+                for (const match of liveMatches) {
+                    const odds = await this.fetchOdds(match.id);
+                    if (odds) {
+                        const cachedOdds = this.cache.get(`odds:${match.id}`);
+                        if (cachedOdds) {
+                            // Detect changes
+                            this.detectOddsChanges(match.id, cachedOdds, odds);
+                        }
+                        this.cache.set(`odds:${match.id}`, odds, CACHE_CONFIG.TTL.ODDS);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error('[Realtime] Failed to fetch odds:', error);
+            }
+        }, REALTIME_CONFIG.POLLING_INTERVALS.ODDS);
+        this.pollingIntervals.set('odds', interval);
+    }
+    /**
+     * Start polling for specific match events
+     */
+    startMatchEventsPolling(matchId) {
+        if (this.pollingIntervals.has(`events:${matchId}`))
+            return;
+        const interval = setInterval(async () => {
+            if (!this.isRunning)
+                return;
+            try {
+                const events = await this.fetchMatchEvents(matchId);
+                const cachedEvents = this.getMatchEvents(matchId);
+                // Find new events
+                const newEvents = events.filter(e => !cachedEvents.some(ce => ce.timestamp === e.timestamp && ce.type === e.type));
+                for (const event of newEvents) {
+                    this.processEvent(event);
+                }
+            }
+            catch (error) {
+                logger.error(`[Realtime] Failed to fetch events for match ${matchId}:`, error);
+            }
+        }, REALTIME_CONFIG.POLLING_INTERVALS.MATCH_EVENTS);
+        this.pollingIntervals.set(`events:${matchId}`, interval);
+    }
+    /**
+     * Detect score changes and emit goal events
+     */
+    detectScoreChanges(matches) {
+        for (const match of matches) {
+            const cachedMatch = this.cache.get(`match:${match.id}`);
+            if (cachedMatch && cachedMatch.score && match.score) {
+                // Check for home team goal
+                if (match.score.home > cachedMatch.score.home) {
+                    this.processEvent({
+                        type: 'goal',
+                        matchId: match.id,
+                        timestamp: Date.now(),
+                        minute: match.minute,
+                        data: {
+                            team: 'home',
+                            score: match.score,
+                            previousScore: cachedMatch.score,
+                        },
+                    });
+                }
+                // Check for away team goal
+                if (match.score.away > cachedMatch.score.away) {
+                    this.processEvent({
+                        type: 'goal',
+                        matchId: match.id,
+                        timestamp: Date.now(),
+                        minute: match.minute,
+                        data: {
+                            team: 'away',
+                            score: match.score,
+                            previousScore: cachedMatch.score,
+                        },
+                    });
+                }
+            }
+            // Update match cache
+            this.cache.set(`match:${match.id}`, match, CACHE_CONFIG.TTL.MATCH_DETAILS);
+        }
+    }
+    /**
+     * Detect odds changes and emit events
+     */
+    detectOddsChanges(matchId, oldOdds, newOdds) {
+        const markets = [
+            { key: 'homeWin', name: 'Home Win' },
+            { key: 'draw', name: 'Draw' },
+            { key: 'awayWin', name: 'Away Win' },
+        ];
+        for (const market of markets) {
+            const oldValue = oldOdds[market.key];
+            const newValue = newOdds[market.key];
+            if (oldValue && newValue && oldValue !== newValue) {
+                const change = ((newValue - oldValue) / oldValue) * 100;
+                // Only emit if change is significant (>5%)
+                if (Math.abs(change) > 5) {
+                    this.processEvent({
+                        type: 'odds_change',
+                        matchId,
+                        timestamp: Date.now(),
+                        data: {
+                            bookmaker: newOdds.provider,
+                            market: market.name,
+                            selection: market.key,
+                            oldOdds: oldValue,
+                            newOdds: newValue,
+                            change,
+                            timestamp: Date.now(),
+                        },
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Update cache with event
+     */
+    updateCache(event) {
+        // Invalidate related cache entries
+        this.cache.invalidatePattern(`match:${event.matchId}*`);
+        // Store event in history
+        const eventsKey = `events:${event.matchId}`;
+        const existingEvents = this.cache.get(eventsKey) || [];
+        existingEvents.push(event);
+        // Keep only last 100 events
+        if (existingEvents.length > 100) {
+            existingEvents.shift();
+        }
+        this.cache.set(eventsKey, existingEvents, CACHE_CONFIG.TTL.LIVE_EVENTS);
+    }
+    // Placeholder methods - implement with actual API calls
+    async fetchLiveScores() {
+        // Implement with your API provider
+        return [];
+    }
+    async fetchOdds(matchId) {
+        // Implement with your API provider
+        return null;
+    }
+    async fetchMatchEvents(matchId) {
+        // Implement with your API provider
+        return [];
+    }
+}
+// Singleton instance
+let globalRealtimeManager = null;
+export function getRealtimeManager() {
+    if (!globalRealtimeManager) {
+        globalRealtimeManager = new RealtimeDataManager();
+    }
+    return globalRealtimeManager;
+}
+export function resetRealtimeManager() {
+    if (globalRealtimeManager) {
+        globalRealtimeManager.stop();
+    }
+    globalRealtimeManager = null;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * RETRY MECHANISM
+ * Exponential backoff with jitter for resilient API calls
+ */
+export interface RetryConfig {
+    maxAttempts: number;
+    initialDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+    retryableErrors?: string[];
+    onRetry?: (attempt: number, error: Error, delay: number) => void;
+}
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+export declare const AGGRESSIVE_RETRY_CONFIG: RetryConfig;
+export declare const LIVE_DATA_RETRY_CONFIG: RetryConfig;
+/**
+ * Execute a function with retry logic
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>, context?: string): Promise<T>;
+/**
+ * Retry with circuit breaker combination
+ */
+export declare function withRetryAndCircuitBreaker<T>(fn: () => Promise<T>, circuitBreaker: {
+    execute: <U>(fn: () => Promise<U>) => Promise<U>;
+}, config?: Partial<RetryConfig>, context?: string): Promise<T>;
+/**
+ * Create a retryable wrapper for a function
+ */
+export declare function createRetryable<T extends (...args: any[]) => Promise<any>>(fn: T, config?: Partial<RetryConfig>, context?: string): T;

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

@@ -0,0 +1,77 @@
+/**
+ * RETRY MECHANISM
+ * Exponential backoff with jitter for resilient API calls
+ */
+import { logger } from '../../../utils.js';
+export const DEFAULT_RETRY_CONFIG = {
+    maxAttempts: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 2,
+    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', '503', '502', '504', '429'],
+};
+export const AGGRESSIVE_RETRY_CONFIG = {
+    maxAttempts: 5,
+    initialDelay: 500,
+    maxDelay: 60000,
+    backoffMultiplier: 2,
+    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', '503', '502', '504', '429', '500'],
+};
+export const LIVE_DATA_RETRY_CONFIG = {
+    maxAttempts: 3,
+    initialDelay: 200,
+    maxDelay: 5000,
+    backoffMultiplier: 1.5,
+    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', '503', '504'],
+};
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with retry logic
+ */
+export async function withRetry(fn, config = {}, context) {
+    const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+    let lastError = null;
+    for (let attempt = 1; attempt <= fullConfig.maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Check if error is retryable
+            if (fullConfig.retryableErrors && !fullConfig.retryableErrors.some(e => lastError.message.includes(e) ||
+                lastError.code?.includes(e))) {
+                throw lastError;
+            }
+            if (attempt === fullConfig.maxAttempts) {
+                break;
+            }
+            // Calculate delay with exponential backoff and jitter
+            const delay = Math.min(fullConfig.initialDelay * Math.pow(fullConfig.backoffMultiplier, attempt - 1), fullConfig.maxDelay);
+            const jitteredDelay = delay * (0.8 + Math.random() * 0.4); // ±20% jitter
+            const contextStr = context ? `[${context}]` : '';
+            logger.warn(`[Retry${contextStr}] Attempt ${attempt}/${fullConfig.maxAttempts} failed: ${lastError.message}. Retrying in ${Math.round(jitteredDelay)}ms...`);
+            if (fullConfig.onRetry) {
+                fullConfig.onRetry(attempt, lastError, jitteredDelay);
+            }
+            await sleep(jitteredDelay);
+        }
+    }
+    const contextStr = context ? `[${context}]` : '';
+    throw new Error(`[Retry${contextStr}] All ${fullConfig.maxAttempts} attempts failed. Last error: ${lastError?.message}`);
+}
+/**
+ * Retry with circuit breaker combination
+ */
+export async function withRetryAndCircuitBreaker(fn, circuitBreaker, config, context) {
+    return circuitBreaker.execute(() => withRetry(fn, config, context));
+}
+/**
+ * Create a retryable wrapper for a function
+ */
+export function createRetryable(fn, config, context) {
+    return (async (...args) => {
+        return withRetry(() => fn(...args), config, context);
+    });
+}

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' | 'scraper';
+export type ProviderType = 'api-football' | 'football-data' | 'sports-db' | 'odds-api' | 'sportradar' | 'scraper';
 export interface SearchQuery {
     type: QueryType;
     query: string;
@@ -175,6 +175,8 @@ export interface Match {
     homeSubstitutes?: Player[];
     awaySubstitutes?: Player[];
     events?: MatchEvent[];
+    dataQuality?: number;
+    lastUpdated?: Date;
 }
 export interface MatchOdds {
     homeWin: number;
@@ -344,6 +346,7 @@ export interface APIResponse<T = any> {
     provider?: ProviderType;
     cached?: boolean;
     rateLimited?: boolean;
+    quality?: number;
 }
 export interface ProviderStatus {
     name: ProviderType;
@@ -352,6 +355,7 @@ export interface ProviderStatus {
     quotaLimit: number;
     rateLimitUntil?: Date;
     lastCall?: Date;
+    circuitBreakerState?: 'closed' | 'open' | 'half-open';
 }
 export interface ComparisonResult {
     teamA: Team;
@@ -377,3 +381,38 @@ export interface LiveScoreUpdate {
     events: MatchEvent[];
     timestamp: Date;
 }
+export interface MLPrediction {
+    matchId: string;
+    homeWinProbability: number;
+    drawProbability: number;
+    awayWinProbability: number;
+    over25Probability?: number;
+    bttsProbability?: number;
+    confidence: number;
+    factors: PredictionFactor[];
+    timestamp: Date;
+}
+export interface PredictionFactor {
+    name: string;
+    weight: number;
+    impact: 'positive' | 'negative' | 'neutral';
+    description: string;
+}
+export interface HistoricalPattern {
+    pattern: string;
+    occurrence: number;
+    successRate: number;
+    avgOdds: number;
+    profit: number;
+}
+export interface TeamHistoricalPerformance {
+    team: Team;
+    totalMatches: number;
+    wins: number;
+    draws: number;
+    losses: number;
+    avgGoalsFor: number;
+    avgGoalsAgainst: number;
+    homeAdvantage: number;
+    patterns: HistoricalPattern[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.0.8",
+  "version": "10000.1.0",
   "publishConfig": {
     "access": "public"
   },