@gotza02/sequential-thinking 10000.2.0 → 10000.2.1

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 }],
+        };
+    });
+}

package/dist/tools/sports/tools/live.js

@@ -6,34 +6,65 @@ import { z } from 'zod';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getSearchProvider } from '../providers/search.js';
+import { logger } from '../../../utils.js';
 // Configuration for watchlist persistence
 const WATCHLIST_FILE = process.env.SPORTS_WATCHLIST_PATH || '.sports_watchlist.json';
-// In-memory watchlist storage (initialized from file)
-let watchlist = [];
-// Load watchlist from file
-async function loadWatchlist() {
-    try {
-        const filePath = path.resolve(WATCHLIST_FILE);
-        const data = await fs.readFile(filePath, 'utf-8');
-        watchlist = JSON.parse(data);
+// Watchlist storage with proper initialization
+class WatchlistStorage {
+    items = [];
+    initialized = false;
+    initPromise = null;
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Prevent concurrent initialization
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.loadFromFile();
+        await this.initPromise;
+        this.initialized = true;
     }
-    catch (error) {
-        // File doesn't exist or is invalid, start with empty list
-        watchlist = [];
+    async loadFromFile() {
+        try {
+            const filePath = path.resolve(WATCHLIST_FILE);
+            const data = await fs.readFile(filePath, 'utf-8');
+            this.items = JSON.parse(data);
+        }
+        catch (error) {
+            // File doesn't exist or is invalid, start with empty list
+            this.items = [];
+        }
     }
-}
-// Save watchlist to file
-async function saveWatchlist() {
-    try {
-        const filePath = path.resolve(WATCHLIST_FILE);
-        await fs.writeFile(filePath, JSON.stringify(watchlist, null, 2), 'utf-8');
+    async save() {
+        try {
+            const filePath = path.resolve(WATCHLIST_FILE);
+            await fs.writeFile(filePath, JSON.stringify(this.items, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logger.error(`Failed to save watchlist to ${WATCHLIST_FILE}:`, error);
+        }
+    }
+    getItems() {
+        return this.items;
+    }
+    add(item) {
+        this.items.push(item);
+    }
+    remove(id) {
+        const index = this.items.findIndex(item => item.id === id);
+        if (index === -1)
+            return null;
+        return this.items.splice(index, 1)[0];
+    }
+    clear() {
+        this.items = [];
     }
-    catch (error) {
-        console.error(`Failed to save watchlist to ${WATCHLIST_FILE}:`, error);
+    get length() {
+        return this.items.length;
     }
 }
-// Initialize watchlist
-loadWatchlist();
+// Singleton instance
+const watchlistStorage = new WatchlistStorage();
 /**
  * Register live and alert tools
  */
@@ -58,6 +89,8 @@ Can be called with:
         awayTeam: z.string().optional().describe('Away team name'),
         alertCondition: z.string().optional().describe('Alert condition for match'),
     }, async ({ type, target, condition, matchId, homeTeam, awayTeam, alertCondition }) => {
+        // Ensure watchlist is initialized before use
+        await watchlistStorage.initialize();
         const id = `watch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         // Handle match mode (matchId, homeTeam, awayTeam provided)
         let itemType = type;
@@ -88,8 +121,8 @@ Can be called with:
             createdAt: new Date().toISOString(),
             triggered: false,
         };
-        watchlist.push(item);
-        await saveWatchlist();
+        watchlistStorage.add(item);
+        await watchlistStorage.save();
         let output = `## 📋 Added to Watchlist\n\n`;
         output += `**ID:** ${id}\n`;
         output += `**Type:** ${itemType}\n`;
@@ -100,7 +133,7 @@ Can be called with:
             output += `**Match:** ${homeTeam} vs ${awayTeam}\n`;
         }
         output += `**Created:** ${item.createdAt}\n`;
-        output += `\n\nTotal watchlist items: ${watchlist.length}`;
+        output += `\n\nTotal watchlist items: ${watchlistStorage.length}`;
         return {
             content: [{ type: 'text', text: output }],
         };
@@ -110,13 +143,16 @@ Can be called with:
      * List all items in the watchlist
      */
     server.tool('watchlist_list', `List all items in the sports watchlist.`, {}, async () => {
-        if (watchlist.length === 0) {
+        // Ensure watchlist is initialized
+        await watchlistStorage.initialize();
+        const items = watchlistStorage.getItems();
+        if (items.length === 0) {
             return {
                 content: [{ type: 'text', text: '## 📋 Watchlist\n\nNo items in watchlist.' }],
             };
         }
-        let output = `## 📋 Watchlist (${watchlist.length} items)\n\n`;
-        for (const item of watchlist) {
+        let output = `## 📋 Watchlist (${items.length} items)\n\n`;
+        for (const item of items) {
             const status = item.triggered ? '✅' : '👀';
             output += `${status} **${item.id}**\n`;
             output += `- Type: ${item.type}\n`;
@@ -136,20 +172,21 @@ Can be called with:
     server.tool('watchlist_remove', `Remove an item from the sports watchlist.`, {
         id: z.string().describe('Watchlist item ID to remove'),
     }, async ({ id }) => {
-        const index = watchlist.findIndex(item => item.id === id);
-        if (index === -1) {
+        // Ensure watchlist is initialized
+        await watchlistStorage.initialize();
+        const removed = watchlistStorage.remove(id);
+        if (!removed) {
             return {
                 content: [{ type: 'text', text: `Error: Watchlist item "${id}" not found.` }],
                 isError: true,
             };
         }
-        const removed = watchlist.splice(index, 1)[0];
-        await saveWatchlist();
+        await watchlistStorage.save();
         let output = `## 📋 Removed from Watchlist\n\n`;
         output += `**ID:** ${removed.id}\n`;
         output += `**Type:** ${removed.type}\n`;
         output += `**Target:** ${removed.target}\n`;
-        output += `\n\nRemaining items: ${watchlist.length}`;
+        output += `\n\nRemaining items: ${watchlistStorage.length}`;
         return {
             content: [{ type: 'text', text: output }],
         };
@@ -159,9 +196,11 @@ Can be called with:
      * Clear all items from the watchlist
      */
     server.tool('watchlist_clear', `Clear all items from the sports watchlist.`, {}, async () => {
-        const count = watchlist.length;
-        watchlist = []; // Reset array
-        await saveWatchlist();
+        // Ensure watchlist is initialized
+        await watchlistStorage.initialize();
+        const count = watchlistStorage.length;
+        watchlistStorage.clear();
+        await watchlistStorage.save();
         return {
             content: [{ type: 'text', text: `## 📋 Watchlist Cleared\n\nRemoved ${count} item(s).` }],
         };
@@ -171,8 +210,11 @@ Can be called with:
      * Check watchlist for triggered alerts
      */
     server.tool('check_alerts', `Check watchlist for triggered alerts based on current data.`, {}, async () => {
+        // Ensure watchlist is initialized
+        await watchlistStorage.initialize();
         let output = `## 🔔 Alert Check Results\n\n`;
-        if (watchlist.length === 0) {
+        const items = watchlistStorage.getItems();
+        if (items.length === 0) {
             output += 'No items in watchlist.';
             return {
                 content: [{ type: 'text', text: output }],
@@ -181,7 +223,7 @@ Can be called with:
         const searchProvider = getSearchProvider();
         let triggeredCount = 0;
         let saveNeeded = false;
-        for (const item of watchlist) {
+        for (const item of items) {
             let triggered = false;
             let message = '';
             // Check based on type
@@ -217,7 +259,7 @@ Can be called with:
             }
         }
         if (saveNeeded) {
-            await saveWatchlist();
+            await watchlistStorage.save();
         }
         if (triggeredCount === 0) {
             output += 'No new alerts. All conditions normal.';