@gotza02/sequential-thinking 10000.1.2 → 10000.1.4

package/dist/index.js

@@ -29,7 +29,10 @@ const server = new McpServer({
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 // Start Dashboard
-startDashboard(3001);
+const historyPath = process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json';
+startDashboard(3001, historyPath).catch(err => {
+    console.error("[Dashboard] Failed to start:", err);
+});
 const knowledgeGraph = new ProjectKnowledgeGraph();
 const memoryGraph = new KnowledgeGraphManager(process.env.MEMORY_GRAPH_PATH || 'knowledge_graph.json');
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');

package/dist/tools/sports/core/base.d.ts

@@ -2,7 +2,7 @@
  * SPORTS MODULE BASE CLASSES
  * Abstract base classes and interfaces for data providers
  */
-import { Match, Team, Player, TableEntry, APIResponse, ProviderStatus, ProviderType } from './types.js';
+import { Match, Team, Player, TableEntry, APIResponse, ProviderStatus, ProviderType, HeadToHead, MatchOdds } from './types.js';
 import { CacheService } from './cache.js';
 /**
  * Base interface for all data providers
@@ -48,6 +48,18 @@ export interface IDataProvider {
      * Search for players
      */
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Fetch head-to-head statistics between two teams
+     */
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    /**
+     * Fetch recent form (last N matches) for a team
+     */
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    /**
+     * Fetch odds for a match
+     */
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
 }
 /**
  * Abstract base class for API-based providers
@@ -84,6 +96,18 @@ export declare abstract class APIProviderBase implements IDataProvider {
     abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
     abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
     abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Head-to-head statistics (optional, may not be supported by all providers)
+     */
+    abstract getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    /**
+     * Team recent form (optional, may not be supported by all providers)
+     */
+    abstract getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    /**
+     * Match odds (optional, may not be supported by all providers)
+     */
+    abstract getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     /**
      * Make a rate-limited API call
      */
@@ -117,6 +141,9 @@ export declare abstract class ScraperProviderBase implements IDataProvider {
     abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
     abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
     abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     /**
      * Scrape a webpage and extract structured data
      */
@@ -143,6 +170,9 @@ export declare class FallbackProvider implements IDataProvider {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
 }
 /**
  * Base class for sports tools

package/dist/tools/sports/core/base.js

@@ -141,6 +141,16 @@ export class ScraperProviderBase {
             quotaLimit: Infinity,
         };
     }
+    // Optional methods - may not be implemented by all scrapers
+    async getH2H(matchId, team1Id, team2Id) {
+        return { success: false, error: 'H2H not available via scraper' };
+    }
+    async getTeamForm(teamId, last) {
+        return { success: false, error: 'Team form not available via scraper' };
+    }
+    async getMatchOdds(matchId) {
+        return { success: false, error: 'Match odds not available via scraper' };
+    }
     /**
      * Scrape a webpage and extract structured data
      */
@@ -243,6 +253,21 @@ export class FallbackProvider {
         return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.searchPlayers(query)), 60 * 60 * 1000 // 1 hour
         );
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        const cacheKey = CacheService.generateKey('h2h', matchId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getH2H(matchId, team1Id, team2Id)), 30 * 60 * 1000 // 30 minutes
+        );
+    }
+    async getTeamForm(teamId, last) {
+        const cacheKey = CacheService.generateKey('form', teamId, last?.toString() || '5');
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getTeamForm(teamId, last)), 30 * 60 * 1000 // 30 minutes
+        );
+    }
+    async getMatchOdds(matchId) {
+        const cacheKey = CacheService.generateKey('odds', matchId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getMatchOdds(matchId)), 5 * 60 * 1000 // 5 minutes (odds change frequently)
+        );
+    }
 }
 /**
  * Base class for sports tools

package/dist/tools/sports/core/cache.d.ts

@@ -1,19 +1,18 @@
 /**
- * ENHANCED CACHE SERVICE
- * TTL-based caching with stale-while-revalidate pattern
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
  */
 /**
- * CacheService - Thread-safe TTL-based caching with stale-while-revalidate
+ * CacheService - Thread-safe TTL-based caching with persistence
  */
 export declare class CacheService {
     private cache;
     private cachePath;
     private maxAge;
-    private staleAge;
     private maxSize;
     private savePending;
     private saveTimer;
-    constructor(cachePath?: string, maxAge?: number, maxSize?: number, staleAge?: number);
+    constructor(cachePath?: string, maxAge?: number, maxSize?: number);
     /**
      * Generate a cache key from components
      */
@@ -25,16 +24,7 @@ export declare class CacheService {
     /**
      * Set a value in cache
      */
-    set<T>(key: string, data: T, ttl?: number, staleTtl?: number): void;
-    /**
-     * Get or set with stale-while-revalidate pattern
-     * Returns cached value immediately, refreshes in background if stale
-     */
-    getOrSetWithStaleRevalidate<T>(key: string, factory: () => T | Promise<T>, ttl?: number, staleTtl?: number): Promise<T>;
-    /**
-     * Refresh data in background
-     */
-    private refreshInBackground;
+    set<T>(key: string, data: T, ttl?: number): void;
     /**
      * Check if a key exists and is not expired
      */
@@ -59,7 +49,6 @@ export declare class CacheService {
             hits: number;
             age: number;
             ttl: number;
-            isStale: boolean;
         }>;
     };
     /**
@@ -67,7 +56,7 @@ export declare class CacheService {
      */
     cleanup(): number;
     /**
-     * Evict the oldest entry (LRU with hit weighting)
+     * Evict the oldest entry (LRU)
      */
     private evictOldest;
     /**
@@ -89,7 +78,7 @@ export declare class CacheService {
     /**
      * Get or set pattern - returns cached value or computes and caches it
      */
-    getOrSet<T>(key: string, factory: () => T | Promise<T>, ttl?: number, staleTtl?: number): Promise<T>;
+    getOrSet<T>(key: string, factory: () => T | Promise<T>, ttl?: number): Promise<T>;
     /**
      * Get multiple keys at once
      */
@@ -97,7 +86,7 @@ export declare class CacheService {
     /**
      * Set multiple keys at once
      */
-    setMultiple<T>(entries: Map<string, T>, ttl?: number, staleTtl?: number): void;
+    setMultiple<T>(entries: Map<string, T>, ttl?: number): void;
     /**
      * Invalidate cache by pattern
      */

package/dist/tools/sports/core/cache.js

@@ -1,26 +1,24 @@
 /**
- * ENHANCED CACHE SERVICE
- * TTL-based caching with stale-while-revalidate pattern
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { CACHE_CONFIG } from './constants.js';
 import { logger, createSafeRegex } from '../../../utils.js';
 /**
- * CacheService - Thread-safe TTL-based caching with stale-while-revalidate
+ * CacheService - Thread-safe TTL-based caching with persistence
  */
 export class CacheService {
     cache = new Map();
     cachePath;
     maxAge;
-    staleAge;
     maxSize;
     savePending = false;
     saveTimer = null;
-    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE, staleAge) {
+    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE) {
         this.cachePath = path.resolve(cachePath);
         this.maxAge = maxAge;
-        this.staleAge = staleAge || maxAge * 2;
         this.maxSize = maxSize;
         this.loadFromFile();
     }
@@ -38,12 +36,11 @@ export class CacheService {
         if (!entry) {
             return null;
         }
-        // Check if expired (including stale period)
+        // Check if expired
         const now = Date.now();
-        const totalTtl = entry.ttl + entry.staleTtl;
-        if (now - entry.timestamp > totalTtl) {
+        if (now - entry.timestamp > entry.ttl) {
             this.cache.delete(key);
-            logger.debug(`Cache expired (including stale): ${key}`);
+            logger.debug(`Cache expired: ${key}`);
             return null;
         }
         // Increment hit counter
@@ -54,7 +51,7 @@ export class CacheService {
     /**
      * Set a value in cache
      */
-    set(key, data, ttl, staleTtl) {
+    set(key, data, ttl) {
         const now = Date.now();
         // Check if we need to evict old entries
         if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
@@ -65,64 +62,11 @@ export class CacheService {
             data,
             timestamp: now,
             ttl: ttl || this.maxAge,
-            staleTtl: staleTtl || this.staleAge,
             hits: 0,
         });
-        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}ms, Stale: ${staleTtl || this.staleAge}ms)`);
+        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}ms)`);
         this.scheduleSave();
     }
-    /**
-     * Get or set with stale-while-revalidate pattern
-     * Returns cached value immediately, refreshes in background if stale
-     */
-    async getOrSetWithStaleRevalidate(key, factory, ttl, staleTtl) {
-        const entry = this.cache.get(key);
-        const now = Date.now();
-        const effectiveTtl = ttl || this.maxAge;
-        const effectiveStaleTtl = staleTtl || this.staleAge;
-        if (entry) {
-            const age = now - entry.timestamp;
-            // Data is fresh - use it
-            if (age < effectiveTtl) {
-                entry.hits++;
-                return entry.data;
-            }
-            // Data is stale but within stale TTL - use it and refresh in background
-            if (age < effectiveTtl + effectiveStaleTtl) {
-                entry.hits++;
-                if (!entry.isRefreshing) {
-                    this.refreshInBackground(key, factory, effectiveTtl, effectiveStaleTtl);
-                }
-                return entry.data;
-            }
-        }
-        // No data or expired beyond stale TTL - fetch new data
-        const value = await factory();
-        this.set(key, value, effectiveTtl, effectiveStaleTtl);
-        return value;
-    }
-    /**
-     * Refresh data in background
-     */
-    async refreshInBackground(key, factory, ttl, staleTtl) {
-        const entry = this.cache.get(key);
-        if (entry) {
-            entry.isRefreshing = true;
-        }
-        try {
-            const value = await factory();
-            this.set(key, value, ttl, staleTtl);
-            logger.debug(`Background refresh successful: ${key}`);
-        }
-        catch (error) {
-            logger.error(`Background refresh failed for ${key}: ${error}`);
-        }
-        finally {
-            if (entry) {
-                entry.isRefreshing = false;
-            }
-        }
-    }
     /**
      * Check if a key exists and is not expired
      */
@@ -131,8 +75,7 @@ export class CacheService {
         if (!entry)
             return false;
         const now = Date.now();
-        const totalTtl = entry.ttl + entry.staleTtl;
-        if (now - entry.timestamp > totalTtl) {
+        if (now - entry.timestamp > entry.ttl) {
             this.cache.delete(key);
             return false;
         }
@@ -157,16 +100,12 @@ export class CacheService {
      */
     getStats() {
         const now = Date.now();
-        const entries = Array.from(this.cache.values()).map(entry => {
-            const age = now - entry.timestamp;
-            return {
-                key: entry.key,
-                hits: entry.hits,
-                age,
-                ttl: entry.ttl,
-                isStale: age > entry.ttl,
-            };
-        });
+        const entries = Array.from(this.cache.values()).map(entry => ({
+            key: entry.key,
+            hits: entry.hits,
+            age: now - entry.timestamp,
+            ttl: entry.ttl,
+        }));
         return {
             size: this.cache.size,
             maxSize: this.maxSize,
@@ -181,8 +120,7 @@ export class CacheService {
         const now = Date.now();
         let removed = 0;
         for (const [key, entry] of this.cache.entries()) {
-            const totalTtl = entry.ttl + entry.staleTtl;
-            if (now - entry.timestamp > totalTtl) {
+            if (now - entry.timestamp > entry.ttl) {
                 this.cache.delete(key);
                 removed++;
             }
@@ -194,22 +132,20 @@ export class CacheService {
         return removed;
     }
     /**
-     * Evict the oldest entry (LRU with hit weighting)
+     * Evict the oldest entry (LRU)
      */
     evictOldest() {
         let oldestKey = null;
-        let lowestScore = Infinity;
-        // Evict based on age weighted by hits
+        let oldestTime = Infinity;
         for (const [key, entry] of this.cache.entries()) {
-            const score = (Date.now() - entry.timestamp) / (entry.hits + 1);
-            if (score < lowestScore) {
-                lowestScore = score;
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
                 oldestKey = key;
             }
         }
         if (oldestKey) {
             this.cache.delete(oldestKey);
-            logger.debug(`Evicted LRU entry: ${oldestKey}`);
+            logger.debug(`Evicted oldest cache entry: ${oldestKey}`);
         }
     }
     /**
@@ -222,7 +158,7 @@ export class CacheService {
         this.saveTimer = setTimeout(() => {
             this.saveToFile();
             this.saveTimer = null;
-        }, 1000);
+        }, 1000); // Save after 1 second of inactivity
     }
     /**
      * Save cache to file
@@ -256,8 +192,7 @@ export class CacheService {
             const now = Date.now();
             let restored = 0;
             for (const [key, entry] of entries) {
-                const totalTtl = entry.ttl + entry.staleTtl;
-                if (now - entry.timestamp < totalTtl) {
+                if (now - entry.timestamp < entry.ttl) {
                     this.cache.set(key, entry);
                     restored++;
                 }
@@ -265,6 +200,7 @@ export class CacheService {
             logger.info(`Cache loaded: ${restored}/${entries.length} entries restored`);
         }
         catch (error) {
+            // File doesn't exist or is invalid - start fresh
             logger.debug('No existing cache file found, starting fresh');
         }
     }
@@ -281,8 +217,14 @@ export class CacheService {
     /**
      * Get or set pattern - returns cached value or computes and caches it
      */
-    async getOrSet(key, factory, ttl, staleTtl) {
-        return this.getOrSetWithStaleRevalidate(key, factory, ttl, staleTtl);
+    async getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
     }
     /**
      * Get multiple keys at once
@@ -300,15 +242,16 @@ export class CacheService {
     /**
      * Set multiple keys at once
      */
-    setMultiple(entries, ttl, staleTtl) {
+    setMultiple(entries, ttl) {
         for (const [key, value] of entries.entries()) {
-            this.set(key, value, ttl, staleTtl);
+            this.set(key, value, ttl);
         }
     }
     /**
      * Invalidate cache by pattern
      */
     invalidatePattern(pattern) {
+        // Use safe regex creation to prevent ReDoS attacks
         const regex = createSafeRegex(pattern);
         let removed = 0;
         for (const key of this.cache.keys()) {
@@ -345,10 +288,10 @@ let globalCache = null;
 export function getGlobalCache() {
     if (!globalCache) {
         globalCache = new CacheService();
-        // Cleanup expired entries every 2 minutes
+        // Cleanup expired entries every 5 minutes
         setInterval(() => {
             globalCache?.cleanup();
-        }, 2 * 60 * 1000);
+        }, 5 * 60 * 1000);
     }
     return globalCache;
 }

package/dist/tools/sports/core/constants.d.ts

@@ -10,40 +10,25 @@ export declare const API_CONFIG: {
     readonly FOOTBALL_DATA_BASE: "https://api.football-data.org/v4";
     readonly SPORTS_DB_KEY: string;
     readonly SPORTS_DB_BASE: "https://www.thesportsdb.com/api/v1/json";
-    readonly ODDS_API_KEY: string;
-    readonly ODDS_API_BASE: "https://api.the-odds-api.com/v4";
-    readonly SPORTRADAR_KEY: string;
-    readonly SPORTRADAR_BASE: "https://api.sportradar.us/soccer/trial/v4";
     readonly RATE_LIMITS: {
         readonly API_FOOTBALL: 10;
         readonly FOOTBALL_DATA: 10;
         readonly SPORTS_DB: 30;
-        readonly ODDS_API: 20;
-        readonly SPORTRADAR: 100;
     };
 };
 export declare const CACHE_CONFIG: {
     readonly DEFAULT_TTL: number;
     readonly TTL: {
         readonly LIVE_SCORES: number;
-        readonly LIVE_EVENTS: number;
-        readonly ODDS: number;
         readonly MATCH_DETAILS: number;
         readonly STANDINGS: number;
         readonly TEAM_STATS: number;
         readonly PLAYER_STATS: number;
+        readonly ODDS: number;
         readonly TRANSFER_NEWS: number;
-        readonly PREDICTIONS: number;
-    };
-    readonly STALE_MULTIPLIERS: {
-        readonly LIVE_SCORES: 2;
-        readonly ODDS: 2;
-        readonly MATCH_DETAILS: 2;
-        readonly STANDINGS: 1.5;
-        readonly TEAM_STATS: 1.5;
     };
     readonly CACHE_PATH: string;
-    readonly MAX_SIZE: 2000;
+    readonly MAX_SIZE: 1000;
 };
 export declare const SCRAPER_CONFIG: {
     readonly PRIORITY_DOMAINS: readonly ["understat.com", "bbc.co.uk/sport", "sportsmole.co.uk", "skysports.com", "goal.com", "thesquareball.net", "fbref.com", "whoscored.com", "sofascore.com", "flashscore.com"];
@@ -187,53 +172,9 @@ export declare const ERRORS: {
     readonly TIMEOUT: "Request timed out.";
     readonly INVALID_RESPONSE: "Invalid response from API.";
     readonly ALL_PROVIDERS_FAILED: "All data providers failed.";
-    readonly CIRCUIT_BREAKER_OPEN: "Service temporarily unavailable due to repeated failures.";
-};
-export declare const ALERT_CONFIG: {
-    readonly CHECK_INTERVAL: 10000;
-    readonly DEFAULT_COOLDOWN: 300000;
-    readonly MAX_ALERTS_PER_HOUR: 10;
-    readonly TYPES: {
-        readonly ODDS_DROP: "odds_drop";
-        readonly ODDS_VALUE: "odds_value";
-        readonly GOAL: "goal";
-        readonly RED_CARD: "red_card";
-        readonly LINEUP_CHANGE: "lineup_change";
-        readonly MATCH_START: "match_start";
-        readonly MATCH_END: "match_end";
-        readonly CUSTOM: "custom";
-    };
-};
-export declare const REALTIME_CONFIG: {
-    readonly WS_RECONNECT_INTERVAL: 5000;
-    readonly WS_MAX_RECONNECT_ATTEMPTS: 10;
-    readonly POLLING_INTERVALS: {
-        readonly LIVE_SCORES: 15000;
-        readonly ODDS: 30000;
-        readonly MATCH_EVENTS: 5000;
-    };
-    readonly EVENT_BATCH_SIZE: 10;
-    readonly EVENT_BATCH_TIMEOUT: 1000;
-};
-export declare const ML_CONFIG: {
-    readonly MIN_TRAINING_MATCHES: 50;
-    readonly FEATURE_WEIGHTS: {
-        readonly form: 0.25;
-        readonly h2h: 0.2;
-        readonly home_advantage: 0.15;
-        readonly xg: 0.15;
-        readonly injuries: 0.1;
-        readonly fatigue: 0.1;
-        readonly weather: 0.05;
-    };
-    readonly CONFIDENCE_THRESHOLDS: {
-        readonly high: 0.7;
-        readonly medium: 0.55;
-        readonly low: 0.4;
-    };
 };
 export declare const MODULE_INFO: {
     readonly NAME: "sports-module";
-    readonly VERSION: "3.0.0";
-    readonly DESCRIPTION: "Football Intelligence System for MCP Server - Realtime Edition";
+    readonly VERSION: "2.0.0";
+    readonly DESCRIPTION: "Football Intelligence System for MCP Server";
 };