@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

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

@@ -0,0 +1,106 @@
+/**
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
+ */
+/**
+ * CacheService - Thread-safe TTL-based caching with persistence
+ */
+export declare class CacheService {
+    private cache;
+    private cachePath;
+    private maxAge;
+    private maxSize;
+    private savePending;
+    private saveTimer;
+    constructor(cachePath?: string, maxAge?: number, maxSize?: number);
+    /**
+     * Generate a cache key from components
+     */
+    static generateKey(...parts: (string | number)[]): string;
+    /**
+     * Get a value from cache
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set a value in cache
+     */
+    set<T>(key: string, data: T, ttl?: number): void;
+    /**
+     * Check if a key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a specific key
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hits: number;
+        entries: Array<{
+            key: string;
+            hits: number;
+            age: number;
+            ttl: number;
+        }>;
+    };
+    /**
+     * Clean up expired entries
+     */
+    cleanup(): number;
+    /**
+     * Evict the oldest entry (LRU)
+     */
+    private evictOldest;
+    /**
+     * Schedule a save operation (debounced)
+     */
+    private scheduleSave;
+    /**
+     * Save cache to file
+     */
+    private saveToFile;
+    /**
+     * Load cache from file
+     */
+    private loadFromFile;
+    /**
+     * Force save cache to file immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Get or set pattern - returns cached value or computes and caches it
+     */
+    getOrSet<T>(key: string, factory: () => T | Promise<T>, ttl?: number): Promise<T>;
+    /**
+     * Get multiple keys at once
+     */
+    getMultiple<T>(keys: string[]): Map<string, T>;
+    /**
+     * Set multiple keys at once
+     */
+    setMultiple<T>(entries: Map<string, T>, ttl?: number): void;
+    /**
+     * Invalidate cache by pattern
+     */
+    invalidatePattern(pattern: string): number;
+    /**
+     * Get cache size breakdown by key prefix
+     */
+    getBreakdown(): Record<string, number>;
+}
+/**
+ * Get or create the global cache instance
+ */
+export declare function getGlobalCache(): CacheService;
+/**
+ * Reset the global cache instance
+ */
+export declare function resetGlobalCache(): void;

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

@@ -0,0 +1,305 @@
+/**
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { CACHE_CONFIG } from './constants.js';
+import { logger } from '../../../utils.js';
+/**
+ * CacheService - Thread-safe TTL-based caching with persistence
+ */
+export class CacheService {
+    cache = new Map();
+    cachePath;
+    maxAge;
+    maxSize;
+    savePending = false;
+    saveTimer = null;
+    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE) {
+        this.cachePath = path.resolve(cachePath);
+        this.maxAge = maxAge;
+        this.maxSize = maxSize;
+        this.loadFromFile();
+    }
+    /**
+     * Generate a cache key from components
+     */
+    static generateKey(...parts) {
+        return parts.join(':').toLowerCase().replace(/\s+/g, '_');
+    }
+    /**
+     * Get a value from cache
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if expired
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            logger.debug(`Cache expired: ${key}`);
+            return null;
+        }
+        // Increment hit counter
+        entry.hits++;
+        logger.debug(`Cache hit: ${key} (${entry.hits} hits)`);
+        return entry.data;
+    }
+    /**
+     * Set a value in cache
+     */
+    set(key, data, ttl) {
+        const now = Date.now();
+        // Check if we need to evict old entries
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            this.evictOldest();
+        }
+        this.cache.set(key, {
+            key,
+            data,
+            timestamp: now,
+            ttl: ttl || this.maxAge,
+            hits: 0,
+        });
+        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}ms)`);
+        this.scheduleSave();
+    }
+    /**
+     * Check if a key exists and is not expired
+     */
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Delete a specific key
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        logger.info('Cache cleared');
+        this.scheduleSave();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const now = Date.now();
+        const entries = Array.from(this.cache.values()).map(entry => ({
+            key: entry.key,
+            hits: entry.hits,
+            age: now - entry.timestamp,
+            ttl: entry.ttl,
+        }));
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            hits: entries.reduce((sum, e) => sum + e.hits, 0),
+            entries: entries.sort((a, b) => b.hits - a.hits),
+        };
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > entry.ttl) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            logger.info(`Cleaned up ${removed} expired cache entries`);
+            this.scheduleSave();
+        }
+        return removed;
+    }
+    /**
+     * Evict the oldest entry (LRU)
+     */
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+            logger.debug(`Evicted oldest cache entry: ${oldestKey}`);
+        }
+    }
+    /**
+     * Schedule a save operation (debounced)
+     */
+    scheduleSave() {
+        if (this.saveTimer) {
+            return;
+        }
+        this.saveTimer = setTimeout(() => {
+            this.saveToFile();
+            this.saveTimer = null;
+        }, 1000); // Save after 1 second of inactivity
+    }
+    /**
+     * Save cache to file
+     */
+    async saveToFile() {
+        if (this.savePending)
+            return;
+        this.savePending = true;
+        try {
+            const data = Array.from(this.cache.entries());
+            const tmpPath = `${this.cachePath}.tmp`;
+            await fs.writeFile(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.cachePath);
+            logger.debug(`Cache saved to ${this.cachePath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save cache: ${error}`);
+        }
+        finally {
+            this.savePending = false;
+        }
+    }
+    /**
+     * Load cache from file
+     */
+    async loadFromFile() {
+        try {
+            const data = await fs.readFile(this.cachePath, 'utf-8');
+            const entries = JSON.parse(data);
+            // Restore only non-expired entries
+            const now = Date.now();
+            let restored = 0;
+            for (const [key, entry] of entries) {
+                if (now - entry.timestamp < entry.ttl) {
+                    this.cache.set(key, entry);
+                    restored++;
+                }
+            }
+            logger.info(`Cache loaded: ${restored}/${entries.length} entries restored`);
+        }
+        catch (error) {
+            // File doesn't exist or is invalid - start fresh
+            logger.debug('No existing cache file found, starting fresh');
+        }
+    }
+    /**
+     * Force save cache to file immediately
+     */
+    async flush() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        await this.saveToFile();
+    }
+    /**
+     * Get or set pattern - returns cached value or computes and caches it
+     */
+    async getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+    /**
+     * Get multiple keys at once
+     */
+    getMultiple(keys) {
+        const result = new Map();
+        for (const key of keys) {
+            const value = this.get(key);
+            if (value !== null) {
+                result.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Set multiple keys at once
+     */
+    setMultiple(entries, ttl) {
+        for (const [key, value] of entries.entries()) {
+            this.set(key, value, ttl);
+        }
+    }
+    /**
+     * Invalidate cache by pattern
+     */
+    invalidatePattern(pattern) {
+        const regex = new RegExp(pattern);
+        let removed = 0;
+        for (const key of this.cache.keys()) {
+            if (regex.test(key)) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            logger.info(`Invalidated ${removed} entries matching pattern: ${pattern}`);
+            this.scheduleSave();
+        }
+        return removed;
+    }
+    /**
+     * Get cache size breakdown by key prefix
+     */
+    getBreakdown() {
+        const breakdown = {};
+        for (const key of this.cache.keys()) {
+            const prefix = key.split(':')[0] || 'unknown';
+            breakdown[prefix] = (breakdown[prefix] || 0) + 1;
+        }
+        return breakdown;
+    }
+}
+/**
+ * Singleton cache instance
+ */
+let globalCache = null;
+/**
+ * Get or create the global cache instance
+ */
+export function getGlobalCache() {
+    if (!globalCache) {
+        globalCache = new CacheService();
+        // Cleanup expired entries every 5 minutes
+        setInterval(() => {
+            globalCache?.cleanup();
+        }, 5 * 60 * 1000);
+    }
+    return globalCache;
+}
+/**
+ * Reset the global cache instance
+ */
+export function resetGlobalCache() {
+    if (globalCache) {
+        globalCache.clear();
+    }
+    globalCache = null;
+}

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

@@ -0,0 +1,179 @@
+/**
+ * SPORTS MODULE CONSTANTS
+ * Configuration values for the football intelligence system
+ */
+export declare const API_CONFIG: {
+    readonly API_FOOTBALL_KEY: string;
+    readonly API_FOOTBALL_BASE: "https://api-football-v1.p.rapidapi.com/v3";
+    readonly API_FOOTBALL_HOST: "api-football-v1.p.rapidapi.com";
+    readonly FOOTBALL_DATA_KEY: string;
+    readonly FOOTBALL_DATA_BASE: "https://api.football-data.org/v4";
+    readonly SPORTS_DB_KEY: string;
+    readonly SPORTS_DB_BASE: "https://www.thesportsdb.com/api/v1/json";
+    readonly RATE_LIMITS: {
+        readonly API_FOOTBALL: 10;
+        readonly FOOTBALL_DATA: 10;
+        readonly SPORTS_DB: 30;
+    };
+};
+export declare const CACHE_CONFIG: {
+    readonly DEFAULT_TTL: number;
+    readonly TTL: {
+        readonly LIVE_SCORES: number;
+        readonly MATCH_DETAILS: number;
+        readonly STANDINGS: number;
+        readonly TEAM_STATS: number;
+        readonly PLAYER_STATS: number;
+        readonly ODDS: number;
+        readonly TRANSFER_NEWS: number;
+    };
+    readonly CACHE_PATH: string;
+    readonly MAX_SIZE: 1000;
+};
+export declare const SCRAPER_CONFIG: {
+    readonly PRIORITY_DOMAINS: readonly ["whoscored.com", "sofascore.com", "flashscore.com", "understat.com", "fbref.com", "bbc.co.uk/sport", "skysports.com", "sportsmole.co.uk", "goal.com", "thesquareball.net"];
+    readonly TIMEOUT: 15000;
+    readonly USER_AGENT: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36";
+    readonly MAX_CONTENT_LENGTH: 50000;
+};
+export declare const LEAGUES: {
+    readonly PREMIER_LEAGUE: {
+        readonly id: 39;
+        readonly name: "Premier League";
+        readonly country: "England";
+        readonly code: "PL";
+    };
+    readonly LA_LIGA: {
+        readonly id: 140;
+        readonly name: "La Liga";
+        readonly country: "Spain";
+        readonly code: "LL";
+    };
+    readonly BUNDESLIGA: {
+        readonly id: 78;
+        readonly name: "Bundesliga";
+        readonly country: "Germany";
+        readonly code: "BL1";
+    };
+    readonly SERIE_A: {
+        readonly id: 135;
+        readonly name: "Serie A";
+        readonly country: "Italy";
+        readonly code: "SA";
+    };
+    readonly LIGUE_1: {
+        readonly id: 61;
+        readonly name: "Ligue 1";
+        readonly country: "France";
+        readonly code: "FL1";
+    };
+    readonly EREDIVISIE: {
+        readonly id: 88;
+        readonly name: "Eredivisie";
+        readonly country: "Netherlands";
+        readonly code: "DED";
+    };
+    readonly PRIMEIRA_LIGA: {
+        readonly id: 94;
+        readonly name: "Primeira Liga";
+        readonly country: "Portugal";
+        readonly code: "PPL";
+    };
+    readonly CHAMPIONS_LEAGUE: {
+        readonly id: 2;
+        readonly name: "UEFA Champions League";
+        readonly country: "Europe";
+        readonly code: "CL";
+    };
+    readonly EUROPA_LEAGUE: {
+        readonly id: 3;
+        readonly name: "UEFA Europa League";
+        readonly country: "Europe";
+        readonly code: "EL";
+    };
+    readonly FA_CUP: {
+        readonly id: 45;
+        readonly name: "FA Cup";
+        readonly country: "England";
+        readonly code: "FAC";
+    };
+    readonly J_LEAGUE: {
+        readonly id: 98;
+        readonly name: "J1 League";
+        readonly country: "Japan";
+        readonly code: "J1";
+    };
+    readonly K_LEAGUE: {
+        readonly id: 251;
+        readonly name: "K League 1";
+        readonly country: "South Korea";
+        readonly code: "KL1";
+    };
+    readonly THAI_LEAGUE: {
+        readonly id: 305;
+        readonly name: "Thai League 1";
+        readonly country: "Thailand";
+        readonly code: "TL1";
+    };
+    readonly CSL: {
+        readonly id: 169;
+        readonly name: "Chinese Super League";
+        readonly country: "China";
+        readonly code: "CSL";
+    };
+};
+export declare const QUERY_TYPES: {
+    readonly GENERAL: "general";
+    readonly H2H: "h2h";
+    readonly FORM: "form";
+    readonly NEWS: "news";
+    readonly STATS: "stats";
+    readonly ODDS: "odds";
+    readonly REFEREE: "referee";
+    readonly WEATHER: "weather";
+    readonly FATIGUE: "fatigue";
+    readonly SETPIECES: "setpieces";
+};
+export declare const BETTING: {
+    readonly KELLY_FULL: "full";
+    readonly KELLY_HALF: "half";
+    readonly KELLY_QUARTER: "quarter";
+    readonly VALUE_THRESHOLD: 0.05;
+    readonly HIGH_VALUE_THRESHOLD: 0.1;
+    readonly CONFIDENCE: {
+        readonly LOW: 50;
+        readonly MEDIUM: 65;
+        readonly HIGH: 80;
+        readonly VERY_HIGH: 90;
+    };
+    readonly DEFAULT_BANKROLL: 1000;
+    readonly MAX_STAKE_PERCENTAGE: 0.05;
+};
+export declare const POSITIONS: {
+    readonly GOALKEEPER: "GK";
+    readonly DEFENDER: "DF";
+    readonly MIDFIELDER: "MF";
+    readonly FORWARD: "FW";
+    readonly SUBSTITUTE: "SUB";
+};
+export declare const MATCH_STATUS: {
+    readonly SCHEDULED: "scheduled";
+    readonly LIVE: "live";
+    readonly FINISHED: "finished";
+    readonly POSTPONED: "postponed";
+    readonly CANCELLED: "cancelled";
+    readonly ABANDONED: "abandoned";
+};
+export declare const ERRORS: {
+    readonly NO_API_KEY: "No API key configured. Please set environment variables.";
+    readonly RATE_LIMITED: "API rate limit exceeded. Please try again later.";
+    readonly NOT_FOUND: "Requested data not found.";
+    readonly TIMEOUT: "Request timed out.";
+    readonly INVALID_RESPONSE: "Invalid response from API.";
+    readonly ALL_PROVIDERS_FAILED: "All data providers failed.";
+};
+export declare const MODULE_INFO: {
+    readonly NAME: "sports-module";
+    readonly VERSION: "2.0.0";
+    readonly DESCRIPTION: "Football Intelligence System for MCP Server";
+};