@gotza02/sequential-thinking 10000.1.0 → 10000.1.2

package/dist/tools/sports/core/historical-analyzer.js

@@ -1,53 +1,37 @@
 /**
  * HISTORICAL ANALYZER
- * Analyzes historical data for patterns and trends
- */
-/**
- * Historical Analyzer
- * Analyzes past matches for patterns and predictive insights
  */
+// Simple logger fallback
+const logger = {
+    info: (...args) => console.error('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    debug: (...args) => { }
+};
 export class HistoricalAnalyzer {
     matchHistory = [];
-    patterns = new Map();
-    constructor() {
-        this.loadHistoricalData();
-    }
-    /**
-     * Analyze team performance over time
-     */
     analyzeTeamPerformance(teamId, query) {
         const matches = this.getTeamMatches(teamId, query);
-        if (matches.length === 0) {
+        if (matches.length === 0)
             return this.createEmptyPerformance(teamId);
-        }
         const wins = matches.filter(m => this.isWin(m, teamId)).length;
         const draws = matches.filter(m => this.isDraw(m)).length;
         const losses = matches.filter(m => this.isLoss(m, teamId)).length;
         const totalGoalsFor = matches.reduce((sum, m) => sum + this.getGoalsFor(m, teamId), 0);
         const totalGoalsAgainst = matches.reduce((sum, m) => sum + this.getGoalsAgainst(m, teamId), 0);
-        const patterns = this.findPatterns(teamId, matches);
         return {
             team: matches[0].homeTeam.id === teamId ? matches[0].homeTeam : matches[0].awayTeam,
             totalMatches: matches.length,
-            wins,
-            draws,
-            losses,
+            wins, draws, losses,
             avgGoalsFor: totalGoalsFor / matches.length,
             avgGoalsAgainst: totalGoalsAgainst / matches.length,
             homeAdvantage: this.calculateHomeAdvantage(teamId, matches),
-            patterns,
+            patterns: this.findPatterns(teamId, matches),
         };
     }
-    /**
-     * Analyze head-to-head history
-     */
     analyzeHeadToHead(teamAId, teamBId, limit = 10) {
         const matches = this.getH2HMatches(teamAId, teamBId, limit);
-        let homeWins = 0;
-        let awayWins = 0;
-        let draws = 0;
-        let homeGoals = 0;
-        let awayGoals = 0;
+        let homeWins = 0, awayWins = 0, draws = 0, homeGoals = 0, awayGoals = 0;
         matches.forEach(match => {
             if (!match.score)
                 return;
@@ -74,71 +58,38 @@ export class HistoricalAnalyzer {
             homeTeam: matches[0]?.homeTeam || { id: teamAId, name: '', country: '' },
             awayTeam: matches[0]?.awayTeam || { id: teamBId, name: '', country: '' },
             totalMatches: matches.length,
-            homeWins,
-            draws,
-            awayWins,
-            homeGoals,
-            awayGoals,
+            homeWins, draws, awayWins,
+            homeGoals, awayGoals,
             recentMatches: matches.slice(0, 5),
         };
     }
-    /**
-     * Analyze trends for a team
-     */
     analyzeTrends(teamId, windowSize = 5) {
         const matches = this.getTeamMatches(teamId).slice(0, windowSize);
         if (matches.length < 3) {
-            return {
-                direction: 'stable',
-                strength: 0,
-                confidence: 0,
-                dataPoints: matches.length,
-                description: 'Insufficient data for trend analysis',
-            };
+            return { direction: 'stable', strength: 0, confidence: 0, dataPoints: matches.length, description: 'Insufficient data' };
         }
-        // Calculate performance in recent matches
-        const recentPerformance = matches.slice(0, Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
-        const olderPerformance = matches.slice(Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
-        const recentAvg = recentPerformance.reduce((a, b) => a + b, 0) / recentPerformance.length;
-        const olderAvg = olderPerformance.reduce((a, b) => a + b, 0) / olderPerformance.length;
+        const recent = matches.slice(0, Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
+        const older = matches.slice(Math.ceil(windowSize / 2)).map(m => this.getMatchPoints(m, teamId));
+        const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+        const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
         const difference = recentAvg - olderAvg;
         const strength = Math.min(1, Math.abs(difference) / 2);
-        let direction;
-        if (difference > 0.5)
-            direction = 'up';
-        else if (difference < -0.5)
-            direction = 'down';
-        else
-            direction = 'stable';
-        const description = direction === 'up'
-            ? `Team improving: ${recentAvg.toFixed(2)} pts/game recently vs ${olderAvg.toFixed(2)} before`
-            : direction === 'down'
-                ? `Team declining: ${recentAvg.toFixed(2)} pts/game recently vs ${olderAvg.toFixed(2)} before`
-                : `Team stable: ${recentAvg.toFixed(2)} pts/game`;
+        const direction = difference > 0.5 ? 'up' : difference < -0.5 ? 'down' : 'stable';
         return {
-            direction,
-            strength,
+            direction, strength,
             confidence: Math.min(100, matches.length * 10),
             dataPoints: matches.length,
-            description,
+            description: direction === 'up'
+                ? `Improving: ${recentAvg.toFixed(2)} pts/game vs ${olderAvg.toFixed(2)} before`
+                : direction === 'down'
+                    ? `Declining: ${recentAvg.toFixed(2)} pts/game vs ${olderAvg.toFixed(2)} before`
+                    : `Stable: ${recentAvg.toFixed(2)} pts/game`,
         };
     }
-    /**
-     * Calculate performance metrics
-     */
     calculateMetrics(teamId, query) {
         const matches = this.getTeamMatches(teamId, query);
         if (matches.length === 0) {
-            return {
-                winRate: 0,
-                drawRate: 0,
-                lossRate: 0,
-                avgGoalsFor: 0,
-                avgGoalsAgainst: 0,
-                cleanSheetRate: 0,
-                bothTeamsScoreRate: 0,
-                over25Rate: 0,
-            };
+            return { winRate: 0, drawRate: 0, lossRate: 0, avgGoalsFor: 0, avgGoalsAgainst: 0, cleanSheetRate: 0, bothTeamsScoreRate: 0, over25Rate: 0 };
         }
         const wins = matches.filter(m => this.isWin(m, teamId)).length;
         const draws = matches.filter(m => this.isDraw(m)).length;
@@ -147,10 +98,7 @@ export class HistoricalAnalyzer {
         const totalGoalsAgainst = matches.reduce((sum, m) => sum + this.getGoalsAgainst(m, teamId), 0);
         const cleanSheets = matches.filter(m => this.getGoalsAgainst(m, teamId) === 0).length;
         const btts = matches.filter(m => this.getGoalsFor(m, teamId) > 0 && this.getGoalsAgainst(m, teamId) > 0).length;
-        const over25 = matches.filter(m => {
-            const total = this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId);
-            return total > 2.5;
-        }).length;
+        const over25 = matches.filter(m => this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId) > 2.5).length;
         return {
             winRate: wins / matches.length,
             drawRate: draws / matches.length,
@@ -162,13 +110,9 @@ export class HistoricalAnalyzer {
             over25Rate: over25 / matches.length,
         };
     }
-    /**
-     * Find betting patterns
-     */
     findBettingPatterns(query) {
         const patterns = [];
         const matches = this.queryMatches(query);
-        // Pattern: Home favorites
         const homeFavorites = matches.filter(m => m.odds && m.odds.homeWin < 1.5 && m.score && m.score.home > m.score.away);
         if (homeFavorites.length >= 5) {
             patterns.push({
@@ -179,136 +123,42 @@ export class HistoricalAnalyzer {
                 profit: this.calculateProfit(homeFavorites, 'home'),
             });
         }
-        // Pattern: Under 2.5 in low-scoring leagues
-        const lowScoringMatches = matches.filter(m => {
-            const total = (m.score?.home || 0) + (m.score?.away || 0);
-            return total < 2.5;
-        });
-        if (lowScoringMatches.length >= 10) {
+        const lowScoring = matches.filter(m => (m.score?.home || 0) + (m.score?.away || 0) < 2.5);
+        if (lowScoring.length >= 10) {
             patterns.push({
                 pattern: 'Under 2.5 goals',
-                occurrence: lowScoringMatches.length,
-                successRate: lowScoringMatches.length / matches.length,
-                avgOdds: 1.8, // Typical under 2.5 odds
-                profit: (lowScoringMatches.length * 0.8 - (matches.length - lowScoringMatches.length)) * 10,
+                occurrence: lowScoring.length,
+                successRate: lowScoring.length / matches.length,
+                avgOdds: 1.8,
+                profit: (lowScoring.length * 0.8 - (matches.length - lowScoring.length)) * 10,
             });
         }
-        // Pattern: BTTS
         const bttsMatches = matches.filter(m => (m.score?.home || 0) > 0 && (m.score?.away || 0) > 0);
         if (bttsMatches.length >= 10) {
             patterns.push({
                 pattern: 'Both teams score',
                 occurrence: bttsMatches.length,
                 successRate: bttsMatches.length / matches.length,
-                avgOdds: 1.9, // Typical BTTS odds
+                avgOdds: 1.9,
                 profit: (bttsMatches.length * 0.9 - (matches.length - bttsMatches.length)) * 10,
             });
         }
         return patterns.sort((a, b) => b.profit - a.profit);
     }
-    /**
-     * Analyze referee bias
-     */
-    analyzeRefereeBias(refereeName, teamId) {
-        const matches = this.matchHistory.filter(m => m.referee?.name === refereeName && m.status === 'finished');
-        const homeWins = matches.filter(m => m.score && m.score.home > m.score.away).length;
-        // Calculate team bias if teamId provided
-        let teamBias;
-        if (teamId) {
-            const teamMatches = matches.filter(m => m.homeTeam.id === teamId || m.awayTeam.id === teamId);
-            const teamWins = teamMatches.filter(m => this.isWin(m, teamId)).length;
-            teamBias = teamWins / (teamMatches.length || 1);
-        }
-        return {
-            referee: refereeName,
-            matches: matches.length,
-            avgCards: 3.5, // Placeholder
-            homeWinRate: homeWins / (matches.length || 1),
-            teamBias,
-        };
-    }
-    /**
-     * Analyze weather impact
-     */
-    analyzeWeatherImpact(condition, teamId) {
-        const matches = this.matchHistory.filter(m => m.weather?.condition === condition && m.status === 'finished');
-        const totalGoals = matches.reduce((sum, m) => sum + (m.score?.home || 0) + (m.score?.away || 0), 0);
-        const homeWins = matches.filter(m => m.score && m.score.home > m.score.away).length;
-        let teamPerformance;
-        if (teamId) {
-            const teamMatches = matches.filter(m => m.homeTeam.id === teamId || m.awayTeam.id === teamId);
-            const points = teamMatches.reduce((sum, m) => sum + this.getMatchPoints(m, teamId), 0);
-            teamPerformance = points / (teamMatches.length || 1);
-        }
-        return {
-            condition,
-            matches: matches.length,
-            avgGoals: totalGoals / (matches.length || 1),
-            homeWinRate: homeWins / (matches.length || 1),
-            teamPerformance,
-        };
-    }
-    /**
-     * Get similar matches
-     */
-    findSimilarMatches(match, limit = 5) {
-        return this.matchHistory
-            .filter(m => m.id !== match.id &&
-            m.status === 'finished' &&
-            m.league.id === match.league.id)
-            .map(m => ({
-            match: m,
-            similarity: this.calculateSimilarity(match, m),
-        }))
-            .sort((a, b) => b.similarity - a.similarity)
-            .slice(0, limit)
-            .map(r => r.match);
-    }
-    /**
-     * Calculate similarity between two matches
-     */
-    calculateSimilarity(matchA, matchB) {
-        let score = 0;
-        // Same league
-        if (matchA.league.id === matchB.league.id)
-            score += 0.3;
-        // Similar odds
-        if (matchA.odds && matchB.odds) {
-            const oddsDiff = Math.abs(matchA.odds.homeWin - matchB.odds.homeWin);
-            score += Math.max(0, 0.3 - oddsDiff);
-        }
-        // Similar teams (by position)
-        if (matchA.homeTeam.stats?.position && matchB.homeTeam.stats?.position) {
-            const posDiff = Math.abs(matchA.homeTeam.stats.position - matchB.homeTeam.stats.position);
-            score += Math.max(0, 0.2 - (posDiff / 20));
-        }
-        // Same venue type
-        if (matchA.venue && matchB.venue)
-            score += 0.2;
-        return score;
-    }
-    // Helper methods
     getTeamMatches(teamId, query) {
-        let matches = this.matchHistory.filter(m => (m.homeTeam.id === teamId || m.awayTeam.id === teamId) &&
-            m.status === 'finished');
-        if (query?.dateFrom) {
+        let matches = this.matchHistory.filter(m => (m.homeTeam.id === teamId || m.awayTeam.id === teamId) && m.status === 'finished');
+        if (query?.dateFrom)
             matches = matches.filter(m => m.date >= query.dateFrom);
-        }
-        if (query?.dateTo) {
+        if (query?.dateTo)
             matches = matches.filter(m => m.date <= query.dateTo);
-        }
         if (query?.venue) {
-            matches = matches.filter(m => query.venue === 'home' ? m.homeTeam.id === teamId :
-                query.venue === 'away' ? m.awayTeam.id === teamId :
-                    true);
+            matches = matches.filter(m => query.venue === 'home' ? m.homeTeam.id === teamId : query.venue === 'away' ? m.awayTeam.id === teamId : true);
         }
         return matches.sort((a, b) => b.date.getTime() - a.date.getTime());
     }
     getH2HMatches(teamAId, teamBId, limit) {
         return this.matchHistory
-            .filter(m => ((m.homeTeam.id === teamAId && m.awayTeam.id === teamBId) ||
-            (m.homeTeam.id === teamBId && m.awayTeam.id === teamAId)) &&
-            m.status === 'finished')
+            .filter(m => ((m.homeTeam.id === teamAId && m.awayTeam.id === teamBId) || (m.homeTeam.id === teamBId && m.awayTeam.id === teamAId)) && m.status === 'finished')
             .sort((a, b) => b.date.getTime() - a.date.getTime())
             .slice(0, limit);
     }
@@ -316,36 +166,22 @@ export class HistoricalAnalyzer {
         if (!match.score)
             return false;
         const isHome = match.homeTeam.id === teamId;
-        return isHome
-            ? match.score.home > match.score.away
-            : match.score.away > match.score.home;
+        return isHome ? match.score.home > match.score.away : match.score.away > match.score.home;
     }
     isDraw(match) {
-        if (!match.score)
-            return false;
-        return match.score.home === match.score.away;
+        return match.score ? match.score.home === match.score.away : false;
     }
     isLoss(match, teamId) {
         if (!match.score)
             return false;
         const isHome = match.homeTeam.id === teamId;
-        return isHome
-            ? match.score.home < match.score.away
-            : match.score.away < match.score.home;
+        return isHome ? match.score.home < match.score.away : match.score.away < match.score.home;
     }
     getGoalsFor(match, teamId) {
-        if (!match.score)
-            return 0;
-        return match.homeTeam.id === teamId
-            ? match.score.home
-            : match.score.away;
+        return match.score ? (match.homeTeam.id === teamId ? match.score.home : match.score.away) : 0;
     }
     getGoalsAgainst(match, teamId) {
-        if (!match.score)
-            return 0;
-        return match.homeTeam.id === teamId
-            ? match.score.away
-            : match.score.home;
+        return match.score ? (match.homeTeam.id === teamId ? match.score.away : match.score.home) : 0;
     }
     getMatchPoints(match, teamId) {
         if (this.isWin(match, teamId))
@@ -365,28 +201,14 @@ export class HistoricalAnalyzer {
     }
     findPatterns(teamId, matches) {
         const patterns = [];
-        // Pattern: Strong at home
         const homeMatches = matches.filter(m => m.homeTeam.id === teamId);
         const homeWins = homeMatches.filter(m => this.isWin(m, teamId)).length;
         if (homeMatches.length >= 5 && homeWins / homeMatches.length > 0.6) {
-            patterns.push({
-                pattern: 'Strong home record',
-                occurrence: homeWins,
-                successRate: homeWins / homeMatches.length,
-                avgOdds: 1.8,
-                profit: 0,
-            });
+            patterns.push({ pattern: 'Strong home record', occurrence: homeWins, successRate: homeWins / homeMatches.length, avgOdds: 1.8, profit: 0 });
         }
-        // Pattern: High scoring
         const highScoring = matches.filter(m => this.getGoalsFor(m, teamId) + this.getGoalsAgainst(m, teamId) > 2.5);
         if (highScoring.length / matches.length > 0.6) {
-            patterns.push({
-                pattern: 'High scoring matches',
-                occurrence: highScoring.length,
-                successRate: highScoring.length / matches.length,
-                avgOdds: 1.9,
-                profit: 0,
-            });
+            patterns.push({ pattern: 'High scoring matches', occurrence: highScoring.length, successRate: highScoring.length / matches.length, avgOdds: 1.9, profit: 0 });
         }
         return patterns;
     }
@@ -395,9 +217,7 @@ export class HistoricalAnalyzer {
         matches.forEach(m => {
             if (!m.odds || !m.score)
                 return;
-            const won = betOn === 'home' && m.score.home > m.score.away ||
-                betOn === 'away' && m.score.away > m.score.home ||
-                betOn === 'draw' && m.score.home === m.score.away;
+            const won = betOn === 'home' && m.score.home > m.score.away || betOn === 'away' && m.score.away > m.score.home || betOn === 'draw' && m.score.home === m.score.away;
             if (won) {
                 profit += (m.odds[betOn === 'home' ? 'homeWin' : betOn === 'away' ? 'awayWin' : 'draw'] - 1) * 10;
             }
@@ -409,53 +229,33 @@ export class HistoricalAnalyzer {
     }
     queryMatches(query) {
         let matches = this.matchHistory.filter(m => m.status === 'finished');
-        if (query.team) {
+        if (query.team)
             matches = matches.filter(m => m.homeTeam.name === query.team || m.awayTeam.name === query.team);
-        }
-        if (query.league) {
+        if (query.league)
             matches = matches.filter(m => m.league.name === query.league);
-        }
-        if (query.dateFrom) {
+        if (query.dateFrom)
             matches = matches.filter(m => m.date >= query.dateFrom);
-        }
-        if (query.dateTo) {
+        if (query.dateTo)
             matches = matches.filter(m => m.date <= query.dateTo);
-        }
         return matches;
     }
     createEmptyPerformance(teamId) {
         return {
             team: { id: teamId, name: '', country: '' },
-            totalMatches: 0,
-            wins: 0,
-            draws: 0,
-            losses: 0,
-            avgGoalsFor: 0,
-            avgGoalsAgainst: 0,
-            homeAdvantage: 0,
-            patterns: [],
+            totalMatches: 0, wins: 0, draws: 0, losses: 0,
+            avgGoalsFor: 0, avgGoalsAgainst: 0,
+            homeAdvantage: 0, patterns: [],
         };
     }
-    loadHistoricalData() {
-        // Would load from database
-        // For now, start empty
-    }
-    /**
-     * Add match to history
-     */
     addMatch(match) {
         this.matchHistory.push(match);
-        // Keep only last 1000 matches
-        if (this.matchHistory.length > 1000) {
+        if (this.matchHistory.length > 1000)
             this.matchHistory.shift();
-        }
     }
 }
-// Singleton instance
 let globalHistoricalAnalyzer = null;
 export function getHistoricalAnalyzer() {
-    if (!globalHistoricalAnalyzer) {
+    if (!globalHistoricalAnalyzer)
         globalHistoricalAnalyzer = new HistoricalAnalyzer();
-    }
     return globalHistoricalAnalyzer;
 }

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

@@ -1,5 +1,5 @@
 /**
- * SPORTS MODULE CORE - Exports
+ * SPORTS MODULE CORE - Exports (FIXED)
  */
 export * from './types.js';
 export { CacheService, getGlobalCache, resetGlobalCache } from './cache.js';

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

@@ -1,5 +1,5 @@
 /**
- * SPORTS MODULE CORE - Exports
+ * SPORTS MODULE CORE - Exports (FIXED)
  */
 // Types
 export * from './types.js';

package/dist/tools/sports/core/ml-prediction.d.ts

@@ -1,8 +1,7 @@
 /**
  * ML PREDICTION ENGINE
- * Machine learning based match outcome prediction
  */
-import type { Match, TeamStats, PredictionFactor, HeadToHead } from './types.js';
+import type { Match, TeamStats, HeadToHead } from './types.js';
 export interface PredictionInput {
     match: Match;
     homeForm: FormData;
@@ -36,6 +35,12 @@ export interface WeatherData {
     windSpeed: number;
     precipitation: boolean;
 }
+export interface PredictionFactor {
+    name: string;
+    weight: number;
+    impact: 'positive' | 'negative' | 'neutral';
+    description: string;
+}
 export interface PredictionResult {
     homeWin: number;
     draw: number;
@@ -45,90 +50,27 @@ export interface PredictionResult {
     confidence: number;
     factors: PredictionFactor[];
 }
-/**
- * ML Prediction Engine
- * Uses weighted factors and historical patterns for predictions
- */
 export declare class MLPredictionEngine {
     private weights;
     private historicalData;
-    constructor();
-    /**
-     * Predict match outcome
-     */
     predict(input: PredictionInput): Promise<PredictionResult>;
-    /**
-     * Calculate form score (-1 to 1)
-     */
     private calculateFormScore;
     private formToPoints;
-    /**
-     * Calculate H2H score (-1 to 1)
-     */
     private calculateH2HScore;
-    /**
-     * Calculate home advantage score (0 to 1)
-     */
     private calculateHomeAdvantage;
-    /**
-     * Calculate xG score (-1 to 1)
-     */
     private calculateXgScore;
-    /**
-     * Calculate injury impact (-1 to 1)
-     */
     private calculateInjuryImpact;
-    /**
-     * Calculate fatigue impact (-1 to 1)
-     */
     private calculateFatigueImpact;
-    /**
-     * Calculate weather impact (-0.5 to 0.5)
-     */
     private calculateWeatherImpact;
-    /**
-     * Combine weighted scores
-     */
     private combineScores;
-    /**
-     * Convert score to probabilities
-     */
     private scoreToProbabilities;
-    /**
-     * Calculate confidence level
-     */
     private calculateConfidence;
-    /**
-     * Predict Over 2.5 goals
-     */
     private predictOver25;
-    /**
-     * Predict Both Teams to Score
-     */
     private predictBTTS;
-    /**
-     * Describe form impact
-     */
     private describeFormImpact;
-    /**
-     * Describe H2H impact
-     */
     private describeH2HImpact;
-    /**
-     * Describe injury impact
-     */
     private describeInjuryImpact;
-    /**
-     * Describe weather impact
-     */
     private describeWeatherImpact;
-    /**
-     * Load historical data
-     */
-    private loadHistoricalData;
-    /**
-     * Learn from past predictions
-     */
     learnFromResult(prediction: PredictionResult, actualResult: 'home' | 'draw' | 'away', odds: number): void;
 }
 export declare function getPredictionEngine(): MLPredictionEngine;