@gotza02/sequential-thinking 10000.1.0 → 10000.1.2

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

@@ -1,10 +1,16 @@
 /**
  * ALERT MANAGER
- * Real-time alert system with rule engine and notifications
+ * Real-time alert system with rule engine
  */
 import { EventEmitter } from 'events';
-import { logger } from '../../../utils.js';
 import { ALERT_CONFIG } from './constants.js';
+// 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 AlertManager extends EventEmitter {
     rules = new Map();
     checkInterval;
@@ -14,9 +20,6 @@ export class AlertManager extends EventEmitter {
         super();
         this.setMaxListeners(100);
     }
-    /**
-     * Start the alert manager
-     */
     start() {
         if (this.checkInterval)
             return;
@@ -25,9 +28,6 @@ export class AlertManager extends EventEmitter {
         }, ALERT_CONFIG.CHECK_INTERVAL);
         logger.info('[AlertManager] Started');
     }
-    /**
-     * Stop the alert manager
-     */
     stop() {
         if (this.checkInterval) {
             clearInterval(this.checkInterval);
@@ -35,9 +35,6 @@ export class AlertManager extends EventEmitter {
         }
         logger.info('[AlertManager] Stopped');
     }
-    /**
-     * Add a new alert rule
-     */
     addRule(rule) {
         const newRule = {
             ...rule,
@@ -50,9 +47,6 @@ export class AlertManager extends EventEmitter {
         this.emit('rule_added', newRule);
         return newRule;
     }
-    /**
-     * Remove an alert rule
-     */
     removeRule(ruleId) {
         const removed = this.rules.delete(ruleId);
         if (removed) {
@@ -61,21 +55,12 @@ export class AlertManager extends EventEmitter {
         }
         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) {
@@ -85,29 +70,19 @@ export class AlertManager extends EventEmitter {
         }
         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) {
+            if (rule.lastTriggered && Date.now() - rule.lastTriggered < rule.cooldown)
                 continue;
-            }
-            // Check rate limit
-            if (rule.triggerCount && rule.triggerCount >= ALERT_CONFIG.MAX_ALERTS_PER_HOUR) {
+            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':
@@ -127,13 +102,10 @@ export class AlertManager extends EventEmitter {
             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) {
@@ -141,21 +113,15 @@ export class AlertManager extends EventEmitter {
             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) {
@@ -164,19 +130,14 @@ export class AlertManager extends EventEmitter {
             ? 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);
@@ -185,13 +146,9 @@ export class AlertManager extends EventEmitter {
                 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 {
@@ -201,10 +158,7 @@ export class AlertManager extends EventEmitter {
             severity,
             title: this.formatAlertTitle(rule, event),
             body: this.formatAlertBody(rule, event),
-            data: {
-                event,
-                rule,
-            },
+            data: { event, rule },
             timestamp: Date.now(),
         };
     }
@@ -223,15 +177,15 @@ export class AlertManager extends EventEmitter {
     formatAlertTitle(rule, event) {
         switch (rule.type) {
             case 'odds_drop':
-                return `🚨 Odds Drop Alert: ${event.matchId}`;
+                return `Odds Drop Alert: ${event.matchId}`;
             case 'odds_value':
-                return `💰 Value Bet Alert: ${event.matchId}`;
+                return `Value Bet Alert: ${event.matchId}`;
             case 'goal':
-                return `⚽ GOAL! ${event.matchId}`;
+                return `GOAL! ${event.matchId}`;
             case 'red_card':
-                return `🔴 RED CARD! ${event.matchId}`;
+                return `RED CARD! ${event.matchId}`;
             default:
-                return `📢 ${rule.name}`;
+                return rule.name;
         }
     }
     formatAlertBody(rule, event) {
@@ -240,9 +194,8 @@ export class AlertManager extends EventEmitter {
         lines.push(`Type: ${rule.type}`);
         lines.push(`Match: ${event.matchId}`);
         lines.push(`Time: ${new Date(event.timestamp).toLocaleString()}`);
-        if (event.minute) {
+        if (event.minute)
             lines.push(`Minute: ${event.minute}'`);
-        }
         if (event.data) {
             lines.push('');
             lines.push('Details:');
@@ -250,9 +203,6 @@ export class AlertManager extends EventEmitter {
         }
         return lines.join('\n');
     }
-    /**
-     * Send notification to a channel
-     */
     async sendNotification(channel, message) {
         switch (channel.type) {
             case 'webhook':
@@ -265,52 +215,57 @@ export class AlertManager extends EventEmitter {
                 await this.sendDiscord(channel.config.webhook, message);
                 break;
             case 'email':
-                await this.sendEmail(channel.config, message);
+                logger.info(`[AlertManager] Would send email to ${channel.config.to}: ${message.title}`);
                 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`);
+                console.error(`\n${'='.repeat(50)}`);
+                console.error(`ALERT: ${message.title}`);
+                console.error(`${'='.repeat(50)}`);
+                console.error(message.body);
+                console.error(`${'='.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}`);
+        try {
+            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}`);
+        }
+        catch (error) {
+            logger.error('[AlertManager] Webhook failed:', error);
         }
     }
     async sendSlack(webhook, message) {
-        const emoji = message.severity === 'critical' ? '🚨' :
-            message.severity === 'warning' ? '⚠️' : 'ℹ️';
+        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',
+                    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}`);
+        try {
+            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}`);
+        }
+        catch (error) {
+            logger.error('[AlertManager] Slack webhook failed:', error);
         }
     }
     async sendDiscord(webhook, message) {
-        const color = message.severity === 'critical' ? 0xff0000 :
-            message.severity === 'warning' ? 0xffa500 : 0x00ff00;
+        const color = message.severity === 'critical' ? 0xff0000 : message.severity === 'warning' ? 0xffa500 : 0x00ff00;
         const payload = {
             embeds: [{
                     title: message.title,
@@ -319,42 +274,29 @@ export class AlertManager extends EventEmitter {
                     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}`);
+        try {
+            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}`);
+        }
+        catch (error) {
+            logger.error('[AlertManager] Discord webhook failed:', error);
         }
     }
-    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.
+        // Time-based alerts
     }
-    /**
-     * 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 {
@@ -364,17 +306,14 @@ export class AlertManager extends EventEmitter {
         };
     }
 }
-// Singleton instance
 let globalAlertManager = null;
 export function getAlertManager() {
-    if (!globalAlertManager) {
+    if (!globalAlertManager)
         globalAlertManager = new AlertManager();
-    }
     return globalAlertManager;
 }
 export function resetAlertManager() {
-    if (globalAlertManager) {
+    if (globalAlertManager)
         globalAlertManager.stop();
-    }
     globalAlertManager = null;
 }

package/dist/tools/sports/core/data-quality.d.ts

@@ -1,6 +1,5 @@
 /**
  * DATA QUALITY VALIDATOR
- * Validates and scores data quality for football matches
  */
 import type { Match, Team, MatchOdds } from './types.js';
 export interface DataQualityReport {
@@ -21,60 +20,17 @@ export interface DataQualityIssue {
     value?: any;
 }
 export declare class DataQualityValidator {
-    private knownTeams;
-    private knownLeagues;
-    constructor();
-    /**
-     * Validate match data and return quality report
-     */
     validateMatchData(data: Partial<Match>): DataQualityReport;
-    /**
-     * Validate team data
-     */
     validateTeamData(data: Partial<Team>): DataQualityReport;
-    /**
-     * Validate odds data
-     */
     validateOddsData(odds: MatchOdds): DataQualityReport;
-    /**
-     * Check data completeness
-     */
     private checkCompleteness;
-    /**
-     * Check data accuracy
-     */
     private checkAccuracy;
-    /**
-     * Check data freshness
-     */
     private checkFreshness;
-    /**
-     * Check data consistency
-     */
     private checkConsistency;
-    /**
-     * Validate team stats
-     */
-    private validateTeamStats;
-    /**
-     * Generate improvement suggestions
-     */
     private generateSuggestions;
-    /**
-     * Calculate freshness score from timestamp
-     */
     private calculateFreshness;
-    /**
-     * Calculate overall score from issues and warnings
-     */
     private calculateScore;
-    /**
-     * Quick validation - returns true if data passes basic checks
-     */
     isValid(data: Partial<Match>): boolean;
-    /**
-     * Get quality grade (A-F)
-     */
     getGrade(score: number): string;
 }
 export declare function getDataQualityValidator(): DataQualityValidator;