@gotza02/sequential-thinking 10000.2.0 → 10000.2.2

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;

package/dist/tools/sports/tools/league.js

@@ -1,12 +1,202 @@
 /**
  * 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 {};
-// Placeholder - Tools will be implemented in Phase 2
+import { z } from 'zod';
+import { createAPIProvider } from '../providers/api.js';
+import { getSearchProvider } from '../providers/search.js';
+import { getGlobalCache, CacheService } from '../core/cache.js';
+import { formatStandingsTable } from '../utils/formatter.js';
+import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
+/**
+ * Get league ID from league name
+ */
+function getLeagueId(leagueName) {
+    const normalized = leagueName.toLowerCase();
+    for (const [key, value] of Object.entries(LEAGUES)) {
+        if (value.name.toLowerCase().includes(normalized) ||
+            normalized.includes(value.name.toLowerCase()) ||
+            value.code?.toLowerCase() === normalized.replace(' ', '')) {
+            return value.id;
+        }
+    }
+    // Try exact match
+    for (const [key, value] of Object.entries(LEAGUES)) {
+        if (value.name.toLowerCase() === normalized) {
+            return value.id;
+        }
+    }
+    return undefined;
+}
+// ============= Tool Registration =============
+export function registerLeagueTools(server) {
+    /**
+     * Tool 1: get_league_standings
+     * Get current league standings table
+     */
+    server.tool('get_league_standings_v2', `Get current league standings table.
+Includes: position, played, won, drawn, lost, goals for/against, goal difference, points.
+Supports home/away splits.`, {
+        league: z.string().describe('League name (e.g., "Premier League", "La Liga")'),
+        season: z.string().optional().describe('Season year (default: current)'),
+    }, async ({ league, season }) => {
+        const cache = getGlobalCache();
+        const currentYear = new Date().getFullYear();
+        const seasonYear = season || currentYear.toString();
+        const cacheKey = CacheService.generateKey('standings', league, seasonYear);
+        // Check cache first (30min TTL)
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        const leagueId = getLeagueId(league);
+        let output = '';
+        const errors = [];
+        if (!leagueId) {
+            errors.push(`League "${league}" not found. Available leagues: ${Object.values(LEAGUES).map(l => l.name).join(', ')}`);
+        }
+        if (leagueId) {
+            try {
+                const api = createAPIProvider();
+                const result = await api.getStandings(leagueId.toString(), seasonYear);
+                if (result.success && result.data) {
+                    output = `## 🏆 ${league} - Standings ${seasonYear}\n\n`;
+                    output += formatStandingsTable(result.data);
+                    // Cache for 30 minutes
+                    cache.set(cacheKey, output, CACHE_CONFIG.TTL.STANDINGS);
+                }
+                else {
+                    errors.push(result.error || 'Unknown API error');
+                }
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        // Fallback to web search if API failed
+        if (!output && errors.length > 0) {
+            try {
+                const searchQuery = `${league} standings table ${seasonYear}`;
+                const searchProvider = getSearchProvider();
+                const searchResults = await searchProvider.search(searchQuery, undefined, 3);
+                const fallbackText = searchResults.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+                output = `## ${league} - Standings ${seasonYear}\n\n`;
+                output += `*API providers not available. Click links for standings:*\n\n${fallbackText}`;
+            }
+            catch (searchError) {
+                output = `Error: ${errors.join(', ')}`;
+            }
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 2: get_top_scorers
+     * Get top scorers for a league
+     */
+    server.tool('get_top_scorers_v2', `Get top scorers for a league.`, {
+        league: z.string().describe('League name'),
+        limit: z.number().optional().default(20).describe('Number of players to return'),
+        season: z.string().optional().describe('Season year (default: current)'),
+    }, async ({ league, limit, season }) => {
+        const cache = getGlobalCache();
+        const currentYear = new Date().getFullYear();
+        const seasonYear = season || currentYear.toString();
+        const cacheKey = CacheService.generateKey('scorers', league, seasonYear, limit.toString());
+        // Check cache first
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        const leagueId = getLeagueId(league);
+        let output = '';
+        const errors = [];
+        if (!leagueId) {
+            errors.push(`League "${league}" not found`);
+        }
+        // Try API first
+        if (leagueId) {
+            try {
+                const api = createAPIProvider();
+                const searchQuery = `${league} top scorers ${seasonYear}`;
+                const searchProvider = getSearchProvider();
+                const searchResults = await searchProvider.search(searchQuery, undefined, limit);
+                output = `## 🥇 ${league} - Top Scorers ${seasonYear}\n\n`;
+                if (searchResults.length > 0) {
+                    const items = searchResults.map((r, i) => `${i + 1}. [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+                    output += items;
+                }
+                else {
+                    output += 'No results found.';
+                }
+                // Cache the results
+                cache.set(cacheKey, output, CACHE_CONFIG.TTL.TEAM_STATS);
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        // Fallback
+        if (!output) {
+            try {
+                const searchQuery = `${league} top scorers ${seasonYear}`;
+                const searchProvider = getSearchProvider();
+                const searchResults = await searchProvider.search(searchQuery, undefined, limit);
+                output = `## 🥇 ${league} - Top Scorers ${seasonYear}\n\n`;
+                output += searchResults.map((r, i) => `${i + 1}. [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+            }
+            catch (error) {
+                output = `Error: ${errors.join(', ')}`;
+            }
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 3: get_league_fixtures
+     * Get upcoming fixtures for a league
+     */
+    server.tool('get_league_fixtures', `Get upcoming fixtures for a league.`, {
+        league: z.string().describe('League name'),
+        days: z.number().optional().default(7).describe('Number of days ahead'),
+    }, async ({ league, days }) => {
+        const cache = getGlobalCache();
+        const cacheKey = CacheService.generateKey('fixtures', league, days.toString());
+        // Check cache first
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        const leagueId = getLeagueId(league);
+        let output = '';
+        try {
+            const searchQuery = `${league} fixtures schedule next ${days} days`;
+            const searchProvider = getSearchProvider();
+            const searchResults = await searchProvider.search(searchQuery, undefined, 10);
+            output = `## 📅 ${league} - Upcoming Fixtures\n\n`;
+            if (searchResults.length > 0) {
+                const items = searchResults.map((r, i) => `${i + 1}. [${r.title}](${r.url}): ${r.snippet}`).join('\n\n');
+                output += items;
+            }
+            else {
+                output += 'No fixtures found.';
+            }
+            // Cache for short period
+            cache.set(cacheKey, output, 15 * 60 * 1000); // 15 minutes
+        }
+        catch (error) {
+            output = `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+}