@gotza02/sequential-thinking 10000.1.2 → 10000.1.3

package/dist/tools/sports/core/alert-manager.d.ts

@@ -1,96 +0,0 @@
-/**
- * ALERT MANAGER
- * Real-time alert system with rule engine
- */
-import { EventEmitter } from 'events';
-import type { LiveEvent } from './realtime-manager.js';
-export interface AlertRule {
-    id: string;
-    name: string;
-    type: AlertType;
-    condition: AlertCondition;
-    channels: NotificationChannel[];
-    cooldown: number;
-    enabled: boolean;
-    createdAt: number;
-    lastTriggered?: number;
-    triggerCount?: number;
-}
-export type AlertType = 'odds_drop' | 'odds_value' | 'goal' | 'red_card' | 'lineup_change' | 'match_start' | 'match_end' | 'custom';
-export type AlertCondition = OddsDropCondition | OddsValueCondition | EventCondition | CompositeCondition;
-export interface OddsDropCondition {
-    type: 'odds_drop';
-    matchId?: string;
-    team?: string;
-    threshold: number;
-    percentage: number;
-}
-export interface OddsValueCondition {
-    type: 'odds_value';
-    matchId?: string;
-    minValue: number;
-    maxOdds?: number;
-}
-export interface EventCondition {
-    type: 'event';
-    matchId?: string;
-    eventTypes: string[];
-}
-export interface CompositeCondition {
-    type: 'composite';
-    conditions: AlertCondition[];
-    operator: 'AND' | 'OR';
-}
-export interface NotificationChannel {
-    type: 'webhook' | 'email' | 'slack' | 'discord' | 'console';
-    config: Record<string, any>;
-}
-export interface AlertMessage {
-    ruleId: string;
-    ruleName: string;
-    type: AlertType;
-    severity: 'info' | 'warning' | 'critical';
-    title: string;
-    body: string;
-    data: any;
-    timestamp: number;
-}
-export declare class AlertManager extends EventEmitter {
-    private rules;
-    private checkInterval?;
-    private alertHistory;
-    private maxHistorySize;
-    constructor();
-    start(): void;
-    stop(): void;
-    addRule(rule: Omit<AlertRule, 'id' | 'createdAt' | 'triggerCount'>): AlertRule;
-    removeRule(ruleId: string): boolean;
-    getRules(): AlertRule[];
-    getRule(ruleId: string): AlertRule | undefined;
-    toggleRule(ruleId: string, enabled: boolean): boolean;
-    processEvent(event: LiveEvent): void;
-    private evaluateCondition;
-    private evaluateOddsDrop;
-    private evaluateOddsValue;
-    private evaluateEventCondition;
-    private evaluateCompositeCondition;
-    private triggerAlert;
-    private createAlertMessage;
-    private determineSeverity;
-    private formatAlertTitle;
-    private formatAlertBody;
-    private sendNotification;
-    private sendWebhook;
-    private sendSlack;
-    private sendDiscord;
-    private checkScheduledAlerts;
-    getAlertHistory(limit?: number): AlertMessage[];
-    clearHistory(): void;
-    getStats(): {
-        totalRules: number;
-        enabledRules: number;
-        totalAlerts: number;
-    };
-}
-export declare function getAlertManager(): AlertManager;
-export declare function resetAlertManager(): void;

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

@@ -1,319 +0,0 @@
-/**
- * ALERT MANAGER
- * Real-time alert system with rule engine
- */
-import { EventEmitter } from 'events';
-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;
-    alertHistory = [];
-    maxHistorySize = 1000;
-    constructor() {
-        super();
-        this.setMaxListeners(100);
-    }
-    start() {
-        if (this.checkInterval)
-            return;
-        this.checkInterval = setInterval(() => {
-            this.checkScheduledAlerts();
-        }, ALERT_CONFIG.CHECK_INTERVAL);
-        logger.info('[AlertManager] Started');
-    }
-    stop() {
-        if (this.checkInterval) {
-            clearInterval(this.checkInterval);
-            this.checkInterval = undefined;
-        }
-        logger.info('[AlertManager] Stopped');
-    }
-    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;
-    }
-    removeRule(ruleId) {
-        const removed = this.rules.delete(ruleId);
-        if (removed) {
-            logger.info(`[AlertManager] Removed rule: ${ruleId}`);
-            this.emit('rule_removed', ruleId);
-        }
-        return removed;
-    }
-    getRules() {
-        return Array.from(this.rules.values());
-    }
-    getRule(ruleId) {
-        return this.rules.get(ruleId);
-    }
-    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;
-    }
-    processEvent(event) {
-        for (const rule of this.rules.values()) {
-            if (!rule.enabled)
-                continue;
-            if (rule.lastTriggered && Date.now() - rule.lastTriggered < rule.cooldown)
-                continue;
-            if (rule.triggerCount && rule.triggerCount >= ALERT_CONFIG.MAX_ALERTS_PER_HOUR)
-                continue;
-            if (this.evaluateCondition(rule.condition, event)) {
-                this.triggerAlert(rule, 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;
-        if (condition.matchId && event.matchId !== condition.matchId)
-            return false;
-        if (newOdds > condition.threshold)
-            return false;
-        return Math.abs(change) >= condition.percentage;
-    }
-    evaluateOddsValue(condition, event) {
-        if (event.type !== 'odds_change')
-            return false;
-        const oddsEvent = event;
-        const { newOdds } = oddsEvent.data;
-        if (condition.matchId && event.matchId !== condition.matchId)
-            return false;
-        if (condition.maxOdds && newOdds > condition.maxOdds)
-            return false;
-        return true;
-    }
-    evaluateEventCondition(condition, event) {
-        if (condition.matchId && event.matchId !== condition.matchId)
-            return false;
-        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);
-    }
-    async triggerAlert(rule, event) {
-        rule.lastTriggered = Date.now();
-        rule.triggerCount = (rule.triggerCount || 0) + 1;
-        const message = this.createAlertMessage(rule, event);
-        this.alertHistory.push(message);
-        if (this.alertHistory.length > this.maxHistorySize) {
-            this.alertHistory.shift();
-        }
-        for (const channel of rule.channels) {
-            try {
-                await this.sendNotification(channel, message);
-            }
-            catch (error) {
-                logger.error(`[AlertManager] Failed to send notification: ${error}`);
-            }
-        }
-        this.emit('alert', message);
-        logger.info(`[AlertManager] Alert triggered: ${rule.name} (${rule.id})`);
-    }
-    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');
-    }
-    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':
-                logger.info(`[AlertManager] Would send email to ${channel.config.to}: ${message.title}`);
-                break;
-            case 'console':
-                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) {
-        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 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),
-                }],
-        };
-        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 payload = {
-            embeds: [{
-                    title: message.title,
-                    description: message.body,
-                    color: color,
-                    timestamp: new Date(message.timestamp).toISOString(),
-                }],
-        };
-        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);
-        }
-    }
-    checkScheduledAlerts() {
-        // Time-based alerts
-    }
-    getAlertHistory(limit) {
-        const history = [...this.alertHistory].reverse();
-        return limit ? history.slice(0, limit) : history;
-    }
-    clearHistory() {
-        this.alertHistory = [];
-    }
-    getStats() {
-        const rules = Array.from(this.rules.values());
-        return {
-            totalRules: rules.length,
-            enabledRules: rules.filter(r => r.enabled).length,
-            totalAlerts: this.alertHistory.length,
-        };
-    }
-}
-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/circuit-breaker.d.ts

@@ -1,40 +0,0 @@
-/**
- * CIRCUIT BREAKER PATTERN
- * Prevents cascading failures by stopping requests to failing services
- */
-export declare class CircuitBreaker {
-    private readonly name;
-    private readonly failureThreshold;
-    private readonly resetTimeout;
-    private readonly halfOpenMaxCalls;
-    private failures;
-    private lastFailureTime;
-    private state;
-    private successCount;
-    constructor(name: string, failureThreshold?: number, resetTimeout?: number, halfOpenMaxCalls?: number);
-    /**
-     * Execute a function with circuit breaker protection
-     */
-    execute<T>(fn: () => Promise<T>, context?: string): Promise<T>;
-    private onSuccess;
-    private onFailure;
-    getStatus(): {
-        name: string;
-        state: "closed" | "open" | "half-open";
-        failures: number;
-        lastFailure: number | null;
-    };
-}
-export declare class CircuitBreakerOpenError extends Error {
-    readonly retryAfter: number;
-    constructor(message: string, retryAfter: number);
-}
-export declare function getCircuitBreaker(name: string, config?: {
-    failureThreshold?: number;
-    resetTimeout?: number;
-}): CircuitBreaker;
-export declare function getAllCircuitBreakerStatus(): Array<{
-    name: string;
-    state: string;
-    failures: number;
-}>;

package/dist/tools/sports/core/circuit-breaker.js

@@ -1,99 +0,0 @@
-/**
- * CIRCUIT BREAKER PATTERN
- * Prevents cascading failures by stopping requests to failing services
- */
-import { logger } from '../../../utils.js';
-export class CircuitBreaker {
-    name;
-    failureThreshold;
-    resetTimeout;
-    halfOpenMaxCalls;
-    failures = 0;
-    lastFailureTime = null;
-    state = 'closed';
-    successCount = 0;
-    constructor(name, failureThreshold = 5, resetTimeout = 60000, halfOpenMaxCalls = 3) {
-        this.name = name;
-        this.failureThreshold = failureThreshold;
-        this.resetTimeout = resetTimeout;
-        this.halfOpenMaxCalls = halfOpenMaxCalls;
-    }
-    /**
-     * Execute a function with circuit breaker protection
-     */
-    async execute(fn, context) {
-        if (this.state === 'open') {
-            const timeSinceLastFailure = Date.now() - (this.lastFailureTime || 0);
-            if (timeSinceLastFailure > this.resetTimeout) {
-                logger.info(`[CircuitBreaker:${this.name}] Transitioning to HALF-OPEN`);
-                this.state = 'half-open';
-                this.successCount = 0;
-            }
-            else {
-                const remainingTime = Math.ceil((this.resetTimeout - timeSinceLastFailure) / 1000);
-                throw new CircuitBreakerOpenError(`Circuit breaker '${this.name}' is OPEN. Retry in ${remainingTime}s`, remainingTime);
-            }
-        }
-        try {
-            const result = await fn();
-            this.onSuccess();
-            return result;
-        }
-        catch (error) {
-            this.onFailure(error instanceof Error ? error : new Error(String(error)));
-            throw error;
-        }
-    }
-    onSuccess() {
-        if (this.state === 'half-open') {
-            this.successCount++;
-            if (this.successCount >= this.halfOpenMaxCalls) {
-                logger.info(`[CircuitBreaker:${this.name}] Transitioning to CLOSED`);
-                this.state = 'closed';
-                this.failures = 0;
-                this.successCount = 0;
-            }
-        }
-        else {
-            this.failures = Math.max(0, this.failures - 1);
-        }
-    }
-    onFailure(error) {
-        this.failures++;
-        this.lastFailureTime = Date.now();
-        logger.warn(`[CircuitBreaker:${this.name}] Failure ${this.failures}/${this.failureThreshold}: ${error.message}`);
-        if (this.failures >= this.failureThreshold) {
-            logger.error(`[CircuitBreaker:${this.name}] Threshold reached. Transitioning to OPEN`);
-            this.state = 'open';
-        }
-    }
-    getStatus() {
-        return {
-            name: this.name,
-            state: this.state,
-            failures: this.failures,
-            lastFailure: this.lastFailureTime,
-        };
-    }
-}
-export class CircuitBreakerOpenError extends Error {
-    retryAfter;
-    constructor(message, retryAfter) {
-        super(message);
-        this.retryAfter = retryAfter;
-        this.name = 'CircuitBreakerOpenError';
-    }
-}
-// Global circuit breakers registry
-const circuitBreakers = new Map();
-export function getCircuitBreaker(name, config) {
-    if (!circuitBreakers.has(name)) {
-        circuitBreakers.set(name, new CircuitBreaker(name, config?.failureThreshold, config?.resetTimeout));
-    }
-    return circuitBreakers.get(name);
-}
-export function getAllCircuitBreakerStatus() {
-    return Array.from(circuitBreakers.values()).map(cb => ({
-        ...cb.getStatus()
-    }));
-}

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

@@ -1,36 +0,0 @@
-/**
- * DATA QUALITY VALIDATOR
- */
-import type { Match, Team, MatchOdds } from './types.js';
-export interface DataQualityReport {
-    overall: number;
-    completeness: number;
-    accuracy: number;
-    freshness: number;
-    consistency: number;
-    issues: DataQualityIssue[];
-    warnings: DataQualityIssue[];
-    suggestions: string[];
-}
-export interface DataQualityIssue {
-    field: string;
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    suggestion?: string;
-    value?: any;
-}
-export declare class DataQualityValidator {
-    validateMatchData(data: Partial<Match>): DataQualityReport;
-    validateTeamData(data: Partial<Team>): DataQualityReport;
-    validateOddsData(odds: MatchOdds): DataQualityReport;
-    private checkCompleteness;
-    private checkAccuracy;
-    private checkFreshness;
-    private checkConsistency;
-    private generateSuggestions;
-    private calculateFreshness;
-    private calculateScore;
-    isValid(data: Partial<Match>): boolean;
-    getGrade(score: number): string;
-}
-export declare function getDataQualityValidator(): DataQualityValidator;