@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/alert-manager.js

@@ -0,0 +1,380 @@
+/**
+ * ALERT MANAGER
+ * Real-time alert system with rule engine and notifications
+ */
+import { EventEmitter } from 'events';
+import { logger } from '../../../utils.js';
+import { ALERT_CONFIG } from './constants.js';
+export class AlertManager extends EventEmitter {
+    rules = new Map();
+    checkInterval;
+    alertHistory = [];
+    maxHistorySize = 1000;
+    constructor() {
+        super();
+        this.setMaxListeners(100);
+    }
+    /**
+     * Start the alert manager
+     */
+    start() {
+        if (this.checkInterval)
+            return;
+        this.checkInterval = setInterval(() => {
+            this.checkScheduledAlerts();
+        }, ALERT_CONFIG.CHECK_INTERVAL);
+        logger.info('[AlertManager] Started');
+    }
+    /**
+     * Stop the alert manager
+     */
+    stop() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = undefined;
+        }
+        logger.info('[AlertManager] Stopped');
+    }
+    /**
+     * Add a new alert rule
+     */
+    addRule(rule) {
+        const newRule = {
+            ...rule,
+            id: `alert-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            createdAt: Date.now(),
+            triggerCount: 0,
+        };
+        this.rules.set(newRule.id, newRule);
+        logger.info(`[AlertManager] Added rule: ${newRule.id} (${newRule.name})`);
+        this.emit('rule_added', newRule);
+        return newRule;
+    }
+    /**
+     * Remove an alert rule
+     */
+    removeRule(ruleId) {
+        const removed = this.rules.delete(ruleId);
+        if (removed) {
+            logger.info(`[AlertManager] Removed rule: ${ruleId}`);
+            this.emit('rule_removed', ruleId);
+        }
+        return removed;
+    }
+    /**
+     * Get all rules
+     */
+    getRules() {
+        return Array.from(this.rules.values());
+    }
+    /**
+     * Get a specific rule
+     */
+    getRule(ruleId) {
+        return this.rules.get(ruleId);
+    }
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(ruleId, enabled) {
+        const rule = this.rules.get(ruleId);
+        if (rule) {
+            rule.enabled = enabled;
+            logger.info(`[AlertManager] Rule ${ruleId} ${enabled ? 'enabled' : 'disabled'}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Process a live event and check for alerts
+     */
+    processEvent(event) {
+        for (const rule of this.rules.values()) {
+            if (!rule.enabled)
+                continue;
+            // Check cooldown
+            if (rule.lastTriggered && Date.now() - rule.lastTriggered < rule.cooldown) {
+                continue;
+            }
+            // Check rate limit
+            if (rule.triggerCount && rule.triggerCount >= ALERT_CONFIG.MAX_ALERTS_PER_HOUR) {
+                continue;
+            }
+            if (this.evaluateCondition(rule.condition, event)) {
+                this.triggerAlert(rule, event);
+            }
+        }
+    }
+    /**
+     * Evaluate an alert condition against an event
+     */
+    evaluateCondition(condition, event) {
+        switch (condition.type) {
+            case 'odds_drop':
+                return this.evaluateOddsDrop(condition, event);
+            case 'odds_value':
+                return this.evaluateOddsValue(condition, event);
+            case 'event':
+                return this.evaluateEventCondition(condition, event);
+            case 'composite':
+                return this.evaluateCompositeCondition(condition, event);
+            default:
+                return false;
+        }
+    }
+    evaluateOddsDrop(condition, event) {
+        if (event.type !== 'odds_change')
+            return false;
+        const oddsEvent = event;
+        const { newOdds, change } = oddsEvent.data;
+        // Check match filter
+        if (condition.matchId && event.matchId !== condition.matchId)
+            return false;
+        // Check threshold
+        if (newOdds > condition.threshold)
+            return false;
+        // Check percentage drop
+        return Math.abs(change) >= condition.percentage;
+    }
+    evaluateOddsValue(condition, event) {
+        if (event.type !== 'odds_change')
+            return false;
+        const oddsEvent = event;
+        const { newOdds } = oddsEvent.data;
+        // Check match filter
+        if (condition.matchId && event.matchId !== condition.matchId)
+            return false;
+        // Check max odds
+        if (condition.maxOdds && newOdds > condition.maxOdds)
+            return false;
+        // Calculate value (would need probability data)
+        // For now, simplified check
+        return true;
+    }
+    evaluateEventCondition(condition, event) {
+        // Check match filter
+        if (condition.matchId && event.matchId !== condition.matchId)
+            return false;
+        // Check event type
+        return condition.eventTypes.includes(event.type);
+    }
+    evaluateCompositeCondition(condition, event) {
+        const results = condition.conditions.map(c => this.evaluateCondition(c, event));
+        return condition.operator === 'AND'
+            ? results.every(r => r)
+            : results.some(r => r);
+    }
+    /**
+     * Trigger an alert
+     */
+    async triggerAlert(rule, event) {
+        rule.lastTriggered = Date.now();
+        rule.triggerCount = (rule.triggerCount || 0) + 1;
+        const message = this.createAlertMessage(rule, event);
+        // Store in history
+        this.alertHistory.push(message);
+        if (this.alertHistory.length > this.maxHistorySize) {
+            this.alertHistory.shift();
+        }
+        // Send notifications
+        for (const channel of rule.channels) {
+            try {
+                await this.sendNotification(channel, message);
+            }
+            catch (error) {
+                logger.error(`[AlertManager] Failed to send notification: ${error}`);
+            }
+        }
+        // Emit event
+        this.emit('alert', message);
+        logger.info(`[AlertManager] Alert triggered: ${rule.name} (${rule.id})`);
+    }
+    /**
+     * Create an alert message
+     */
+    createAlertMessage(rule, event) {
+        const severity = this.determineSeverity(rule.type, event);
+        return {
+            ruleId: rule.id,
+            ruleName: rule.name,
+            type: rule.type,
+            severity,
+            title: this.formatAlertTitle(rule, event),
+            body: this.formatAlertBody(rule, event),
+            data: {
+                event,
+                rule,
+            },
+            timestamp: Date.now(),
+        };
+    }
+    determineSeverity(type, event) {
+        switch (type) {
+            case 'goal':
+            case 'red_card':
+                return 'critical';
+            case 'odds_drop':
+            case 'odds_value':
+                return 'warning';
+            default:
+                return 'info';
+        }
+    }
+    formatAlertTitle(rule, event) {
+        switch (rule.type) {
+            case 'odds_drop':
+                return `🚨 Odds Drop Alert: ${event.matchId}`;
+            case 'odds_value':
+                return `💰 Value Bet Alert: ${event.matchId}`;
+            case 'goal':
+                return `⚽ GOAL! ${event.matchId}`;
+            case 'red_card':
+                return `🔴 RED CARD! ${event.matchId}`;
+            default:
+                return `📢 ${rule.name}`;
+        }
+    }
+    formatAlertBody(rule, event) {
+        const lines = [];
+        lines.push(`Rule: ${rule.name}`);
+        lines.push(`Type: ${rule.type}`);
+        lines.push(`Match: ${event.matchId}`);
+        lines.push(`Time: ${new Date(event.timestamp).toLocaleString()}`);
+        if (event.minute) {
+            lines.push(`Minute: ${event.minute}'`);
+        }
+        if (event.data) {
+            lines.push('');
+            lines.push('Details:');
+            lines.push(JSON.stringify(event.data, null, 2));
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Send notification to a channel
+     */
+    async sendNotification(channel, message) {
+        switch (channel.type) {
+            case 'webhook':
+                await this.sendWebhook(channel.config.url, message);
+                break;
+            case 'slack':
+                await this.sendSlack(channel.config.webhook, message);
+                break;
+            case 'discord':
+                await this.sendDiscord(channel.config.webhook, message);
+                break;
+            case 'email':
+                await this.sendEmail(channel.config, message);
+                break;
+            case 'console':
+                console.log(`\n${'='.repeat(50)}`);
+                console.log(`ALERT: ${message.title}`);
+                console.log(`${'='.repeat(50)}`);
+                console.log(message.body);
+                console.log(`${'='.repeat(50)}\n`);
+                break;
+        }
+    }
+    async sendWebhook(url, message) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(message),
+        });
+        if (!response.ok) {
+            throw new Error(`Webhook failed: ${response.status}`);
+        }
+    }
+    async sendSlack(webhook, message) {
+        const emoji = message.severity === 'critical' ? '🚨' :
+            message.severity === 'warning' ? '⚠️' : 'ℹ️';
+        const payload = {
+            text: `${emoji} *${message.title}*`,
+            attachments: [{
+                    color: message.severity === 'critical' ? 'danger' :
+                        message.severity === 'warning' ? 'warning' : 'good',
+                    text: message.body,
+                    footer: 'Football Alert System',
+                    ts: Math.floor(message.timestamp / 1000),
+                }],
+        };
+        const response = await fetch(webhook, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Slack webhook failed: ${response.status}`);
+        }
+    }
+    async sendDiscord(webhook, message) {
+        const color = message.severity === 'critical' ? 0xff0000 :
+            message.severity === 'warning' ? 0xffa500 : 0x00ff00;
+        const payload = {
+            embeds: [{
+                    title: message.title,
+                    description: message.body,
+                    color: color,
+                    timestamp: new Date(message.timestamp).toISOString(),
+                }],
+        };
+        const response = await fetch(webhook, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Discord webhook failed: ${response.status}`);
+        }
+    }
+    async sendEmail(config, message) {
+        // Would integrate with email service like SendGrid, AWS SES, etc.
+        logger.info(`[AlertManager] Would send email to ${config.to}: ${message.title}`);
+    }
+    /**
+     * Check scheduled alerts (for time-based alerts)
+     */
+    checkScheduledAlerts() {
+        // Implement time-based alert checking
+        // e.g., check for upcoming matches, etc.
+    }
+    /**
+     * Get alert history
+     */
+    getAlertHistory(limit) {
+        const history = [...this.alertHistory].reverse();
+        return limit ? history.slice(0, limit) : history;
+    }
+    /**
+     * Clear alert history
+     */
+    clearHistory() {
+        this.alertHistory = [];
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const rules = Array.from(this.rules.values());
+        return {
+            totalRules: rules.length,
+            enabledRules: rules.filter(r => r.enabled).length,
+            totalAlerts: this.alertHistory.length,
+        };
+    }
+}
+// Singleton instance
+let globalAlertManager = null;
+export function getAlertManager() {
+    if (!globalAlertManager) {
+        globalAlertManager = new AlertManager();
+    }
+    return globalAlertManager;
+}
+export function resetAlertManager() {
+    if (globalAlertManager) {
+        globalAlertManager.stop();
+    }
+    globalAlertManager = null;
+}

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

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