@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/dashboard/server.js

@@ -1,67 +1,472 @@
-import * as http from 'http';
-import * as fs from 'fs';
-import * as path from 'path';
+/**
+ * DASHBOARD SERVER
+ * Real-time monitoring dashboard for the football analysis system
+ */
+import { createServer } from 'http';
+import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export function startDashboard(port, historyPath) {
-    return new Promise((resolve, reject) => {
-        const server = http.createServer((req, res) => {
-            // Handle CORS
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET');
-            if (req.url === '/') {
-                // Serve index.html
-                const indexPath = path.join(__dirname, 'index.html');
-                fs.readFile(indexPath, (err, data) => {
-                    if (err) {
-                        res.writeHead(500);
-                        res.end('Error loading dashboard');
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(data);
-                });
-            }
-            else if (req.url === '/api/history') {
-                // Serve thoughts_history.json
-                fs.readFile(historyPath, (err, data) => {
-                    if (err) {
-                        // Try .tmp if main file is locked/missing (rare fallback)
-                        fs.readFile(historyPath + '.tmp', (err2, data2) => {
-                            if (err2) {
-                                res.writeHead(500);
-                                res.end(JSON.stringify({ error: 'History not found' }));
-                                return;
-                            }
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(data2);
-                        });
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(data);
-                });
+import { logger } from '../utils.js';
+import { getGlobalCache } from '../tools/sports/core/cache.js';
+import { getAllCircuitBreakerStatus } from '../tools/sports/core/circuit-breaker.js';
+import { getRealtimeManager } from '../tools/sports/core/realtime-manager.js';
+import { getAlertManager } from '../tools/sports/core/alert-manager.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class DashboardServer {
+    server = null;
+    port;
+    updateInterval = null;
+    constructor(port = 8080) {
+        this.port = port;
+    }
+    /**
+     * Start the dashboard server
+     */
+    start() {
+        if (this.server)
+            return;
+        this.server = createServer((req, res) => {
+            this.handleRequest(req, res);
+        });
+        this.server.listen(this.port, () => {
+            logger.info(`[Dashboard] Server running on http://localhost:${this.port}`);
+        });
+        // Start stats update interval
+        this.updateInterval = setInterval(() => {
+            this.broadcastStats();
+        }, 5000);
+    }
+    /**
+     * Stop the dashboard server
+     */
+    stop() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+            logger.info('[Dashboard] Server stopped');
+        }
+    }
+    /**
+     * Handle HTTP requests
+     */
+    handleRequest(req, res) {
+        const url = new URL(req.url, `http://localhost:${this.port}`);
+        // Enable CORS
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        // Route handling
+        if (url.pathname === '/' || url.pathname === '/index.html') {
+            this.serveDashboard(res);
+        }
+        else if (url.pathname === '/api/stats') {
+            this.serveStats(res);
+        }
+        else if (url.pathname === '/api/cache/clear') {
+            this.clearCache(res);
+        }
+        else if (url.pathname === '/api/circuit-breakers/reset') {
+            this.resetCircuitBreakers(res);
+        }
+        else if (url.pathname === '/api/alerts/rules') {
+            this.serveAlertRules(res);
+        }
+        else if (url.pathname === '/api/alerts/history') {
+            this.serveAlertHistory(res);
+        }
+        else {
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+    }
+    /**
+     * Serve the dashboard HTML
+     */
+    serveDashboard(res) {
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Football Analysis Dashboard</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0f172a;
+            color: #e2e8f0;
+            padding: 20px;
+        }
+        .header {
+            text-align: center;
+            padding: 20px;
+            margin-bottom: 30px;
+        }
+        .header h1 {
+            font-size: 2.5em;
+            background: linear-gradient(135deg, #3b82f6, #8b5cf6);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        .card {
+            background: #1e293b;
+            border-radius: 12px;
+            padding: 20px;
+            border: 1px solid #334155;
+        }
+        .card h2 {
+            font-size: 1.2em;
+            margin-bottom: 15px;
+            color: #94a3b8;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        .stat {
+            display: flex;
+            justify-content: space-between;
+            padding: 10px 0;
+            border-bottom: 1px solid #334155;
+        }
+        .stat:last-child { border-bottom: none; }
+        .stat-value {
+            font-weight: bold;
+            color: #3b82f6;
+        }
+        .status {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 0.85em;
+            font-weight: 500;
+        }
+        .status-online { background: #22c55e; color: #064e3b; }
+        .status-offline { background: #ef4444; color: #7f1d1d; }
+        .status-warning { background: #f59e0b; color: #78350f; }
+        .cb-closed { color: #22c55e; }
+        .cb-open { color: #ef4444; }
+        .cb-half { color: #f59e0b; }
+        button {
+            background: #3b82f6;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 0.9em;
+            margin-top: 10px;
+        }
+        button:hover { background: #2563eb; }
+        .refresh-indicator {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            width: 10px;
+            height: 10px;
+            background: #22c55e;
+            border-radius: 50%;
+            animation: pulse 2s infinite;
+        }
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+        .alerts-list {
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        .alert-item {
+            padding: 8px;
+            margin: 5px 0;
+            background: #334155;
+            border-radius: 6px;
+            font-size: 0.85em;
+        }
+        .alert-critical { border-left: 3px solid #ef4444; }
+        .alert-warning { border-left: 3px solid #f59e0b; }
+        .alert-info { border-left: 3px solid #3b82f6; }
+    </style>
+</head>
+<body>
+    <div class="refresh-indicator"></div>
+    
+    <div class="header">
+        <h1>⚽ Football Analysis Dashboard</h1>
+        <p>Real-time System Monitoring</p>
+    </div>
+
+    <div class="grid">
+        <div class="card">
+            <h2>📊 System Status</h2>
+            <div class="stat">
+                <span>Realtime Manager</span>
+                <span class="status status-online" id="realtime-status">Online</span>
+            </div>
+            <div class="stat">
+                <span>Alert Manager</span>
+                <span class="status status-online" id="alert-status">Online</span>
+            </div>
+            <div class="stat">
+                <span>Cache Service</span>
+                <span class="status status-online" id="cache-status">Online</span>
+            </div>
+            <div class="stat">
+                <span>Last Update</span>
+                <span id="last-update">-</span>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>💾 Cache Statistics</h2>
+            <div class="stat">
+                <span>Cache Size</span>
+                <span class="stat-value" id="cache-size">0 / 2000</span>
+            </div>
+            <div class="stat">
+                <span>Cache Hits</span>
+                <span class="stat-value" id="cache-hits">0</span>
+            </div>
+            <div class="stat">
+                <span>Hit Rate</span>
+                <span class="stat-value" id="hit-rate">0%</span>
+            </div>
+            <button onclick="clearCache()">Clear Cache</button>
+        </div>
+
+        <div class="card">
+            <h2>🔒 Circuit Breakers</h2>
+            <div id="circuit-breakers">
+                <div class="stat">
+                    <span>No circuit breakers active</span>
+                </div>
+            </div>
+            <button onclick="resetCircuitBreakers()">Reset All</button>
+        </div>
+
+        <div class="card">
+            <h2>⚡ Realtime Data</h2>
+            <div class="stat">
+                <span>Live Matches</span>
+                <span class="stat-value" id="live-matches">0</span>
+            </div>
+            <div class="stat">
+                <span>Active Subscribers</span>
+                <span class="stat-value" id="subscribers">0</span>
+            </div>
+            <div class="stat">
+                <span>Events/Minute</span>
+                <span class="stat-value" id="events-rate">0</span>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>🚨 Alert System</h2>
+            <div class="stat">
+                <span>Total Rules</span>
+                <span class="stat-value" id="total-rules">0</span>
+            </div>
+            <div class="stat">
+                <span>Enabled Rules</span>
+                <span class="stat-value" id="enabled-rules">0</span>
+            </div>
+            <div class="stat">
+                <span>Total Alerts</span>
+                <span class="stat-value" id="total-alerts">0</span>
+            </div>
+            <button onclick="viewAlertRules()">View Rules</button>
+        </div>
+
+        <div class="card">
+            <h2>🔔 Recent Alerts</h2>
+            <div class="alerts-list" id="alerts-list">
+                <div class="alert-item">No recent alerts</div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let stats = {};
+
+        async function fetchStats() {
+            try {
+                const response = await fetch('/api/stats');
+                stats = await response.json();
+                updateDashboard();
+            } catch (error) {
+                console.error('Failed to fetch stats:', error);
             }
-            else {
-                res.writeHead(404);
-                res.end('Not found');
+        }
+
+        function updateDashboard() {
+            document.getElementById('last-update').textContent = new Date().toLocaleTimeString();
+            
+            // Cache stats
+            document.getElementById('cache-size').textContent = 
+                \`\${stats.cache.size} / \${stats.cache.maxSize}\`;
+            document.getElementById('cache-hits').textContent = stats.cache.hits;
+            
+            // Circuit breakers
+            const cbContainer = document.getElementById('circuit-breakers');
+            if (stats.circuitBreakers.length > 0) {
+                cbContainer.innerHTML = stats.circuitBreakers.map(cb => \`
+                    <div class="stat">
+                        <span>\${cb.name}</span>
+                        <span class="cb-\${cb.state}">\${cb.state.toUpperCase()}</span>
+                    </div>
+                \`).join('');
             }
-        });
-        server.on('error', (e) => {
-            if (e.code === 'EADDRINUSE') {
-                console.error(`[Dashboard] Port ${port} is busy. Trying ${port + 1}...`);
-                // Recursive retry
-                startDashboard(port + 1, historyPath).then(resolve).catch(reject);
+            
+            // Realtime
+            document.getElementById('live-matches').textContent = stats.realtime.liveMatches;
+            document.getElementById('subscribers').textContent = stats.realtime.subscribers;
+            
+            // Alerts
+            document.getElementById('total-rules').textContent = stats.alerts.totalRules;
+            document.getElementById('enabled-rules').textContent = stats.alerts.enabledRules;
+            document.getElementById('total-alerts').textContent = stats.alerts.totalAlerts;
+        }
+
+        async function clearCache() {
+            try {
+                await fetch('/api/cache/clear', { method: 'POST' });
+                alert('Cache cleared');
+                fetchStats();
+            } catch (error) {
+                alert('Failed to clear cache');
             }
-            else {
-                console.error('[Dashboard] Server error:', e);
-                reject(e);
+        }
+
+        async function resetCircuitBreakers() {
+            try {
+                await fetch('/api/circuit-breakers/reset', { method: 'POST' });
+                alert('Circuit breakers reset');
+                fetchStats();
+            } catch (error) {
+                alert('Failed to reset circuit breakers');
             }
-        });
-        server.listen(port, () => {
-            console.error(`[Dashboard] 📊 Dashboard running at http://localhost:${port}`);
-            resolve(server);
-        });
-    });
+        }
+
+        function viewAlertRules() {
+            window.open('/api/alerts/rules', '_blank');
+        }
+
+        // Fetch stats every 5 seconds
+        fetchStats();
+        setInterval(fetchStats, 5000);
+    </script>
+</body>
+</html>`;
+        res.setHeader('Content-Type', 'text/html');
+        res.writeHead(200);
+        res.end(html);
+    }
+    /**
+     * Serve stats JSON
+     */
+    serveStats(res) {
+        const stats = this.collectStats();
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify(stats));
+    }
+    /**
+     * Clear cache
+     */
+    clearCache(res) {
+        const cache = getGlobalCache();
+        cache.clear();
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({ success: true, message: 'Cache cleared' }));
+    }
+    /**
+     * Reset circuit breakers
+     */
+    resetCircuitBreakers(res) {
+        // Circuit breakers auto-reset based on timeout
+        // This endpoint just returns success
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({ success: true, message: 'Circuit breakers will reset automatically' }));
+    }
+    /**
+     * Serve alert rules
+     */
+    serveAlertRules(res) {
+        const alertManager = getAlertManager();
+        const rules = alertManager.getRules();
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify(rules, null, 2));
+    }
+    /**
+     * Serve alert history
+     */
+    serveAlertHistory(res) {
+        const alertManager = getAlertManager();
+        const history = alertManager.getAlertHistory(50);
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify(history, null, 2));
+    }
+    /**
+     * Collect all stats
+     */
+    collectStats() {
+        const cache = getGlobalCache();
+        const cacheStats = cache.getStats();
+        const realtimeManager = getRealtimeManager();
+        const alertManager = getAlertManager();
+        return {
+            cache: {
+                size: cacheStats.size,
+                maxSize: cacheStats.maxSize,
+                hits: cacheStats.hits,
+                breakdown: cache.getBreakdown(),
+            },
+            circuitBreakers: getAllCircuitBreakerStatus(),
+            realtime: {
+                isRunning: true, // Would check actual state
+                liveMatches: realtimeManager.getLiveMatches().length,
+                subscribers: realtimeManager.listenerCount('event'),
+            },
+            alerts: alertManager.getStats(),
+        };
+    }
+    /**
+     * Broadcast stats to all connected clients (for WebSocket upgrade)
+     */
+    broadcastStats() {
+        // In a full implementation, this would push to WebSocket clients
+        // For now, clients poll via HTTP
+    }
+}
+// Singleton instance
+let globalDashboardServer = null;
+export function startDashboard(port) {
+    if (!globalDashboardServer) {
+        globalDashboardServer = new DashboardServer(port);
+        globalDashboardServer.start();
+    }
+    return globalDashboardServer;
+}
+export function stopDashboard() {
+    if (globalDashboardServer) {
+        globalDashboardServer.stop();
+        globalDashboardServer = null;
+    }
 }

package/dist/index.js

@@ -29,10 +29,7 @@ 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
-const historyPath = process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json';
-startDashboard(3001, historyPath).catch(err => {
-    console.error("[Dashboard] Failed to start:", err);
-});
+startDashboard(3001);
 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/alert-manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * ALERT MANAGER
+ * Real-time alert system with rule engine and notifications
+ */
+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 the alert manager
+     */
+    start(): void;
+    /**
+     * Stop the alert manager
+     */
+    stop(): void;
+    /**
+     * Add a new alert rule
+     */
+    addRule(rule: Omit<AlertRule, 'id' | 'createdAt' | 'triggerCount'>): AlertRule;
+    /**
+     * Remove an alert rule
+     */
+    removeRule(ruleId: string): boolean;
+    /**
+     * Get all rules
+     */
+    getRules(): AlertRule[];
+    /**
+     * Get a specific rule
+     */
+    getRule(ruleId: string): AlertRule | undefined;
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(ruleId: string, enabled: boolean): boolean;
+    /**
+     * Process a live event and check for alerts
+     */
+    processEvent(event: LiveEvent): void;
+    /**
+     * Evaluate an alert condition against an event
+     */
+    private evaluateCondition;
+    private evaluateOddsDrop;
+    private evaluateOddsValue;
+    private evaluateEventCondition;
+    private evaluateCompositeCondition;
+    /**
+     * Trigger an alert
+     */
+    private triggerAlert;
+    /**
+     * Create an alert message
+     */
+    private createAlertMessage;
+    private determineSeverity;
+    private formatAlertTitle;
+    private formatAlertBody;
+    /**
+     * Send notification to a channel
+     */
+    private sendNotification;
+    private sendWebhook;
+    private sendSlack;
+    private sendDiscord;
+    private sendEmail;
+    /**
+     * Check scheduled alerts (for time-based alerts)
+     */
+    private checkScheduledAlerts;
+    /**
+     * Get alert history
+     */
+    getAlertHistory(limit?: number): AlertMessage[];
+    /**
+     * Clear alert history
+     */
+    clearHistory(): void;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalRules: number;
+        enabledRules: number;
+        totalAlerts: number;
+    };
+}
+export declare function getAlertManager(): AlertManager;
+export declare function resetAlertManager(): void;