@gotza02/sequential-thinking 10000.2.0 → 10000.2.2

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.';

package/dist/tools/sports/tools/match-calculations.d.ts

@@ -0,0 +1,51 @@
+/**
+ * SPORTS MODULE - Match Calculations
+ * Probability and statistical calculation functions
+ */
+import { Match, ProbabilityRange } from '../core/types.js';
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+export declare function calculateAdaptiveTTL(dataType: 'match' | 'lineups' | 'odds' | 'news' | 'stats' | 'h2h' | 'form', matchDate?: Date): number;
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+export declare function calculateProbabilityRange(baseProbability: number, dataQuality: {
+    score: number;
+}): {
+    low: number;
+    mid: number;
+    high: number;
+};
+/**
+ * Calculate points from a team's form matches
+ */
+export declare function calculateFormPoints(form: Match[], teamName: string): number;
+/**
+ * Calculate expected goals from form data
+ */
+export declare function calculateExpectedGoals(form: Match[], teamName: string, isHomeTeam: boolean): {
+    xG: number;
+    attackStrength: number;
+    defenseWeakness: number;
+};
+/**
+ * Calculate probabilities from form data using proper normalization
+ */
+export declare function calculateProbabilitiesFromForm(homeForm: Match[], awayForm: Match[], homeTeamName: string, awayTeamName: string, dataQuality: number): {
+    homeWin: ProbabilityRange;
+    draw: ProbabilityRange;
+    awayWin: ProbabilityRange;
+    expectedGoals: {
+        home: number;
+        away: number;
+    };
+};
+/**
+ * Calculate probability from betting odds
+ */
+export declare function calculateProbabilityFromOdds(odds: number): number;
+/**
+ * Calculate Kelly Criterion stake
+ */
+export declare function calculateKellyStake(bankroll: number, probability: number, odds: number, fraction?: number): number;

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

@@ -0,0 +1,171 @@
+/**
+ * SPORTS MODULE - Match Calculations
+ * Probability and statistical calculation functions
+ */
+import { normalizeTeamName } from './match-helpers.js';
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+export function calculateAdaptiveTTL(dataType, matchDate) {
+    const now = Date.now();
+    const hoursUntilMatch = matchDate
+        ? (matchDate.getTime() - now) / (1000 * 60 * 60)
+        : Infinity;
+    switch (dataType) {
+        case 'odds':
+            if (hoursUntilMatch < 1)
+                return 60 * 1000;
+            if (hoursUntilMatch < 24)
+                return 5 * 60 * 1000;
+            return 15 * 60 * 1000;
+        case 'lineups':
+            if (hoursUntilMatch < 2)
+                return 5 * 60 * 1000;
+            return 60 * 60 * 1000;
+        case 'news':
+            if (hoursUntilMatch < 24)
+                return 15 * 60 * 1000;
+            return 60 * 60 * 1000;
+        case 'stats':
+        case 'h2h':
+            return 24 * 60 * 60 * 1000;
+        case 'form':
+            if (hoursUntilMatch < 0)
+                return 60 * 1000;
+            return 6 * 60 * 60 * 1000;
+        case 'match':
+            if (hoursUntilMatch < 0)
+                return 60 * 1000;
+            if (hoursUntilMatch < 1)
+                return 5 * 60 * 1000;
+            return 30 * 60 * 1000;
+        default:
+            return 60 * 60 * 1000;
+    }
+}
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+export function calculateProbabilityRange(baseProbability, dataQuality) {
+    // Higher data quality = narrower range
+    const qualityFactor = dataQuality.score / 100;
+    const baseUncertainty = 0.15; // 15% base uncertainty
+    // Adjust uncertainty based on data quality (better quality = smaller range)
+    const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
+    // Calculate range using standard error formula
+    const mid = baseProbability;
+    // Margin decreases with better data quality
+    const margin = adjustedUncertainty * Math.sqrt(mid * (1 - mid) + 0.1);
+    return {
+        low: Math.max(0, mid - margin * 1.96),
+        mid: Math.min(1, Math.max(0, mid)),
+        high: Math.min(1, mid + margin * 1.96),
+    };
+}
+/**
+ * Calculate points from a team's form matches
+ */
+export function calculateFormPoints(form, teamName) {
+    let points = 0;
+    for (const match of form) {
+        const isHome = normalizeTeamName(match.homeTeam.name).includes(normalizeTeamName(teamName));
+        const homeScore = match.score?.home ?? 0;
+        const awayScore = match.score?.away ?? 0;
+        const teamScore = isHome ? homeScore : awayScore;
+        const opponentScore = isHome ? awayScore : homeScore;
+        if (teamScore > opponentScore)
+            points += 3;
+        else if (teamScore === opponentScore)
+            points += 1;
+    }
+    return points;
+}
+/**
+ * Calculate expected goals from form data
+ */
+export function calculateExpectedGoals(form, teamName, isHomeTeam) {
+    let totalGoalsScored = 0;
+    let totalGoalsConceded = 0;
+    let matchesWithData = 0;
+    for (const match of form) {
+        if (!match.score)
+            continue;
+        const isHome = normalizeTeamName(match.homeTeam.name).includes(normalizeTeamName(teamName));
+        const homeScore = match.score.home ?? 0;
+        const awayScore = match.score.away ?? 0;
+        const teamScore = isHome ? homeScore : awayScore;
+        const opponentScore = isHome ? awayScore : homeScore;
+        totalGoalsScored += teamScore;
+        totalGoalsConceded += opponentScore;
+        matchesWithData++;
+    }
+    if (matchesWithData === 0) {
+        return { xG: 1.3, attackStrength: 1.0, defenseWeakness: 1.0 };
+    }
+    const avgGoalsScored = totalGoalsScored / matchesWithData;
+    const avgGoalsConceded = totalGoalsConceded / matchesWithData;
+    // League average is approximately 1.3 goals per match
+    const leagueAvgGoals = 1.3;
+    const attackStrength = avgGoalsScored / leagueAvgGoals;
+    const defenseWeakness = avgGoalsConceded / leagueAvgGoals;
+    // xG estimation
+    const xG = avgGoalsScored * (isHomeTeam ? 1.2 : 0.9);
+    return {
+        xG: Math.round(xG * 10) / 10,
+        attackStrength: Math.round(attackStrength * 100) / 100,
+        defenseWeakness: Math.round(defenseWeakness * 100) / 100
+    };
+}
+/**
+ * Calculate probabilities from form data using proper normalization
+ */
+export function calculateProbabilitiesFromForm(homeForm, awayForm, homeTeamName, awayTeamName, dataQuality) {
+    // Calculate form metrics
+    const homeXGData = calculateExpectedGoals(homeForm, homeTeamName, true);
+    const awayXGData = calculateExpectedGoals(awayForm, awayTeamName, false);
+    // Base probabilities from xG
+    const homeAdvantage = 1.2;
+    const adjustedHomeXg = homeXGData.xG * homeAdvantage;
+    const adjustedAwayXg = awayXGData.xG;
+    const totalXg = adjustedHomeXg + adjustedAwayXg;
+    const drawFactor = 0.25;
+    let homeProb = adjustedHomeXg / totalXg * (1 - drawFactor);
+    let awayProb = adjustedAwayXg / totalXg * (1 - drawFactor);
+    let drawProb = drawFactor;
+    // Normalize
+    const total = homeProb + awayProb + drawProb;
+    homeProb /= total;
+    awayProb /= total;
+    drawProb /= total;
+    // Determine confidence based on data quality and sample size
+    const sampleSize = Math.min(homeForm.length, awayForm.length);
+    let confidence = 'low';
+    if (sampleSize >= 5 && dataQuality >= 70)
+        confidence = 'high';
+    else if (sampleSize >= 3 && dataQuality >= 50)
+        confidence = 'medium';
+    return {
+        homeWin: calculateProbabilityRange(homeProb, confidence, dataQuality),
+        draw: calculateProbabilityRange(drawProb, confidence, dataQuality),
+        awayWin: calculateProbabilityRange(awayProb, confidence, dataQuality),
+        expectedGoals: {
+            home: homeXGData.xG,
+            away: awayXGData.xG
+        }
+    };
+}
+/**
+ * Calculate probability from betting odds
+ */
+export function calculateProbabilityFromOdds(odds) {
+    if (odds <= 1)
+        return 0.5;
+    return 1 / odds;
+}
+/**
+ * Calculate Kelly Criterion stake
+ */
+export function calculateKellyStake(bankroll, probability, odds, fraction = 0.5) {
+    const edge = (probability * odds - 1) / (odds - 1);
+    return Math.max(0, bankroll * edge * fraction);
+}

package/dist/tools/sports/tools/match-helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SPORTS MODULE - Match Helpers
+ * Utility functions for match analysis
+ */
+/**
+ * Get date context for search queries
+ */
+export declare function getDateContext(): string;
+/**
+ * Normalize team names for better matching
+ */
+export declare function normalizeTeamName(name: string): string;
+/**
+ * Check if a team name matches exactly or is contained within another name
+ * Uses more strict matching to avoid false positives
+ */
+export declare function isTeamMatch(teamName: string, matchName: string): boolean;
+/**
+ * Get analysis framework instructions
+ */
+export declare function getAnalysisInstructions(): string;

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

@@ -0,0 +1,57 @@
+/**
+ * SPORTS MODULE - Match Helpers
+ * Utility functions for match analysis
+ */
+/**
+ * Get date context for search queries
+ */
+export function getDateContext() {
+    const now = new Date();
+    const month = now.toLocaleDateString('en-US', { month: 'long' });
+    const year = now.getFullYear();
+    return ` ${month} ${year}`;
+}
+/**
+ * Normalize team names for better matching
+ */
+export function normalizeTeamName(name) {
+    return name
+        .toLowerCase()
+        .replace(/\b(fc|afc|sc|cf|united|utd|city|town|athletic|albion|rovers|wanderers|olympic|real)\b/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Check if a team name matches exactly or is contained within another name
+ * Uses more strict matching to avoid false positives
+ */
+export function isTeamMatch(teamName, matchName) {
+    const normalizedSearch = normalizeTeamName(teamName);
+    const normalizedMatch = normalizeTeamName(matchName);
+    // Exact match
+    if (normalizedSearch === normalizedMatch)
+        return true;
+    // Check if search is contained as a word in match
+    const searchWords = normalizedSearch.split(/\s+/).filter(w => w.length > 2);
+    const matchWords = normalizedMatch.split(/\s+/).filter(w => w.length > 2);
+    // Must have at least one significant word in common
+    const commonWords = searchWords.filter(w => matchWords.includes(w));
+    // For longer names, require more matching words
+    if (searchWords.length >= 2) {
+        return commonWords.length >= Math.min(2, searchWords.length);
+    }
+    return commonWords.length > 0;
+}
+/**
+ * Get analysis framework instructions
+ */
+export function getAnalysisInstructions() {
+    return `INSTRUCTIONS: Act as a World-Class Football Analysis Panel. Provide a deep, non-obvious analysis using this framework:\n\n` +
+        `1. 📊 THE DATA SCIENTIST (Quantitative):\n   - Analyze xG trends & Possession stats.\n   - Assess Home/Away variance.\n\n` +
+        `2. 🧠 THE TACTICAL SCOUT (Qualitative):\n   - Stylistic Matchup (Press vs Block).\n   - Key Battles.\n\n` +
+        `3. 🚑 THE PHYSIO (Physical Condition):\n   - FATIGUE CHECK: Days rest? Travel distance?\n   - Squad Depth: Who has the better bench?\n\n` +
+        `4. 🎯 SET PIECE ANALYST:\n   - Corners/Free Kicks: Strong vs Weak?\n   - Who is most likely to score from a header?\n\n` +
+        `5. 💎 THE INSIDER (External Factors):\n   - Market Movements (Odds dropping?).\n   - Referee & Weather impact.\n\n` +
+        `6. 🕵️ THE SKEPTIC & SCENARIOS:\n   - Why might the favorite LOSE?\n   - Game Script: "If Team A scores first..."\n\n` +
+        `🏆 FINAL VERDICT:\n   - Asian Handicap Leans\n   - Goal Line (Over/Under)\n   - The "Value Pick"`;
+}