@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

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

@@ -0,0 +1,186 @@
+/**
+ * SPORTS MODULE SCRAPER PROVIDER
+ * Web scraping provider for sports data from various websites
+ */
+import { ScraperProviderBase } from '../core/base.js';
+import { SCRAPER_CONFIG } from '../core/constants.js';
+import { fetchWithRetry } from '../../../utils.js';
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+import TurndownService from 'turndown';
+/**
+ * Web Scraper Provider for sports data
+ */
+export class ScraperProvider extends ScraperProviderBase {
+    turndown;
+    constructor() {
+        super();
+        this.turndown = new TurndownService({
+            headingStyle: 'atx',
+            codeBlockStyle: 'fenced',
+        });
+    }
+    /**
+     * Check if a URL is from a priority domain
+     */
+    isPriorityDomain(url) {
+        return SCRAPER_CONFIG.PRIORITY_DOMAINS.some(domain => url.includes(domain));
+    }
+    /**
+     * Scrape a webpage and return structured data
+     * Overrides the base class method with a specific implementation
+     */
+    async scrape(url, extractor) {
+        try {
+            const response = await fetchWithRetry(url, {
+                headers: {
+                    'User-Agent': SCRAPER_CONFIG.USER_AGENT,
+                },
+            });
+            const html = await response.text();
+            if (extractor) {
+                const data = extractor(html);
+                return {
+                    success: true,
+                    data,
+                    provider: 'scraper',
+                };
+            }
+            // Default extraction: extract article content
+            const doc = new JSDOM(html, { url });
+            const reader = new Readability(doc.window.document);
+            const article = reader.parse();
+            if (!article) {
+                return {
+                    success: false,
+                    error: 'Could not parse article content',
+                };
+            }
+            let content = this.turndown.turndown(article.content || '');
+            // Truncate if too long
+            if (content.length > SCRAPER_CONFIG.MAX_CONTENT_LENGTH) {
+                content = content.substring(0, SCRAPER_CONFIG.MAX_CONTENT_LENGTH) + '\n...(truncated)';
+            }
+            return {
+                success: true,
+                data: `Title: ${article.title}\n\n${content}`,
+                provider: 'scraper',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Public method to scrape and get markdown content
+     */
+    async scrapeToMarkdown(url) {
+        return this.scrape(url);
+    }
+    /**
+     * Extract match data from a webpage
+     */
+    async getMatch(matchId) {
+        // For scraper, matchId should be a URL
+        return {
+            success: false,
+            error: 'Direct match scraping not implemented. Use URL-based scraping.',
+        };
+    }
+    /**
+     * Get live matches from a scoring website
+     */
+    async getLiveMatches(leagueId) {
+        // This would require scraping live score websites
+        return {
+            success: false,
+            error: 'Live score scraping not implemented. Use API providers.',
+        };
+    }
+    /**
+     * Get standings from a webpage
+     */
+    async getStandings(leagueId) {
+        return {
+            success: false,
+            error: 'Standings scraping not implemented. Use API providers.',
+        };
+    }
+    /**
+     * Get team information from a webpage
+     */
+    async getTeam(teamId) {
+        // teamId should be a URL
+        return {
+            success: false,
+            error: 'Team scraping not implemented. Use URL-based scraping.',
+        };
+    }
+    /**
+     * Get player information from a webpage
+     */
+    async getPlayer(playerId) {
+        return {
+            success: false,
+            error: 'Player scraping not implemented. Use API providers.',
+        };
+    }
+    /**
+     * Search for teams via web search
+     */
+    async searchTeams(query) {
+        return {
+            success: false,
+            error: 'Team search via scraping not implemented.',
+        };
+    }
+    /**
+     * Search for players via web search
+     */
+    async searchPlayers(query) {
+        return {
+            success: false,
+            error: 'Player search via scraping not implemented.',
+        };
+    }
+    /**
+     * Scrape a URL with timeout protection
+     */
+    async scrapeWithTimeout(url, timeout = SCRAPER_CONFIG.TIMEOUT) {
+        const scrapePromise = this.scrapeToMarkdown(url);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Scrape timeout')), timeout));
+        try {
+            return await Promise.race([scrapePromise, timeoutPromise]);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+/**
+ * Scrape match preview/article content
+ */
+export async function scrapeMatchContent(url) {
+    const scraper = new ScraperProvider();
+    return scraper.scrapeToMarkdown(url);
+}
+/**
+ * Find best URL for match data from search results
+ */
+export function findBestMatchUrl(urls) {
+    const priorityDomains = SCRAPER_CONFIG.PRIORITY_DOMAINS;
+    // Find first URL from priority domain
+    for (const url of urls) {
+        if (priorityDomains.some(domain => url.includes(domain))) {
+            return url;
+        }
+    }
+    // Return first URL if no priority match
+    return urls[0] || null;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * SPORTS MODULE SEARCH PROVIDER
+ * Abstraction layer for web search providers (Brave, Exa, Google)
+ */
+import { SearchQuery, QueryType } from '../core/types.js';
+/**
+ * Search result
+ */
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    publishedDate?: string;
+    score?: number;
+}
+/**
+ * Unified Search Provider with fallback
+ */
+export declare class SearchProvider {
+    private providers;
+    constructor();
+    /**
+     * Get available providers
+     */
+    getAvailableProviders(): string[];
+    /**
+     * Search with automatic fallback
+     */
+    search(query: string, preferredProvider?: string, count?: number): Promise<SearchResult[]>;
+    /**
+     * Perform multiple searches in parallel
+     */
+    searchMultiple(queries: SearchQuery[], count?: number): Promise<Map<QueryType, SearchResult[]>>;
+    /**
+     * Build football match search queries
+     */
+    static buildMatchQueries(homeTeam: string, awayTeam: string, league?: string, context?: string): SearchQuery[];
+    /**
+     * Extract URLs from search results
+     */
+    static extractURLs(results: SearchResult[]): string[];
+    /**
+     * Format search results as markdown
+     */
+    static formatAsMarkdown(results: SearchResult[], title: string): string;
+}
+/**
+ * Get or create the global search provider
+ */
+export declare function getSearchProvider(): SearchProvider;
+/**
+ * Reset the global search provider
+ */
+export declare function resetSearchProvider(): void;

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

@@ -0,0 +1,224 @@
+/**
+ * SPORTS MODULE SEARCH PROVIDER
+ * Abstraction layer for web search providers (Brave, Exa, Google)
+ */
+import { QUERY_TYPES } from '../core/constants.js';
+import { fetchWithRetry } from '../../../utils.js';
+import { logger } from '../../../utils.js';
+/**
+ * Brave Search Provider
+ */
+class BraveSearchProvider {
+    name = 'brave';
+    isAvailable() {
+        return !!process.env.BRAVE_API_KEY;
+    }
+    async search(query, count = 5) {
+        const response = await fetchWithRetry(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${count}`, {
+            headers: {
+                'X-Subscription-Token': process.env.BRAVE_API_KEY,
+                'Accept': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Brave API error: ${response.status}`);
+        }
+        const data = await response.json();
+        const results = data.web?.results || [];
+        return results.map((r) => ({
+            title: r.title,
+            url: r.url,
+            snippet: r.description,
+        }));
+    }
+}
+/**
+ * Exa Search Provider
+ */
+class ExaSearchProvider {
+    name = 'exa';
+    isAvailable() {
+        return !!process.env.EXA_API_KEY;
+    }
+    async search(query, count = 5) {
+        const response = await fetchWithRetry('https://api.exa.ai/search', {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.EXA_API_KEY,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ query, numResults: count }),
+        });
+        if (!response.ok) {
+            throw new Error(`Exa API error: ${response.status}`);
+        }
+        const data = await response.json();
+        const results = data.results || [];
+        return results.map((r) => ({
+            title: r.title,
+            url: r.url,
+            snippet: r.text || r.title,
+            publishedDate: r.publishedDate,
+        }));
+    }
+}
+/**
+ * Google Custom Search Provider
+ */
+class GoogleSearchProvider {
+    name = 'google';
+    isAvailable() {
+        return !!(process.env.GOOGLE_SEARCH_API_KEY && process.env.GOOGLE_SEARCH_CX);
+    }
+    async search(query, count = 5) {
+        const response = await fetchWithRetry(`https://www.googleapis.com/customsearch/v1?key=${process.env.GOOGLE_SEARCH_API_KEY}&cx=${process.env.GOOGLE_SEARCH_CX}&q=${encodeURIComponent(query)}&num=${count}`);
+        if (!response.ok) {
+            throw new Error(`Google API error: ${response.status}`);
+        }
+        const data = await response.json();
+        const items = data.items || [];
+        return items.map((item) => ({
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet,
+        }));
+    }
+}
+/**
+ * Unified Search Provider with fallback
+ */
+export class SearchProvider {
+    providers = [];
+    constructor() {
+        // Initialize available providers
+        const brave = new BraveSearchProvider();
+        if (brave.isAvailable()) {
+            this.providers.push(brave);
+            logger.info('Brave search provider initialized');
+        }
+        const exa = new ExaSearchProvider();
+        if (exa.isAvailable()) {
+            this.providers.push(exa);
+            logger.info('Exa search provider initialized');
+        }
+        const google = new GoogleSearchProvider();
+        if (google.isAvailable()) {
+            this.providers.push(google);
+            logger.info('Google search provider initialized');
+        }
+        if (this.providers.length === 0) {
+            logger.warn('No search providers available. Set BRAVE_API_KEY, EXA_API_KEY, or GOOGLE_SEARCH_API_KEY.');
+        }
+    }
+    /**
+     * Get available providers
+     */
+    getAvailableProviders() {
+        return this.providers.map(p => p.name);
+    }
+    /**
+     * Search with automatic fallback
+     */
+    async search(query, preferredProvider, count = 5) {
+        // Sort providers: preferred first, then others
+        let providers = this.providers;
+        if (preferredProvider) {
+            const preferred = this.providers.find(p => p.name === preferredProvider);
+            providers = preferred
+                ? [preferred, ...this.providers.filter(p => p.name !== preferredProvider)]
+                : this.providers;
+        }
+        const errors = [];
+        for (const provider of providers) {
+            try {
+                const results = await provider.search(query, count);
+                logger.debug(`${provider.name} search returned ${results.length} results`);
+                return results;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                errors.push(`${provider.name}: ${errorMsg}`);
+                logger.warn(`${provider.name} search failed: ${errorMsg}`);
+            }
+        }
+        throw new Error(`All search providers failed:\n${errors.join('\n')}`);
+    }
+    /**
+     * Perform multiple searches in parallel
+     */
+    async searchMultiple(queries, count = 4) {
+        const results = new Map();
+        // Sort by priority (higher first)
+        const sortedQueries = [...queries].sort((a, b) => b.priority - a.priority);
+        // Search in parallel
+        const searchPromises = sortedQueries.map(async (query) => {
+            try {
+                const searchResults = await this.search(query.query, undefined, count);
+                return { type: query.type, results: searchResults };
+            }
+            catch (error) {
+                logger.error(`Search failed for ${query.type}: ${error}`);
+                return { type: query.type, results: [] };
+            }
+        });
+        const allSearchResults = await Promise.all(searchPromises);
+        for (const { type, results: searchResults } of allSearchResults) {
+            results.set(type, searchResults);
+        }
+        return results;
+    }
+    /**
+     * Build football match search queries
+     */
+    static buildMatchQueries(homeTeam, awayTeam, league, context) {
+        const leagueStr = league ? `${league} ` : '';
+        const baseQuery = `${leagueStr}${homeTeam} vs ${awayTeam}`;
+        const today = new Date().toLocaleDateString('en-US', { month: 'long', year: 'numeric' });
+        const dateQuery = ` ${today}`;
+        return [
+            { type: QUERY_TYPES.GENERAL, query: `${baseQuery} match prediction stats${dateQuery}`, priority: 10 },
+            { type: QUERY_TYPES.H2H, query: `${baseQuery} head to head history`, priority: 8 },
+            { type: QUERY_TYPES.FORM, query: `${homeTeam} ${awayTeam} recent form last 5 matches${dateQuery}`, priority: 7 },
+            { type: 'news', query: `${baseQuery} team news injuries lineups${dateQuery}`, priority: 9 },
+            { type: QUERY_TYPES.STATS, query: `${baseQuery} xG expected goals stats${dateQuery}`, priority: 6 },
+            { type: QUERY_TYPES.ODDS, query: `${baseQuery} odds movement dropping trends${dateQuery}`, priority: 8 },
+            { type: QUERY_TYPES.FATIGUE, query: `${homeTeam} ${awayTeam} days rest fixture congestion${dateQuery}`, priority: 5 },
+            { type: QUERY_TYPES.SETPIECES, query: `${baseQuery} set pieces corners aerial duels${dateQuery}`, priority: 5 },
+        ];
+    }
+    /**
+     * Extract URLs from search results
+     */
+    static extractURLs(results) {
+        return results.map(r => r.url);
+    }
+    /**
+     * Format search results as markdown
+     */
+    static formatAsMarkdown(results, title) {
+        if (results.length === 0) {
+            return `### ${title}\nNo results found.\n`;
+        }
+        const items = results.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+        return `### ${title}\n${items}\n`;
+    }
+}
+/**
+ * Singleton search provider instance
+ */
+let globalSearchProvider = null;
+/**
+ * Get or create the global search provider
+ */
+export function getSearchProvider() {
+    if (!globalSearchProvider) {
+        globalSearchProvider = new SearchProvider();
+    }
+    return globalSearchProvider;
+}
+/**
+ * Reset the global search provider
+ */
+export function resetSearchProvider() {
+    globalSearchProvider = null;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * SPORTS MODULE TOOLS - Betting Tools
+ * Tools for betting intelligence and odds comparison
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerBettingTools(server: McpServer): void;