@gotza02/sequential-thinking 10000.2.0 → 10000.2.1

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

@@ -73,7 +73,8 @@ export declare abstract class APIProviderBase implements IDataProvider {
     protected rateLimitUntil: Date | null;
     protected lastCall: Date | null;
     protected callCount: number;
-    constructor(type: ProviderType, apiKey: string, baseUrl: string, rateLimit?: number);
+    constructor(type: ProviderType, apiKey: string, baseUrl: string, rateLimit?: number, // calls per minute
+    cache?: CacheService);
     /**
      * Check if provider has valid credentials
      */
@@ -131,7 +132,7 @@ export declare abstract class APIProviderBase implements IDataProvider {
 export declare abstract class ScraperProviderBase implements IDataProvider {
     protected cache: CacheService;
     readonly type: ProviderType;
-    constructor();
+    constructor(cache?: CacheService);
     isAvailable(): boolean;
     getStatus(): ProviderStatus;
     abstract getMatch(matchId: string): Promise<APIResponse<Match>>;

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

@@ -2,7 +2,7 @@
  * SPORTS MODULE BASE CLASSES
  * Abstract base classes and interfaces for data providers
  */
-import { CacheService } from './cache.js';
+import { CacheService, getGlobalCache } from './cache.js';
 import { logger } from '../../../utils.js';
 /**
  * Abstract base class for API-based providers
@@ -16,13 +16,13 @@ export class APIProviderBase {
     rateLimitUntil = null;
     lastCall = null;
     callCount = 0;
-    constructor(type, apiKey, baseUrl, rateLimit = 10 // calls per minute
-    ) {
+    constructor(type, apiKey, baseUrl, rateLimit = 10, // calls per minute
+    cache) {
         this.type = type;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.rateLimit = rateLimit;
-        this.cache = new CacheService();
+        this.cache = cache || getGlobalCache();
     }
     /**
      * Check if provider has valid credentials
@@ -86,7 +86,9 @@ export class APIProviderBase {
                 // Handle rate limiting
                 if (response.status === 429) {
                     const retryAfter = response.headers.get('Retry-After');
-                    this.rateLimitUntil = new Date(Date.now() + (retryAfter ? parseInt(retryAfter) * 1000 : 60000));
+                    const retrySeconds = retryAfter ? parseInt(retryAfter, 10) : NaN;
+                    const delayMs = isNaN(retrySeconds) ? 60000 : retrySeconds * 1000;
+                    this.rateLimitUntil = new Date(Date.now() + delayMs);
                     return {
                         success: false,
                         error: 'Rate limited',
@@ -127,8 +129,8 @@ export class APIProviderBase {
 export class ScraperProviderBase {
     cache;
     type = 'scraper';
-    constructor() {
-        this.cache = new CacheService();
+    constructor(cache) {
+        this.cache = cache || getGlobalCache();
     }
     isAvailable() {
         return true; // Scraping is always "available"
@@ -181,8 +183,8 @@ export class ScraperProviderBase {
 export class FallbackProvider {
     providers;
     cache;
-    type = 'scraper';
-    constructor(providers, cache = new CacheService()) {
+    type = 'api-football'; // Most common API type
+    constructor(providers, cache = getGlobalCache()) {
         this.providers = providers;
         this.cache = cache;
     }
@@ -275,7 +277,7 @@ export class FallbackProvider {
 export class SportsToolBase {
     cache;
     constructor(cache) {
-        this.cache = cache || new CacheService();
+        this.cache = cache || getGlobalCache();
     }
     /**
      * Format error message for user

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

@@ -12,7 +12,12 @@ export declare class CacheService {
     private maxSize;
     private savePending;
     private saveTimer;
+    cleanupInterval: NodeJS.Timeout | null;
     constructor(cachePath?: string, maxAge?: number, maxSize?: number);
+    /**
+     * Initialize cache - must be called after construction
+     */
+    initialize(): Promise<void>;
     /**
      * Generate a cache key from components
      */
@@ -37,6 +42,10 @@ export declare class CacheService {
      * Clear all cache entries
      */
     clear(): void;
+    /**
+     * Stop cleanup interval and clear all resources
+     */
+    dispose(): void;
     /**
      * Get cache statistics
      */

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

@@ -16,11 +16,17 @@ export class CacheService {
     maxSize;
     savePending = false;
     saveTimer = null;
+    cleanupInterval = 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();
+    }
+    /**
+     * Initialize cache - must be called after construction
+     */
+    async initialize() {
+        await this.loadFromFile();
     }
     /**
      * Generate a cache key from components
@@ -95,6 +101,20 @@ export class CacheService {
         logger.info('Cache cleared');
         this.scheduleSave();
     }
+    /**
+     * Stop cleanup interval and clear all resources
+     */
+    dispose() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        this.cache.clear();
+    }
     /**
      * Get cache statistics
      */
@@ -288,8 +308,10 @@ let globalCache = null;
 export function getGlobalCache() {
     if (!globalCache) {
         globalCache = new CacheService();
+        // Initialize async (fire and forget - will be ready on next tick)
+        globalCache.initialize().catch(err => logger.error('Cache init failed:', err));
         // Cleanup expired entries every 5 minutes
-        setInterval(() => {
+        globalCache.cleanupInterval = setInterval(() => {
             globalCache?.cleanup();
         }, 5 * 60 * 1000);
     }
@@ -300,7 +322,7 @@ export function getGlobalCache() {
  */
 export function resetGlobalCache() {
     if (globalCache) {
-        globalCache.clear();
+        globalCache.dispose();
     }
     globalCache = null;
 }

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

@@ -138,7 +138,9 @@ export interface TableEntry {
         drawn: number;
         lost: number;
         goalsFor: number;
-        against: number;
+        goalsAgainst: number;
+        /** @deprecated Use goalsAgainst instead */
+        against?: number;
     };
     awayRecord?: {
         played: number;
@@ -146,7 +148,9 @@ export interface TableEntry {
         drawn: number;
         lost: number;
         goalsFor: number;
-        against: number;
+        goalsAgainst: number;
+        /** @deprecated Use goalsAgainst instead */
+        against?: number;
     };
     lastFive?: {
         result: 'W' | 'D' | 'L';

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

@@ -61,6 +61,10 @@ export declare class FootballDataProvider extends APIProviderBase {
 export declare class SportsDBProvider extends APIProviderBase {
     constructor();
     protected getAuthHeaders(): Record<string, string>;
+    /**
+     * Override callAPI to inject API key in URL for TheSportsDB
+     */
+    protected callAPI<T>(endpoint: string, options?: RequestInit): Promise<APIResponse<T>>;
     protected transformResponse<T>(data: any): T;
     getMatch(matchId: string): Promise<APIResponse<Match>>;
     getLiveMatches(): Promise<APIResponse<Match[]>>;

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

@@ -65,7 +65,8 @@ export class APIFootballProvider extends APIProviderBase {
         return response;
     }
     async getPlayer(playerId) {
-        const response = await this.callAPI(`/players?id=${playerId}&season=2024`);
+        const currentYear = new Date().getFullYear();
+        const response = await this.callAPI(`/players?id=${playerId}&season=${currentYear}`);
         if (response.success && response.data?.response?.[0]) {
             const player = this.transformPlayer(response.data.response[0]);
             return { success: true, data: player, provider: 'api-football' };
@@ -81,7 +82,8 @@ export class APIFootballProvider extends APIProviderBase {
         return response;
     }
     async searchPlayers(query) {
-        const response = await this.callAPI(`/players?search=${encodeURIComponent(query)}&season=2024`);
+        const currentYear = new Date().getFullYear();
+        const response = await this.callAPI(`/players?search=${encodeURIComponent(query)}&season=${currentYear}`);
         if (response.success && response.data?.response) {
             const players = response.data.response.map((p) => this.transformPlayer(p));
             return { success: true, data: players, provider: 'api-football' };
@@ -156,11 +158,11 @@ export class APIFootballProvider extends APIProviderBase {
             status: this.mapStatus(data.fixture.status.long),
             venue: data.fixture.venue?.name,
             score: data.goals ? {
-                home: data.goals.home,
-                away: data.goals.away,
-                halfTime: data.score.halftime ? {
-                    home: data.score.halftime.home,
-                    away: data.score.halftime.away,
+                home: data.goals.home ?? 0,
+                away: data.goals.away ?? 0,
+                halfTime: data.score?.halftime ? {
+                    home: data.score.halftime.home ?? 0,
+                    away: data.score.halftime.away ?? 0,
                 } : undefined,
             } : undefined,
             minute: data.fixture.status?.elapsed,
@@ -208,7 +210,7 @@ export class APIFootballProvider extends APIProviderBase {
                 drawn: data.home.draw,
                 lost: data.home.lose,
                 goalsFor: data.home.goals.for,
-                against: data.home.goals.against,
+                goalsAgainst: data.home.goals.against,
             } : undefined,
             awayRecord: data.away ? {
                 played: data.away.played,
@@ -216,7 +218,7 @@ export class APIFootballProvider extends APIProviderBase {
                 drawn: data.away.draw,
                 lost: data.away.lose,
                 goalsFor: data.away.goals.for,
-                against: data.away.goals.against,
+                goalsAgainst: data.away.goals.against,
             } : undefined,
         };
     }
@@ -230,6 +232,8 @@ export class APIFootballProvider extends APIProviderBase {
             return 'postponed';
         if (s.includes('cancelled'))
             return 'cancelled';
+        if (s.includes('abandoned'))
+            return 'abandoned';
         return 'scheduled';
     }
     mapPosition(pos) {
@@ -276,9 +280,17 @@ export class APIFootballProvider extends APIProviderBase {
             homeGoals += isHomeTeam ? match.score.home : match.score.away;
             awayGoals += isHomeTeam ? match.score.away : match.score.home;
         }
+        // Determine teams - use first match data if available
+        const firstMatch = matches[0];
+        const homeTeamObj = firstMatch
+            ? (firstMatch.homeTeam.id === homeId ? firstMatch.homeTeam : firstMatch.awayTeam)
+            : { id: homeId, name: 'Unknown', country: '' };
+        const awayTeamObj = firstMatch
+            ? (firstMatch.homeTeam.id === awayId ? firstMatch.homeTeam : firstMatch.awayTeam)
+            : { id: awayId, name: 'Unknown', country: '' };
         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,
+            homeTeam: homeTeamObj,
+            awayTeam: awayTeamObj,
             totalMatches: matches.length,
             homeWins,
             draws,
@@ -306,23 +318,27 @@ export class APIFootballProvider extends APIProviderBase {
         // 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];
+        if (ahBet?.values?.length >= 2) {
+            const homeValue = ahBet.values.find((v) => v.value?.toLowerCase().includes('home') || v.value === 'Home');
+            const awayValue = ahBet.values.find((v) => v.value?.toLowerCase().includes('away') || v.value === 'Away');
+            const lineMatch = ahBet.values[0].value?.match(/[-+]?\d+(?:\.\d+)?/);
             result.asianHandicap = {
-                home: parseFloat(ahValue.odd) || 2.0,
-                away: parseFloat(ahValue.odd) || 2.0,
-                line: parseFloat(ahValue.value) || 0,
+                home: parseFloat(homeValue?.odd) || parseFloat(ahBet.values[0]?.odd) || 2.0,
+                away: parseFloat(awayValue?.odd) || parseFloat(ahBet.values[1]?.odd) || 2.0,
+                line: lineMatch ? parseFloat(lineMatch[0]) : 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;
+        const ouBet = bookmaker?.bets?.find((b) => b.name?.toLowerCase().includes('over/under') ||
+            b.name?.toLowerCase().includes('goals over/under'));
+        if (ouBet?.values?.length >= 2) {
+            const overValue = ouBet.values.find((v) => v.value?.toLowerCase().includes('over'));
+            const underValue = ouBet.values.find((v) => v.value?.toLowerCase().includes('under'));
+            const lineMatch = overValue?.value?.match(/\d+(?:\.\d+)?/);
             result.overUnder = {
-                line,
-                over: parseFloat(ouValue.odd) || 2.0,
-                under: parseFloat(ouValue.odd) || 2.0,
+                line: lineMatch ? parseFloat(lineMatch[0]) : 2.5,
+                over: parseFloat(overValue?.odd) || 2.0,
+                under: parseFloat(underValue?.odd) || 2.0,
             };
         }
         return result;
@@ -353,7 +369,10 @@ export class FootballDataProvider extends APIProviderBase {
         return response;
     }
     async getLiveMatches(leagueId) {
-        const response = await this.callAPI('/matches?status=IN_PLAY');
+        const endpoint = leagueId
+            ? `/competitions/${leagueId}/matches?status=IN_PLAY`
+            : '/matches?status=IN_PLAY';
+        const response = await this.callAPI(endpoint);
         if (response.success && response.data?.matches) {
             const matches = response.data.matches.map((m) => this.transformMatchFD(m));
             return { success: true, data: matches, provider: 'football-data' };
@@ -467,7 +486,7 @@ export class FootballDataProvider extends APIProviderBase {
                 drawn: data.homeGames.draw,
                 lost: data.homeGames.lost,
                 goalsFor: data.homeGames.goalsFor,
-                against: data.homeGames.goalsAgainst,
+                goalsAgainst: data.homeGames.goalsAgainst,
             } : undefined,
             awayRecord: data.awayGames ? {
                 played: data.awayGames.playedGames,
@@ -475,7 +494,7 @@ export class FootballDataProvider extends APIProviderBase {
                 drawn: data.awayGames.draw,
                 lost: data.awayGames.lost,
                 goalsFor: data.awayGames.goalsFor,
-                against: data.awayGames.goalsAgainst,
+                goalsAgainst: data.awayGames.goalsAgainst,
             } : undefined,
         };
     }
@@ -502,7 +521,71 @@ export class SportsDBProvider extends APIProviderBase {
     }
     getAuthHeaders() {
         // TheSportsDB uses API key in URL, not headers
-        return {};
+        return {
+            'Accept': 'application/json',
+        };
+    }
+    /**
+     * Override callAPI to inject API key in URL for TheSportsDB
+     */
+    async callAPI(endpoint, options = {}) {
+        // Inject API key into URL for TheSportsDB
+        const separator = endpoint.includes('?') ? '&' : '?';
+        const urlWithKey = `${this.baseUrl}${endpoint}${separator}api_key=${encodeURIComponent(this.apiKey)}`;
+        // Check rate limit
+        if (this.isRateLimited()) {
+            return {
+                success: false,
+                error: `Rate limited until ${this.rateLimitUntil}`,
+                rateLimited: true,
+            };
+        }
+        // Check availability
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                error: 'Provider not available (missing API key)',
+            };
+        }
+        try {
+            const response = await fetch(urlWithKey, {
+                ...options,
+                headers: {
+                    'Accept': 'application/json',
+                    ...options.headers,
+                },
+            });
+            this.lastCall = new Date();
+            this.callCount++;
+            if (!response.ok) {
+                if (response.status === 429) {
+                    const retryAfter = response.headers.get('Retry-After');
+                    this.rateLimitUntil = new Date(Date.now() + (retryAfter ? parseInt(retryAfter) * 1000 : 60000));
+                    return {
+                        success: false,
+                        error: 'Rate limited',
+                        rateLimited: true,
+                    };
+                }
+                return {
+                    success: false,
+                    error: `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                data: data,
+                provider: this.type,
+            };
+        }
+        catch (error) {
+            logger.error(`${this.type} API error: ${error}`);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
     }
     transformResponse(data) {
         return data;

package/dist/tools/sports/tools/betting.js

@@ -8,19 +8,6 @@ import { calculateValue, calculateKelly, calculateRecommendedStake, oddsToProbab
 import { formatOdds } from '../utils/formatter.js';
 import { BETTING } from '../core/constants.js';
 // ============= Helper Functions =============
-/**
- * Get league ID from league name
- */
-function getLeagueId(leagueName) {
-    const normalized = leagueName.toLowerCase();
-    for (const [key, value] of Object.entries({ ...BETTING })) {
-        // Skip non-league entries
-        if (typeof value !== 'object' || value === null || !('name' in value)) {
-            continue;
-        }
-    }
-    return undefined;
-}
 /**
  * Search for odds by match
  */
@@ -159,13 +146,26 @@ Shows: Fair odds, market odds, value %, confidence, Kelly stake.`, {
                 break;
             case 'fractional':
                 // Parse fractional odds like "5/2" or "5-2"
-                const oddsStr = odds.toString();
+                const oddsStr = odds.toString().trim();
                 const parts = oddsStr.split(/[-/]/);
                 if (parts.length === 2) {
-                    decimalOdds = (parseFloat(parts[0]) / parseFloat(parts[1])) + 1;
+                    const numerator = parseFloat(parts[0]);
+                    const denominator = parseFloat(parts[1]);
+                    if (!isNaN(numerator) && !isNaN(denominator) && denominator !== 0) {
+                        decimalOdds = (numerator / denominator) + 1;
+                    }
+                    else {
+                        return {
+                            content: [{ type: 'text', text: `Error: Invalid fractional odds format "${odds}". Use format like "5/2" or "3/1".` }],
+                            isError: true,
+                        };
+                    }
                 }
                 else {
-                    decimalOdds = odds;
+                    return {
+                        content: [{ type: 'text', text: `Error: Invalid fractional odds format "${odds}". Use format like "5/2" or "3/1".` }],
+                        isError: true,
+                    };
                 }
                 break;
         }

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

@@ -1,11 +1,6 @@
 /**
  * SPORTS MODULE TOOLS - League Tools
  * Tools for league standings and statistics
- *
- * This file will contain:
- * - get_league_standings
- * - get_top_scorers
- *
- * Status: Placeholder for Phase 2 implementation
  */
-export {};
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerLeagueTools(server: McpServer): void;