@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

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

@@ -0,0 +1,517 @@
+/**
+ * SPORTS MODULE API PROVIDERS
+ * Concrete implementations of football API providers
+ */
+import { APIProviderBase, FallbackProvider } from '../core/base.js';
+import { API_CONFIG } from '../core/constants.js';
+import { logger } from '../../../utils.js';
+/**
+ * API-Football Provider (via RapidAPI)
+ * Documentation: https://rapidapi.com/api-sports/api/api-football
+ */
+export class APIFootballProvider extends APIProviderBase {
+    constructor() {
+        super('api-football', API_CONFIG.API_FOOTBALL_KEY, API_CONFIG.API_FOOTBALL_BASE, API_CONFIG.RATE_LIMITS.API_FOOTBALL);
+    }
+    getAuthHeaders() {
+        return {
+            'x-rapidapi-key': this.apiKey,
+            'x-rapidapi-host': API_CONFIG.API_FOOTBALL_HOST,
+        };
+    }
+    transformResponse(data) {
+        return data;
+    }
+    async getMatch(matchId) {
+        const cacheKey = `match:api-football:${matchId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        const response = await this.callAPI(`/fixtures?id=${matchId}`);
+        if (response.success && response.data?.response?.[0]) {
+            const match = this.transformMatch(response.data.response[0]);
+            this.cache.set(cacheKey, match);
+            return { success: true, data: match, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getLiveMatches(leagueId) {
+        const endpoint = leagueId
+            ? `/fixtures?live=all&league=${leagueId}`
+            : '/fixtures?live=all';
+        const response = await this.callAPI(endpoint);
+        if (response.success && response.data?.response) {
+            const matches = response.data.response.map((m) => this.transformMatch(m));
+            return { success: true, data: matches, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getStandings(leagueId, season) {
+        const currentYear = new Date().getFullYear();
+        const seasonYear = season || currentYear;
+        const response = await this.callAPI(`/standings?league=${leagueId}&season=${seasonYear}`);
+        if (response.success && response.data?.response?.[0]?.league?.standings?.[0]) {
+            const standings = response.data.response[0].league.standings[0].map((s) => this.transformTableEntry(s));
+            return { success: true, data: standings, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getTeam(teamId) {
+        const response = await this.callAPI(`/teams?id=${teamId}`);
+        if (response.success && response.data?.response?.[0]) {
+            const team = this.transformTeam(response.data.response[0]);
+            return { success: true, data: team, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getPlayer(playerId) {
+        const response = await this.callAPI(`/players?id=${playerId}&season=2024`);
+        if (response.success && response.data?.response?.[0]) {
+            const player = this.transformPlayer(response.data.response[0]);
+            return { success: true, data: player, provider: 'api-football' };
+        }
+        return response;
+    }
+    async searchTeams(query) {
+        const response = await this.callAPI(`/teams?search=${encodeURIComponent(query)}`);
+        if (response.success && response.data?.response) {
+            const teams = response.data.response.map((t) => this.transformTeam(t));
+            return { success: true, data: teams, provider: 'api-football' };
+        }
+        return response;
+    }
+    async searchPlayers(query) {
+        const response = await this.callAPI(`/players?search=${encodeURIComponent(query)}&season=2024`);
+        if (response.success && response.data?.response) {
+            const players = response.data.response.map((p) => this.transformPlayer(p));
+            return { success: true, data: players, provider: 'api-football' };
+        }
+        return response;
+    }
+    // ============= Transformation Helpers =============
+    transformMatch(data) {
+        return {
+            id: data.fixture.id.toString(),
+            homeTeam: this.transformTeam(data.teams.home),
+            awayTeam: this.transformTeam(data.teams.away),
+            league: {
+                id: data.league.id.toString(),
+                name: data.league.name,
+                country: data.league.country,
+                season: data.league.season.toString(),
+            },
+            date: new Date(data.fixture.date),
+            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,
+                } : undefined,
+            } : undefined,
+            minute: data.fixture.status?.elapsed,
+        };
+    }
+    transformTeam(data) {
+        return {
+            id: data.team?.id?.toString() || data.id?.toString() || '',
+            name: data.team?.name || data.name || '',
+            code: data.team?.code || data.code,
+            country: data.team?.country || data.country || '',
+            logo: data.team?.logo || data.logo,
+            founded: data.team?.founded || data.founded,
+            venue: data.venue?.name,
+        };
+    }
+    transformPlayer(data) {
+        return {
+            id: data.player?.id?.toString() || data.id?.toString() || '',
+            name: data.player?.name || data.name || '',
+            age: data.player?.age || data.age,
+            nationality: data.player?.nationality || data.nationality || '',
+            position: this.mapPosition(data.player?.position || data.statistics?.[0]?.games?.position),
+            number: data.player?.number || data.statistics?.[0]?.games?.number,
+            photo: data.player?.photo,
+            team: data.statistics?.[0]?.team ? this.transformTeam({ team: data.statistics[0].team }) : undefined,
+        };
+    }
+    transformTableEntry(data) {
+        return {
+            position: data.rank,
+            team: this.transformTeam(data.team),
+            played: data.all.played,
+            won: data.all.win,
+            drawn: data.all.draw,
+            lost: data.all.lose,
+            goalsFor: data.all.goals.for,
+            goalsAgainst: data.all.goals.against,
+            goalDifference: data.goalsDiff,
+            points: data.points,
+            form: data.form ? (data.form.split('').map((c) => c)) : undefined,
+            homeRecord: data.home ? {
+                played: data.home.played,
+                won: data.home.win,
+                drawn: data.home.draw,
+                lost: data.home.lose,
+                goalsFor: data.home.goals.for,
+                against: data.home.goals.against,
+            } : undefined,
+            awayRecord: data.away ? {
+                played: data.away.played,
+                won: data.away.win,
+                drawn: data.away.draw,
+                lost: data.away.lose,
+                goalsFor: data.away.goals.for,
+                against: data.away.goals.against,
+            } : undefined,
+        };
+    }
+    mapStatus(status) {
+        const s = status.toLowerCase();
+        if (s.includes('live') || s.includes('half'))
+            return 'live';
+        if (s.includes('finished') || s.includes('complete'))
+            return 'finished';
+        if (s.includes('postponed'))
+            return 'postponed';
+        if (s.includes('cancelled'))
+            return 'cancelled';
+        return 'scheduled';
+    }
+    mapPosition(pos) {
+        if (!pos)
+            return 'SUB';
+        const p = pos.toLowerCase();
+        if (p.includes('goalkeeper') || p === 'gk')
+            return 'GK';
+        if (p.includes('defender') || p === 'df')
+            return 'DF';
+        if (p.includes('midfielder') || p === 'mf')
+            return 'MF';
+        if (p.includes('forward') || p === 'fw')
+            return 'FW';
+        return 'SUB';
+    }
+}
+/**
+ * Football-Data.org Provider
+ * Documentation: https://www.football-data.org/
+ */
+export class FootballDataProvider extends APIProviderBase {
+    constructor() {
+        super('football-data', API_CONFIG.FOOTBALL_DATA_KEY, API_CONFIG.FOOTBALL_DATA_BASE, API_CONFIG.RATE_LIMITS.FOOTBALL_DATA);
+    }
+    getAuthHeaders() {
+        return {
+            'X-Auth-Token': this.apiKey,
+        };
+    }
+    transformResponse(data) {
+        return data;
+    }
+    async getMatch(matchId) {
+        const response = await this.callAPI(`/matches/${matchId}`);
+        if (response.success && response.data?.match) {
+            const match = this.transformMatchFD(response.data.match);
+            return { success: true, data: match, provider: 'football-data' };
+        }
+        return response;
+    }
+    async getLiveMatches(leagueId) {
+        const response = await this.callAPI('/matches?status=IN_PLAY');
+        if (response.success && response.data?.matches) {
+            const matches = response.data.matches.map((m) => this.transformMatchFD(m));
+            return { success: true, data: matches, provider: 'football-data' };
+        }
+        return response;
+    }
+    async getStandings(leagueId, season) {
+        const response = await this.callAPI(`/competitions/${leagueId}/standings`);
+        if (response.success && response.data?.standings?.[0]?.table) {
+            const standings = response.data.standings[0].table.map((t) => this.transformTableEntryFD(t));
+            return { success: true, data: standings, provider: 'football-data' };
+        }
+        return response;
+    }
+    async getTeam(teamId) {
+        const response = await this.callAPI(`/teams/${teamId}`);
+        if (response.success && response.data) {
+            const team = this.transformTeamFD(response.data);
+            return { success: true, data: team, provider: 'football-data' };
+        }
+        return response;
+    }
+    async getPlayer(playerId) {
+        // Football-Data.org has limited player data
+        return {
+            success: false,
+            error: 'Player data not available via Football-Data.org',
+        };
+    }
+    async searchTeams(query) {
+        // Football-Data.org doesn't have search endpoint
+        return {
+            success: false,
+            error: 'Search not available via Football-Data.org',
+        };
+    }
+    async searchPlayers(query) {
+        return {
+            success: false,
+            error: 'Search not available via Football-Data.org',
+        };
+    }
+    // ============= Transformation Helpers (Football-Data.org format) =============
+    transformMatchFD(data) {
+        return {
+            id: data.id.toString(),
+            homeTeam: this.transformTeamFD(data.homeTeam),
+            awayTeam: this.transformTeamFD(data.awayTeam),
+            league: {
+                id: data.competition.id.toString(),
+                name: data.competition.name,
+                country: data.competition.area?.name || 'Europe',
+            },
+            date: new Date(data.utcDate),
+            status: this.mapStatusFD(data.status),
+            score: data.score ? {
+                home: data.score.fullTime.homeTeam || 0,
+                away: data.score.fullTime.awayTeam || 0,
+                halfTime: data.score.halfTime.homeTeam !== null ? {
+                    home: data.score.halfTime.homeTeam,
+                    away: data.score.halfTime.awayTeam,
+                } : undefined,
+            } : undefined,
+        };
+    }
+    transformTeamFD(data) {
+        return {
+            id: data.id.toString(),
+            name: data.name || data.shortName,
+            code: data.tla,
+            country: data.area?.name || '',
+            logo: data.crest,
+            founded: data.founded,
+            venue: data.venue,
+        };
+    }
+    transformTableEntryFD(data) {
+        return {
+            position: data.position,
+            team: this.transformTeamFD(data.team),
+            played: data.playedGames,
+            won: data.won,
+            drawn: data.draw,
+            lost: data.lost,
+            goalsFor: data.goalsFor,
+            goalsAgainst: data.goalsAgainst,
+            goalDifference: data.goalDifference,
+            points: data.points,
+            homeRecord: data.homeGames ? {
+                played: data.homeGames.playedGames,
+                won: data.homeGames.won,
+                drawn: data.homeGames.draw,
+                lost: data.homeGames.lost,
+                goalsFor: data.homeGames.goalsFor,
+                against: data.homeGames.goalsAgainst,
+            } : undefined,
+            awayRecord: data.awayGames ? {
+                played: data.awayGames.playedGames,
+                won: data.awayGames.won,
+                drawn: data.awayGames.draw,
+                lost: data.awayGames.lost,
+                goalsFor: data.awayGames.goalsFor,
+                against: data.awayGames.goalsAgainst,
+            } : undefined,
+        };
+    }
+    mapStatusFD(status) {
+        const s = status.toUpperCase();
+        if (s === 'IN_PLAY' || s === 'PAUSED')
+            return 'live';
+        if (s === 'FINISHED')
+            return 'finished';
+        if (s === 'POSTPONED')
+            return 'postponed';
+        if (s === 'CANCELLED')
+            return 'cancelled';
+        return 'scheduled';
+    }
+}
+/**
+ * TheSportsDB Provider
+ * Documentation: https://www.thesportsdb.com/api.php
+ */
+export class SportsDBProvider extends APIProviderBase {
+    constructor() {
+        super('sports-db', API_CONFIG.SPORTS_DB_KEY, API_CONFIG.SPORTS_DB_BASE, API_CONFIG.RATE_LIMITS.SPORTS_DB);
+    }
+    getAuthHeaders() {
+        // TheSportsDB uses API key in URL, not headers
+        return {};
+    }
+    transformResponse(data) {
+        return data;
+    }
+    async getMatch(matchId) {
+        const url = `/lookupfixture.php?id=${matchId}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data?.[0]) {
+            const match = this.transformMatchDB(response.data[0]);
+            return { success: true, data: match, provider: 'sports-db' };
+        }
+        return response;
+    }
+    async getLiveMatches() {
+        // TheSportsDB doesn't have a good live scores endpoint
+        return {
+            success: false,
+            error: 'Live scores not available via TheSportsDB',
+        };
+    }
+    async getStandings(leagueId) {
+        const url = `/lookuptable.php?l=${leagueId}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data) {
+            const standings = response.data.map((t) => this.transformTableEntryDB(t));
+            return { success: true, data: standings, provider: 'sports-db' };
+        }
+        return response;
+    }
+    async getTeam(teamId) {
+        const url = `/lookupteam.php?id=${teamId}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data?.[0]) {
+            const team = this.transformTeamDB(response.data[0]);
+            return { success: true, data: team, provider: 'sports-db' };
+        }
+        return response;
+    }
+    async getPlayer(playerId) {
+        const url = `/lookupplayer.php?id=${playerId}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data?.[0]) {
+            const player = this.transformPlayerDB(response.data[0]);
+            return { success: true, data: player, provider: 'sports-db' };
+        }
+        return response;
+    }
+    async searchTeams(query) {
+        const url = `/searchteams.php?t=${encodeURIComponent(query)}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data) {
+            const teams = response.data.map((t) => this.transformTeamDB(t));
+            return { success: true, data: teams, provider: 'sports-db' };
+        }
+        return response;
+    }
+    async searchPlayers(query) {
+        const url = `/searchplayers.php?p=${encodeURIComponent(query)}`;
+        const response = await this.callAPI(url);
+        if (response.success && response.data) {
+            const players = response.data.map((p) => this.transformPlayerDB(p));
+            return { success: true, data: players, provider: 'sports-db' };
+        }
+        return response;
+    }
+    // ============= Transformation Helpers (TheSportsDB format) =============
+    transformMatchDB(data) {
+        return {
+            id: data.idEvent,
+            homeTeam: this.transformTeamDB({ idTeam: data.idHomeTeam, strTeam: data.strHomeTeam }),
+            awayTeam: this.transformTeamDB({ idTeam: data.idAwayTeam, strTeam: data.strAwayTeam }),
+            league: {
+                id: data.idLeague,
+                name: data.strLeague,
+                country: data.strCountry || '',
+            },
+            date: new Date(data.dateEvent + 'T' + data.strTime),
+            status: data.strStatus === 'Match Finished' ? 'finished' : 'scheduled',
+            score: {
+                home: parseInt(data.intHomeScore) || 0,
+                away: parseInt(data.intAwayScore) || 0,
+            },
+        };
+    }
+    transformTeamDB(data) {
+        return {
+            id: data.idTeam?.toString() || '',
+            name: data.strTeam || '',
+            code: data.strTeamShort,
+            country: data.strCountry || '',
+            logo: data.strTeamBadge,
+            founded: data.intFormedYear ? parseInt(data.intFormedYear) : undefined,
+            venue: data.strStadium,
+        };
+    }
+    transformPlayerDB(data) {
+        return {
+            id: data.idPlayer?.toString() || '',
+            name: data.strPlayer || '',
+            age: data.dateBorn
+                ? new Date().getFullYear() - new Date(data.dateBorn).getFullYear()
+                : undefined,
+            nationality: data.strNationality || '',
+            position: this.mapPositionDB(data.strPosition),
+            photo: data.strCutout,
+            team: data.strTeam
+                ? this.transformTeamDB({ strTeam: data.strTeam })
+                : undefined,
+        };
+    }
+    transformTableEntryDB(data) {
+        return {
+            position: parseInt(data.intRank),
+            team: this.transformTeamDB(data),
+            played: parseInt(data.intPlayed),
+            won: parseInt(data.intWin),
+            drawn: parseInt(data.intDraw),
+            lost: parseInt(data.intLoss),
+            goalsFor: parseInt(data.intGoalsFor),
+            goalsAgainst: parseInt(data.intGoalsAgainst),
+            goalDifference: parseInt(data.intGoalDifference),
+            points: parseInt(data.intPoints),
+        };
+    }
+    mapPositionDB(pos) {
+        if (!pos)
+            return 'SUB';
+        const p = pos.toLowerCase();
+        if (p.includes('goalkeeper') || p === 'gk')
+            return 'GK';
+        if (p.includes('defender') || p === 'df')
+            return 'DF';
+        if (p.includes('midfielder') || p === 'mf')
+            return 'MF';
+        if (p.includes('forward') || p === 'fw')
+            return 'FW';
+        return 'SUB';
+    }
+}
+/**
+ * Create a fallback provider with all available API providers
+ */
+export function createAPIProvider() {
+    const providers = [];
+    // Add API-Football if key is available
+    if (API_CONFIG.API_FOOTBALL_KEY) {
+        providers.push(new APIFootballProvider());
+        logger.info('API-Football provider initialized');
+    }
+    // Add Football-Data.org if key is available
+    if (API_CONFIG.FOOTBALL_DATA_KEY) {
+        providers.push(new FootballDataProvider());
+        logger.info('Football-Data.org provider initialized');
+    }
+    // Add TheSportsDB if key is available
+    if (API_CONFIG.SPORTS_DB_KEY) {
+        providers.push(new SportsDBProvider());
+        logger.info('TheSportsDB provider initialized');
+    }
+    if (providers.length === 0) {
+        logger.warn('No API providers configured. Set API_FOOTBALL_KEY, FOOTBALL_DATA_KEY, or SPORTS_DB_KEY environment variables.');
+    }
+    return new FallbackProvider(providers);
+}

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

@@ -0,0 +1,66 @@
+/**
+ * SPORTS MODULE SCRAPER PROVIDER
+ * Web scraping provider for sports data from various websites
+ */
+import { Match, Team, Player, TableEntry, APIResponse } from '../core/types.js';
+import { ScraperProviderBase } from '../core/base.js';
+/**
+ * Web Scraper Provider for sports data
+ */
+export declare class ScraperProvider extends ScraperProviderBase {
+    private turndown;
+    constructor();
+    /**
+     * Check if a URL is from a priority domain
+     */
+    isPriorityDomain(url: string): boolean;
+    /**
+     * Scrape a webpage and return structured data
+     * Overrides the base class method with a specific implementation
+     */
+    protected scrape<T>(url: string, extractor?: (html: string) => T): Promise<APIResponse<T>>;
+    /**
+     * Public method to scrape and get markdown content
+     */
+    scrapeToMarkdown(url: string): Promise<APIResponse<string>>;
+    /**
+     * Extract match data from a webpage
+     */
+    getMatch(matchId: string): Promise<APIResponse<Match>>;
+    /**
+     * Get live matches from a scoring website
+     */
+    getLiveMatches(leagueId?: string): Promise<APIResponse<Match[]>>;
+    /**
+     * Get standings from a webpage
+     */
+    getStandings(leagueId: string): Promise<APIResponse<TableEntry[]>>;
+    /**
+     * Get team information from a webpage
+     */
+    getTeam(teamId: string): Promise<APIResponse<Team>>;
+    /**
+     * Get player information from a webpage
+     */
+    getPlayer(playerId: string): Promise<APIResponse<Player>>;
+    /**
+     * Search for teams via web search
+     */
+    searchTeams(query: string): Promise<APIResponse<Team[]>>;
+    /**
+     * Search for players via web search
+     */
+    searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Scrape a URL with timeout protection
+     */
+    scrapeWithTimeout(url: string, timeout?: number): Promise<APIResponse<string>>;
+}
+/**
+ * Scrape match preview/article content
+ */
+export declare function scrapeMatchContent(url: string): Promise<APIResponse<string>>;
+/**
+ * Find best URL for match data from search results
+ */
+export declare function findBestMatchUrl(urls: string[]): string | null;