@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

package/dist/tools/sports/tools/match.js

@@ -0,0 +1,323 @@
+/**
+ * SPORTS MODULE TOOLS - Match Tools
+ * Tools for match analysis and live scores
+ */
+import { z } from 'zod';
+import { createAPIProvider } from '../providers/api.js';
+import { getSearchProvider } from '../providers/search.js';
+import { scrapeMatchContent, findBestMatchUrl } from '../providers/scraper.js';
+import { getGlobalCache, CacheService } from '../core/cache.js';
+import { formatMatchesTable, formatScore, formatMatchStatus } from '../utils/formatter.js';
+import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
+// ============= Helper Functions =============
+/**
+ * Get date context for search queries
+ */
+function getDateContext() {
+    const now = new Date();
+    const month = now.toLocaleDateString('en-US', { month: 'long' });
+    const year = now.getFullYear();
+    return ` ${month} ${year}`;
+}
+/**
+ * Extract team names from match analysis result
+ */
+function extractTeamNames(result) {
+    const match = result.match(/(?:home|away)[Tt]eam[:\s]+["']?([A-Za-z\s\.]+)["']?/i);
+    if (!match)
+        return null;
+    return { homeTeam: '', awayTeam: '' }; // Will be parsed from context
+}
+/**
+ * Try to find match ID from API by team names and league
+ */
+async function findMatchId(homeTeam, awayTeam, league) {
+    try {
+        const api = createAPIProvider();
+        const searchResult = await api.searchTeams(homeTeam);
+        if (searchResult.success && searchResult.data && searchResult.data.length > 0) {
+            // For now, return null - actual match ID lookup would require complex logic
+            return null;
+        }
+    }
+    catch {
+        // Ignore search errors
+    }
+    return null;
+}
+/**
+ * Perform comprehensive match analysis using web search
+ */
+async function performMatchAnalysis(homeTeam, awayTeam, league, context) {
+    const leagueStr = league ? `${league} ` : '';
+    const baseQuery = `${leagueStr}${homeTeam} vs ${awayTeam}`;
+    const dateQuery = getDateContext();
+    const searchProvider = getSearchProvider();
+    const queries = [
+        { type: 'general', query: `${baseQuery} match prediction stats${dateQuery}`, title: 'General & Prediction' },
+        { type: 'h2h', query: `${baseQuery} head to head history`, title: 'Head to Head' },
+        { type: 'form', query: `${homeTeam} ${awayTeam} recent form last 5 matches${dateQuery}`, title: 'Recent Form' },
+        { type: 'news', query: `${baseQuery} team news injuries lineups${dateQuery}`, title: 'Team News & Lineups' },
+        { type: 'stats', query: `${baseQuery} xG expected goals stats${dateQuery}`, title: 'Advanced Metrics' },
+        { type: 'odds', query: `${baseQuery} odds movement dropping odds${dateQuery}`, title: 'Market & Odds' },
+        { type: 'fatigue', query: `${homeTeam} ${awayTeam} days rest fixture congestion${dateQuery}`, title: 'Fatigue & Schedule' },
+        { type: 'setpieces', query: `${baseQuery} set pieces corners aerial duels${dateQuery}`, title: 'Set Pieces' },
+    ];
+    if (context) {
+        queries.push({ type: 'general', query: `${baseQuery} ${context}${dateQuery}`, title: 'Specific Context' });
+    }
+    let combinedResults = `--- FOOTBALL MATCH DATA: ${homeTeam} vs ${awayTeam} ---\n`;
+    combinedResults += `Match Context Date: ${new Date().toLocaleDateString()}\n\n`;
+    const candidateUrls = [];
+    // Execute searches in parallel (in small batches)
+    const batchSize = 4;
+    for (let i = 0; i < queries.length; i += batchSize) {
+        const batch = queries.slice(i, i + batchSize);
+        const batchPromises = batch.map(async (q) => {
+            try {
+                const results = await searchProvider.search(q.query, undefined, 4);
+                results.forEach(r => candidateUrls.push(r.url));
+                const items = results.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+                return `### ${q.title}\n${items}\n`;
+            }
+            catch (error) {
+                return `### ${q.title} (Failed)\nError: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
+        });
+        const batchResults = await Promise.all(batchPromises);
+        combinedResults += batchResults.join('\n');
+    }
+    // Deep dive: Scrape the best URL
+    if (candidateUrls.length > 0) {
+        const bestUrl = findBestMatchUrl(candidateUrls);
+        if (bestUrl) {
+            combinedResults += `\n--- DEEP DIVE ANALYSIS (${bestUrl}) ---\n`;
+            try {
+                const scrapedContent = await scrapeMatchContent(bestUrl);
+                if (scrapedContent.success) {
+                    combinedResults += scrapedContent.data || '';
+                }
+                else {
+                    combinedResults += `(Deep dive failed: ${scrapedContent.error})`;
+                }
+            }
+            catch (scrapeError) {
+                combinedResults += `(Deep dive failed: ${scrapeError instanceof Error ? scrapeError.message : String(scrapeError)})`;
+            }
+            combinedResults += `\n--- END DEEP DIVE ---\n`;
+        }
+    }
+    combinedResults += `\n--- END DATA ---\n\n`;
+    // Add analysis framework instructions
+    combinedResults += `INSTRUCTIONS: Act as a World-Class Football Analysis Panel. Provide a deep, non-obvious analysis using this framework:\n\n`;
+    combinedResults += `1. 📊 THE DATA SCIENTIST (Quantitative):\n   - Analyze xG trends & Possession stats.\n   - Assess Home/Away variance.\n\n`;
+    combinedResults += `2. 🧠 THE TACTICAL SCOUT (Qualitative):\n   - Stylistic Matchup (Press vs Block).\n   - Key Battles.\n\n`;
+    combinedResults += `3. 🚑 THE PHYSIO (Physical Condition):\n   - FATIGUE CHECK: Days rest? Travel distance?\n   - Squad Depth: Who has the better bench?\n\n`;
+    combinedResults += `4. 🎯 SET PIECE ANALYST:\n   - Corners/Free Kicks: Strong vs Weak?\n   - Who is most likely to score from a header?\n\n`;
+    combinedResults += `5. 💎 THE INSIDER (External Factors):\n   - Market Movements (Odds dropping?).\n   - Referee & Weather impact.\n\n`;
+    combinedResults += `6. 🕵️ THE SKEPTIC & SCENARIOS:\n   - Why might the favorite LOSE?\n   - Game Script: "If Team A scores first..."\n\n`;
+    combinedResults += `🏆 FINAL VERDICT:\n   - Asian Handicap Leans\n   - Goal Line (Over/Under)\n   - The "Value Pick"`;
+    return combinedResults;
+}
+// ============= Tool Registration =============
+export function registerMatchTools(server) {
+    /**
+     * Tool 1: analyze_football_match_v2
+     * Comprehensive football match analysis with API + Web search fallback
+     */
+    server.tool('analyze_football_match_v2', `Comprehensive football match analysis. 
+Uses API providers when available, falls back to web search.
+Gathers: Head-to-Head, Recent Form, Team News, Advanced Metrics (xG), 
+Market Intelligence, Referee stats, Weather, Fatigue analysis, Set Pieces.`, {
+        homeTeam: z.string().describe('Name of the home team'),
+        awayTeam: z.string().describe('Name of the away team'),
+        league: z.string().optional().describe('League name (optional, helps with accuracy)'),
+        context: z.string().optional().describe('Specific angle to focus on (e.g., "betting", "tactical", "injury")'),
+        useApi: z.boolean().optional().default(true).describe('Try to use direct API first if available'),
+    }, async ({ homeTeam, awayTeam, league, context, useApi }) => {
+        const errors = [];
+        let analysisResult = null;
+        // Try API providers first if requested
+        if (useApi) {
+            try {
+                const api = createAPIProvider();
+                const apiStatus = api.getStatus();
+                if (apiStatus.available) {
+                    // Could try to fetch match data from API here
+                    // For now, we'll use the search-based analysis as fallback
+                    analysisResult = await performMatchAnalysis(homeTeam, awayTeam, league, context);
+                }
+                else {
+                    errors.push('API providers not configured');
+                }
+            }
+            catch (error) {
+                errors.push(`API error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Fallback to web search analysis
+        if (!analysisResult) {
+            analysisResult = await performMatchAnalysis(homeTeam, awayTeam, league, context);
+        }
+        return {
+            content: [{ type: 'text', text: analysisResult }],
+        };
+    });
+    /**
+     * Tool 2: get_live_scores
+     * Get live football scores for a league or team
+     */
+    server.tool('get_live_scores', `Get live football scores.
+Supports filtering by league or team.
+Data cached for 1 minute.`, {
+        league: z.string().optional().describe('Filter by league name (e.g., "Premier League")'),
+        team: z.string().optional().describe('Filter by team name'),
+        limit: z.number().optional().default(20).describe('Max matches to return'),
+    }, async ({ league, team, limit }) => {
+        const cache = getGlobalCache();
+        const cacheKey = CacheService.generateKey('live_scores', league || 'all', team || 'all', limit.toString());
+        // Check cache first
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        const errors = [];
+        let matches = [];
+        // Try API providers first
+        try {
+            const api = createAPIProvider();
+            const leagueId = league ? getLeagueId(league) : undefined;
+            const result = await api.getLiveMatches(leagueId?.toString());
+            if (result.success && result.data) {
+                matches = result.data;
+                // Filter by team if specified
+                if (team) {
+                    matches = matches.filter((m) => m.homeTeam.name.toLowerCase().includes(team.toLowerCase()) ||
+                        m.awayTeam.name.toLowerCase().includes(team.toLowerCase()));
+                }
+                // Limit results
+                matches = matches.slice(0, limit);
+            }
+            else {
+                errors.push(result.error || 'Unknown API error');
+            }
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+        // If no matches from API, try web search as fallback
+        if (matches.length === 0) {
+            try {
+                const searchQuery = league
+                    ? `${league} live scores today${getDateContext()}`
+                    : `football live scores today${getDateContext()}`;
+                const searchProvider = getSearchProvider();
+                const searchResults = await searchProvider.search(searchQuery, undefined, 5);
+                // Format search results as fallback
+                const fallbackText = searchResults.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `## Live Scores (via Search)\n\n${fallbackText}\n\n*API providers not available. Click links for live scores.*`
+                        }],
+                };
+            }
+            catch (searchError) {
+                errors.push(`Search fallback failed: ${searchError instanceof Error ? searchError.message : String(searchError)}`);
+            }
+        }
+        // Format results
+        let output = `## ⚽ Live Scores`;
+        if (league)
+            output += ` - ${league}`;
+        if (team)
+            output += ` (${team})`;
+        output += `\n\n`;
+        if (matches.length > 0) {
+            output += formatMatchesTable(matches, 'Live Matches');
+        }
+        else {
+            output += 'No live matches found.\n';
+            if (errors.length > 0) {
+                output += `\nErrors: ${errors.join(', ')}`;
+            }
+        }
+        // Cache for 1 minute
+        cache.set(cacheKey, output, CACHE_CONFIG.TTL.LIVE_SCORES);
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 3: get_match_details
+     * Get detailed information about a specific match
+     */
+    server.tool('get_match_details', `Get detailed match information by ID.
+Requires API provider with match ID.`, {
+        matchId: z.string().describe('Match ID (from API)'),
+        provider: z.enum(['api-football', 'football-data', 'sports-db']).optional().describe('Preferred API provider'),
+    }, async ({ matchId, provider }) => {
+        try {
+            const api = createAPIProvider();
+            const result = await api.getMatch(matchId);
+            if (result.success && result.data) {
+                const match = result.data;
+                let output = `## Match Details\n\n`;
+                output += `**${match.homeTeam.name}** vs **${match.awayTeam.name}**\n`;
+                output += `**Competition:** ${match.league.name}\n`;
+                output += `**Date:** ${match.date.toLocaleString()}\n`;
+                output += `**Status:** ${formatMatchStatus(match.status)}\n`;
+                if (match.score) {
+                    output += `**Score:** ${formatScore(match)}\n`;
+                }
+                if (match.venue) {
+                    output += `**Venue:** ${match.venue}\n`;
+                }
+                if (match.referee) {
+                    output += `**Referee:** ${match.referee.name}\n`;
+                }
+                if (match.status === 'live' && match.minute) {
+                    output += `**Minute:** ${match.minute}'\n`;
+                }
+                return {
+                    content: [{ type: 'text', text: output }],
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${result.error || 'Failed to fetch match details'}`
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+// ============= Helper Functions =============
+/**
+ * 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;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * SPORTS MODULE TOOLS - Player Tools
+ * Tools for player analysis
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPlayerTools(server: McpServer): void;

package/dist/tools/sports/tools/player.js

@@ -0,0 +1,152 @@
+/**
+ * SPORTS MODULE TOOLS - Player Tools
+ * Tools for player analysis
+ */
+import { z } from 'zod';
+import { createAPIProvider } from '../providers/api.js';
+import { getSearchProvider } from '../providers/search.js';
+import { getGlobalCache, CacheService } from '../core/cache.js';
+import { formatPlayerStats } from '../utils/formatter.js';
+import { CACHE_CONFIG } from '../core/constants.js';
+// ============= Tool Registration =============
+export function registerPlayerTools(server) {
+    /**
+     * Tool 1: player_analysis
+     * Detailed analysis of a specific player
+     */
+    server.tool('player_analysis', `Get detailed analysis of a football player.
+Includes: stats, form, injury status, transfer value, market value.`, {
+        player: z.string().describe('Player name'),
+        include: z.array(z.enum(['stats', 'form', 'injury', 'transfer', 'market-value']))
+            .optional().default(['stats', 'form'])
+            .describe('Information to include'),
+    }, async ({ player, include }) => {
+        const cache = getGlobalCache();
+        const includeArray = include || ['stats', 'form'];
+        const cacheKey = CacheService.generateKey('player', player, includeArray.join(','));
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        let output = '';
+        const errors = [];
+        // Try API first
+        try {
+            const api = createAPIProvider();
+            const searchResult = await api.searchPlayers(player);
+            if (searchResult.success && searchResult.data && searchResult.data.length > 0) {
+                const playerData = searchResult.data[0];
+                output = `## 👤 ${playerData.name}\n\n`;
+                output += `**Age:** ${playerData.age || 'N/A'}\n`;
+                output += `**Nationality:** ${playerData.nationality}\n`;
+                output += `**Position:** ${playerData.position}\n`;
+                if (playerData.number)
+                    output += `**Shirt Number:** ${playerData.number}\n`;
+                if (playerData.team)
+                    output += `**Team:** ${playerData.team.name}\n`;
+                if (playerData.photo)
+                    output += `**Photo:** ${playerData.photo}\n`;
+                if (includeArray.includes('stats') && playerData.stats) {
+                    output += `\n### Season Statistics\n`;
+                    output += formatPlayerStats(playerData.stats, playerData.name);
+                }
+                // Cache for 1 hour
+                cache.set(cacheKey, output, CACHE_CONFIG.TTL.PLAYER_STATS);
+            }
+            else {
+                errors.push('Player not found via API');
+            }
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+        // Fallback to web search
+        if (!output) {
+            try {
+                const searchQuery = `${player} football player stats profile`;
+                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 = `## 👤 ${player}\n\n`;
+                output += `*API data not available. Click links for player info:*\n\n${fallbackText}`;
+            }
+            catch (searchError) {
+                output = `Error: ${errors.join(', ')}`;
+            }
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 2: tactical_breakdown
+     * Analyze tactical matchups between teams
+     */
+    server.tool('tactical_breakdown', `Analyze tactical matchups between two teams.
+Includes: formations, playing styles, key battles, strengths/weaknesses.`, {
+        homeTeam: z.string().describe('Home team name'),
+        awayTeam: z.string().describe('Away team name'),
+        focus: z.enum(['formation', 'pressing', 'set-pieces', 'all']).optional().default('all')
+            .describe('Tactical focus area'),
+    }, async ({ homeTeam, awayTeam, focus }) => {
+        const searchQuery = `${homeTeam} ${awayTeam} tactical analysis formation pressing`;
+        let output = `## 🧠 Tactical Breakdown: ${homeTeam} vs ${awayTeam}\n\n`;
+        try {
+            const searchProvider = getSearchProvider();
+            const searchResults = await searchProvider.search(searchQuery, undefined, 5);
+            output += `### Tactical Analysis Sources\n\n`;
+            const items = searchResults.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+            output += items;
+            output += `\n\n### Key Tactical Areas\n\n`;
+            output += `| Area | Home Team | Away Team |\n`;
+            output += `|------|-----------|----------|\n`;
+            output += `| Formation | Analyzing... | Analyzing... |\n`;
+            output += `| Playing Style | Analyzing... | Analyzing... |\n`;
+            output += `| Pressing | Analyzing... | Analyzing... |\n`;
+            output += `| Set Pieces | Analyzing... | Analyzing... |\n`;
+            output += `\n*Note: Full tactical analysis requires detailed match data API.*`;
+        }
+        catch (error) {
+            output += `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 3: referee_profile
+     * Get referee statistics and tendencies
+     */
+    server.tool('referee_profile', `Get referee statistics and tendencies.
+Includes: cards per game, home/away bias, penalties awarded.`, {
+        referee: z.string().describe('Referee name'),
+        league: z.string().optional().describe('Filter by league'),
+    }, async ({ referee, league }) => {
+        const searchQuery = `${referee} referee stats cards per game${league ? ` ${league}` : ''}`;
+        let output = `## 🎨 Referee Profile: ${referee}\n\n`;
+        try {
+            const searchProvider = getSearchProvider();
+            const searchResults = await searchProvider.search(searchQuery, undefined, 3);
+            output += `### Statistics\n\n`;
+            output += `| Statistic | Value |\n`;
+            output += `|-----------|-------|\n`;
+            output += `| Yellow Cards/Game | Searching... |\n`;
+            output += `| Red Cards/Game | Searching... |\n`;
+            output += `| Penalties/Game | Searching... |\n`;
+            output += `| Home Win Rate | Searching... |\n`;
+            output += `| Away Win Rate | Searching... |\n`;
+            output += `\n### Data Sources\n\n`;
+            const items = searchResults.map(r => `- [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+            output += items;
+            output += `\n\n*Note: Detailed referee statistics require dedicated API integration.*`;
+        }
+        catch (error) {
+            output += `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+}

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

@@ -0,0 +1,6 @@
+/**
+ * SPORTS MODULE TOOLS - Team Tools
+ * Tools for team analysis, comparison, and league standings
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTeamTools(server: McpServer): void;