@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

package/dist/tools/sports/tools/team.js

@@ -0,0 +1,370 @@
+/**
+ * SPORTS MODULE TOOLS - Team Tools
+ * Tools for team analysis, comparison, and league standings
+ */
+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, formatComparisonResult } from '../utils/formatter.js';
+import { CACHE_CONFIG, LEAGUES } 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(LEAGUES)) {
+        if (value.name.toLowerCase().includes(normalized) ||
+            normalized.includes(value.name.toLowerCase()) ||
+            value.code?.toLowerCase() === normalized.replace(' ', '')) {
+            return value.id;
+        }
+    }
+    // Try direct name match
+    for (const [key, value] of Object.entries(LEAGUES)) {
+        if (value.name.toLowerCase() === normalized) {
+            return value.id;
+        }
+    }
+    return undefined;
+}
+/**
+ * Search for team by name using web search
+ */
+async function searchTeamByName(teamName) {
+    try {
+        const searchProvider = getSearchProvider();
+        const results = await searchProvider.search(`${teamName} football team stats`, undefined, 3);
+        if (results.length > 0) {
+            // Return a basic team object from search results
+            return {
+                id: `search_${Date.now()}`,
+                name: teamName,
+                country: 'Unknown',
+                stats: {
+                    matchesPlayed: 0,
+                    wins: 0,
+                    draws: 0,
+                    losses: 0,
+                    goalsFor: 0,
+                    goalsAgainst: 0,
+                    goalDifference: 0,
+                },
+            };
+        }
+    }
+    catch {
+        // Ignore search errors
+    }
+    return null;
+}
+/**
+ * Compare two teams and generate analysis
+ */
+async function compareTeamsAnalysis(teamAName, teamBName) {
+    const metrics = [];
+    const errors = [];
+    try {
+        const api = createAPIProvider();
+        // Try to get team data from API
+        const [teamAResult, teamBResult] = await Promise.all([
+            api.searchTeams(teamAName),
+            api.searchTeams(teamBName),
+        ]);
+        const teamA = teamAResult.success && teamAResult.data && teamAResult.data.length > 0
+            ? teamAResult.data[0]
+            : { id: 'a', name: teamAName, country: '', stats: undefined };
+        const teamB = teamBResult.success && teamBResult.data && teamBResult.data.length > 0
+            ? teamBResult.data[0]
+            : { id: 'b', name: teamBName, country: '', stats: undefined };
+        // Generate comparison metrics
+        // Note: These would be populated with real API data
+        metrics.push({
+            name: 'Team Name',
+            teamAValue: teamA.name,
+            teamBValue: teamB.name,
+            importance: 'low',
+        });
+        if (teamA.stats && teamB.stats) {
+            metrics.push({
+                name: 'League Position',
+                teamAValue: teamA.stats.position || 'N/A',
+                teamBValue: teamB.stats.position || 'N/A',
+                winner: teamA.stats.position && teamB.stats.position
+                    ? teamA.stats.position < teamB.stats.position ? 'A' : teamA.stats.position > teamB.stats.position ? 'B' : 'draw'
+                    : undefined,
+                importance: 'high',
+            });
+            metrics.push({
+                name: 'Form (Last 5)',
+                teamAValue: teamA.stats.form
+                    ? Array.isArray(teamA.stats.form)
+                        ? teamA.stats.form.join('')
+                        : teamA.stats.form
+                    : 'N/A',
+                teamBValue: teamB.stats.form
+                    ? Array.isArray(teamB.stats.form)
+                        ? teamB.stats.form.join('')
+                        : teamB.stats.form
+                    : 'N/A',
+                importance: 'medium',
+            });
+            metrics.push({
+                name: 'Goals Per Game',
+                teamAValue: teamA.stats.matchesPlayed > 0
+                    ? (teamA.stats.goalsFor / teamA.stats.matchesPlayed).toFixed(2)
+                    : 'N/A',
+                teamBValue: teamB.stats.matchesPlayed > 0
+                    ? (teamB.stats.goalsFor / teamB.stats.matchesPlayed).toFixed(2)
+                    : 'N/A',
+                winner: teamA.stats.matchesPlayed > 0 && teamB.stats.matchesPlayed > 0
+                    ? (teamA.stats.goalsFor / teamA.stats.matchesPlayed) > (teamB.stats.goalsFor / teamB.stats.matchesPlayed) ? 'A' : 'B'
+                    : undefined,
+                importance: 'high',
+            });
+        }
+        // Generate summary
+        let summary = `Comparison between **${teamA.name}** and **${teamB.name}**.\n\n`;
+        if (teamA.stats && teamB.stats) {
+            const aPoints = teamA.stats.points || 0;
+            const bPoints = teamB.stats.points || 0;
+            if (aPoints > bPoints + 10) {
+                summary += `${teamA.name} has a significantly better league position. `;
+            }
+            else if (bPoints > aPoints + 10) {
+                summary += `${teamB.name} has a significantly better league position. `;
+            }
+            else {
+                summary += `The teams are relatively evenly matched in terms of league standing. `;
+            }
+        }
+        else {
+            summary += `Detailed statistics not available via API. `;
+        }
+        summary += `\n\n**Note:** Full comparison requires API provider configuration.`;
+        return {
+            teamA,
+            teamB,
+            metrics,
+            summary,
+        };
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+        // Fallback to basic comparison
+        return {
+            teamA: { id: 'a', name: teamAName, country: '' },
+            teamB: { id: 'b', name: teamBName, country: '' },
+            metrics: [
+                {
+                    name: 'Team Name',
+                    teamAValue: teamAName,
+                    teamBValue: teamBName,
+                    importance: 'low',
+                },
+            ],
+            summary: `Basic comparison between ${teamAName} and ${teamBName}. API providers not configured.\n\nErrors: ${errors.join(', ')}`,
+        };
+    }
+}
+// ============= Tool Registration =============
+export function registerTeamTools(server) {
+    /**
+     * Tool 1: compare_teams
+     * Compare two teams across multiple metrics
+     */
+    server.tool('compare_teams', `Compare two football teams across multiple metrics.
+Analyzes: form, head-to-head, xG, possession, goals, defense, home/away records.`, {
+        teamA: z.string().describe('First team name'),
+        teamB: z.string().describe('Second team name'),
+        metrics: z.array(z.enum(['form', 'h2h', 'xg', 'possession', 'goals', 'defense', 'home-away']))
+            .optional().default(['form', 'h2h', 'goals'])
+            .describe('Metrics to compare'),
+    }, async ({ teamA, teamB, metrics }) => {
+        const result = await compareTeamsAnalysis(teamA, teamB);
+        const output = formatComparisonResult(result);
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 2: get_league_standings
+     * Get current league standings table
+     */
+    server.tool('get_league_standings', `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 3: get_team_info
+     * Get detailed information about a team
+     */
+    server.tool('get_team_info', `Get detailed team information including stats, squad, and recent form.`, {
+        team: z.string().describe('Team name'),
+    }, async ({ team }) => {
+        const cache = getGlobalCache();
+        const cacheKey = CacheService.generateKey('team_info', team);
+        // Check cache first (1 hour TTL)
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return {
+                content: [{ type: 'text', text: cached + '\n\n*(cached data)*' }],
+            };
+        }
+        let output = '';
+        const errors = [];
+        try {
+            const api = createAPIProvider();
+            const searchResult = await api.searchTeams(team);
+            if (searchResult.success && searchResult.data && searchResult.data.length > 0) {
+                const teamData = searchResult.data[0];
+                output = `## ⚽ ${teamData.name}\n\n`;
+                output += `**Country:** ${teamData.country}\n`;
+                if (teamData.founded)
+                    output += `**Founded:** ${teamData.founded}\n`;
+                if (teamData.venue)
+                    output += `**Stadium:** ${teamData.venue}\n`;
+                if (teamData.logo)
+                    output += `**Logo:** ${teamData.logo}\n`;
+                if (teamData.stats) {
+                    output += `\n### Season Stats\n`;
+                    output += `| Metric | Value |\n|--------|-------|\n`;
+                    output += `| Played | ${teamData.stats.matchesPlayed} |\n`;
+                    output += `| Wins | ${teamData.stats.wins} |\n`;
+                    output += `| Draws | ${teamData.stats.draws} |\n`;
+                    output += `| Losses | ${teamData.stats.losses} |\n`;
+                    output += `| Goals For/Against | ${teamData.stats.goalsFor}/${teamData.stats.goalsAgainst} |\n`;
+                    output += `| Goal Difference | ${teamData.stats.goalDifference} |\n`;
+                    if (teamData.stats.points !== undefined)
+                        output += `| Points | ${teamData.stats.points} |\n`;
+                }
+                // Cache for 1 hour
+                cache.set(cacheKey, output, CACHE_CONFIG.TTL.TEAM_STATS);
+            }
+            else {
+                errors.push('Team not found via API');
+            }
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+        // Fallback to web search
+        if (!output) {
+            try {
+                const searchQuery = `${team} football team stats squad`;
+                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 = `## ⚽ ${team}\n\n`;
+                output += `*API data not available. Click links for team info:*\n\n${fallbackText}`;
+            }
+            catch (searchError) {
+                output = `Error: ${errors.join(', ')}`;
+            }
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    /**
+     * Tool 4: get_top_scorers
+     * Get top scorers and assists for a league
+     */
+    server.tool('get_top_scorers', `Get top scorers and assists for a league.`, {
+        league: z.string().describe('League name'),
+        type: z.enum(['scorers', 'assists', 'both']).optional().default('both').describe('Statistics type'),
+        limit: z.number().optional().default(20).describe('Number of players to return'),
+    }, async ({ league, type, limit }) => {
+        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();
+                // Note: This would require a dedicated API endpoint for top scorers
+                // For now, use web search as fallback
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        // Use web search
+        try {
+            const searchQuery = `${league} top ${type === 'assists' ? 'assists' : 'scorers'} ${new Date().getFullYear()}`;
+            const searchProvider = getSearchProvider();
+            const searchResults = await searchProvider.search(searchQuery, undefined, limit);
+            output = `## 🥇 ${league} - Top ${type === 'assists' ? 'Assists' : 'Scorers'}\n\n`;
+            const items = searchResults.map((r, i) => `${i + 1}. [${r.title}](${r.url}): ${r.snippet}`).join('\n');
+            output += items;
+            if (searchResults.length === 0) {
+                output += `\nNo results found.`;
+            }
+        }
+        catch (error) {
+            output = `Error: ${errors.join(', ')}`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+}

package/dist/tools/sports/utils/calculator.d.ts

@@ -0,0 +1,69 @@
+/**
+ * SPORTS MODULE UTILS - Calculator
+ * Betting calculators and mathematical utilities
+ */
+import { BetType, KellyVariant, ValueBet } from '../core/types.js';
+/**
+ * Calculate value of a bet
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @returns Value as percentage (e.g., 0.15 = 15%)
+ */
+export declare function calculateValue(odds: number, probability: number): number;
+/**
+ * Calculate Kelly Criterion stake
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param variant - Kelly variant (full, half, quarter)
+ * @returns Fraction of bankroll to stake (0-1)
+ */
+export declare function calculateKelly(odds: number, probability: number, variant?: KellyVariant): number;
+/**
+ * Calculate recommended stake based on bankroll
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param bankroll - Total bankroll
+ * @param kellyVariant - Kelly variant
+ * @param maxStakePct - Maximum stake as percentage of bankroll
+ * @returns Recommended stake amount
+ */
+export declare function calculateRecommendedStake(odds: number, probability: number, bankroll?: number, kellyVariant?: KellyVariant, maxStakePct?: number): number;
+/**
+ * Create a value bet analysis
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param betType - Type of bet
+ * @param bankroll - Total bankroll
+ * @returns Value bet analysis
+ */
+export declare function analyzeValueBet(odds: number, probability: number, betType: BetType, bankroll?: number): Omit<ValueBet, 'match' | 'reasoning'>;
+/**
+ * Convert fractional odds to decimal
+ */
+export declare function fractionalToDecimal(fractional: string): number;
+/**
+ * Convert decimal odds to fractional
+ */
+export declare function decimalToFractional(decimal: number): string;
+/**
+ * Convert American odds to decimal
+ */
+export declare function americanToDecimal(american: number): number;
+/**
+ * Convert decimal odds to American
+ */
+export declare function decimalToAmerican(decimal: number): number;
+/**
+ * Calculate implied probability from decimal odds
+ */
+export declare function oddsToProbability(odds: number): number;
+/**
+ * Calculate overround (bookmaker margin)
+ * @param odds - Array of decimal odds for all outcomes
+ * @returns Overround as percentage
+ */
+export declare function calculateOverround(odds: number[]): number;
+/**
+ * Calculate true probability after removing overround
+ */
+export declare function removeOverround(odds: number[]): number[];

package/dist/tools/sports/utils/calculator.js

@@ -0,0 +1,156 @@
+/**
+ * SPORTS MODULE UTILS - Calculator
+ * Betting calculators and mathematical utilities
+ */
+import { BETTING } from '../core/constants.js';
+/**
+ * Calculate value of a bet
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @returns Value as percentage (e.g., 0.15 = 15%)
+ */
+export function calculateValue(odds, probability) {
+    return (odds * probability) - 1;
+}
+/**
+ * Calculate Kelly Criterion stake
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param variant - Kelly variant (full, half, quarter)
+ * @returns Fraction of bankroll to stake (0-1)
+ */
+export function calculateKelly(odds, probability, variant = 'half') {
+    const kelly = (probability * odds - 1) / (odds - 1);
+    // Kelly can be negative (no value), return 0 in that case
+    if (kelly < 0)
+        return 0;
+    switch (variant) {
+        case 'full':
+            return Math.min(kelly, 1);
+        case 'half':
+            return Math.min(kelly / 2, 1);
+        case 'quarter':
+            return Math.min(kelly / 4, 1);
+        default:
+            return Math.min(kelly / 2, 1);
+    }
+}
+/**
+ * Calculate recommended stake based on bankroll
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param bankroll - Total bankroll
+ * @param kellyVariant - Kelly variant
+ * @param maxStakePct - Maximum stake as percentage of bankroll
+ * @returns Recommended stake amount
+ */
+export function calculateRecommendedStake(odds, probability, bankroll = BETTING.DEFAULT_BANKROLL, kellyVariant = 'half', maxStakePct = BETTING.MAX_STAKE_PERCENTAGE) {
+    const kelly = calculateKelly(odds, probability, kellyVariant);
+    const kellyStake = bankroll * kelly;
+    const maxStake = bankroll * maxStakePct;
+    return Math.min(kellyStake, maxStake);
+}
+/**
+ * Create a value bet analysis
+ * @param odds - Decimal odds
+ * @param probability - Estimated probability (0-1)
+ * @param betType - Type of bet
+ * @param bankroll - Total bankroll
+ * @returns Value bet analysis
+ */
+export function analyzeValueBet(odds, probability, betType, bankroll = BETTING.DEFAULT_BANKROLL) {
+    const value = calculateValue(odds, probability);
+    const kellyFraction = calculateKelly(odds, probability, 'half');
+    const recommendedStake = calculateRecommendedStake(odds, probability, bankroll);
+    // Determine confidence based on value and probability
+    let confidence;
+    if (value >= BETTING.HIGH_VALUE_THRESHOLD && probability >= 0.5) {
+        confidence = BETTING.CONFIDENCE.VERY_HIGH;
+    }
+    else if (value >= BETTING.VALUE_THRESHOLD && probability >= 0.4) {
+        confidence = BETTING.CONFIDENCE.HIGH;
+    }
+    else if (value >= 0 && probability >= 0.3) {
+        confidence = BETTING.CONFIDENCE.MEDIUM;
+    }
+    else {
+        confidence = BETTING.CONFIDENCE.LOW;
+    }
+    return {
+        betType,
+        fairOdds: 1 / probability,
+        marketOdds: odds,
+        value,
+        confidence,
+        kellyFraction,
+        recommendedStake,
+    };
+}
+/**
+ * Convert fractional odds to decimal
+ */
+export function fractionalToDecimal(fractional) {
+    const [numerator, denominator] = fractional.split('/').map(Number);
+    if (denominator === 0)
+        return 0;
+    return (numerator / denominator) + 1;
+}
+/**
+ * Convert decimal odds to fractional
+ */
+export function decimalToFractional(decimal) {
+    const numerator = decimal - 1;
+    const denominator = 1;
+    // Find common denominator
+    const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+    const num = Math.round(numerator * 100);
+    const den = 100;
+    const divisor = gcd(num, den);
+    return `${num / divisor}/${den / divisor}`;
+}
+/**
+ * Convert American odds to decimal
+ */
+export function americanToDecimal(american) {
+    if (american > 0) {
+        return (american / 100) + 1;
+    }
+    else {
+        return (100 / Math.abs(american)) + 1;
+    }
+}
+/**
+ * Convert decimal odds to American
+ */
+export function decimalToAmerican(decimal) {
+    if (decimal >= 2) {
+        return Math.round((decimal - 1) * 100);
+    }
+    else {
+        return Math.round(-100 / (decimal - 1));
+    }
+}
+/**
+ * Calculate implied probability from decimal odds
+ */
+export function oddsToProbability(odds) {
+    return 1 / odds;
+}
+/**
+ * Calculate overround (bookmaker margin)
+ * @param odds - Array of decimal odds for all outcomes
+ * @returns Overround as percentage
+ */
+export function calculateOverround(odds) {
+    const impliedProbability = odds.reduce((sum, odd) => sum + oddsToProbability(odd), 0);
+    return impliedProbability - 1;
+}
+/**
+ * Calculate true probability after removing overround
+ */
+export function removeOverround(odds) {
+    const overround = calculateOverround(odds);
+    const probabilities = odds.map(o => oddsToProbability(o));
+    const total = probabilities.reduce((sum, p) => sum + p, 0);
+    return probabilities.map(p => p / total);
+}

package/dist/tools/sports/utils/formatter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * SPORTS MODULE UTILS - Formatter
+ * Output formatting utilities for sports data
+ */
+import { Match, TableEntry, PlayerStats, ComparisonResult, HeadToHead } from '../core/types.js';
+/**
+ * Format a match as markdown table row
+ */
+export declare function formatMatchRow(match: Match): string;
+/**
+ * Format standings as markdown table
+ */
+export declare function formatStandingsTable(standings: TableEntry[]): string;
+/**
+ * Format player stats as markdown table
+ */
+export declare function formatPlayerStats(stats: PlayerStats, playerName: string): string;
+/**
+ * Format comparison result as markdown
+ */
+export declare function formatComparisonResult(result: ComparisonResult): string;
+/**
+ * Format head to head record as markdown
+ */
+export declare function formatHeadToHead(h2h: HeadToHead): string;
+/**
+ * Format match status for display
+ */
+export declare function formatMatchStatus(status: Match['status']): string;
+/**
+ * Format score with context
+ */
+export declare function formatScore(match: Match): string;
+/**
+ * Format odds as decimal/fractional
+ */
+export declare function formatOdds(decimalOdds: number): string;
+/**
+ * Format probability as percentage
+ */
+export declare function formatProbability(probability: number): string;
+/**
+ * Format value bet recommendation
+ */
+export declare function formatValueBet(match: string, odds: number, probability: number, value: number, confidence: number): string;
+/**
+ * Format a list of matches as markdown table
+ */
+export declare function formatMatchesTable(matches: Match[], title: string): string;
+/**
+ * Truncate text to max length with ellipsis
+ */
+export declare function truncate(text: string, maxLength?: number): string;
+/**
+ * Format date relative to now
+ */
+export declare function formatRelativeDate(date: Date): string;