@gotza02/sequential-thinking 10000.0.9 → 10000.1.1

package/README.md

@@ -1,52 +1,262 @@
-# @gotza02/sequential-thinking
+# Football Analysis System - Fixed & Enhanced
 
-**The Elite "Brain" for AI Agents.**
-An advanced Model Context Protocol (MCP) server that equips AI with structured reasoning, web search capabilities, and safety protocols.
+## การปรับปรุงที่ทำ (Priority 1-3)
 
-## 🚀 Features
+### Priority 1: Core Reliability
 
-### 🧠 Sequential Thinking Engine
-Forces the AI to think before acting using a strict block-based flow:
-- **Analysis:** Understand the problem deeply.
-- **Planning:** Formulate a step-by-step plan.
-- **Execution:** Perform actions (with tool support).
-- **Observation:** Analyze results (Mandatory step).
-- **Reflection:** Critique the outcome and adjust.
+#### 1.1 Circuit Breaker Pattern (`core/circuit-breaker.ts`)
+- ป้องกัน cascading failures เมื่อ API ล่ม
+- สถานะ: CLOSED → HALF-OPEN → OPEN
+- Auto-reset หลังจาก timeout
 
-### 🛡️ Coding Safety Net (New!)
-- **Auto-Backup:** Automatically creates `.bak` backups before modifying any file via `deep_code_edit`.
-- **Destructive Action Protection:** Prevents accidental data loss during code refactoring.
+#### 1.2 Retry Mechanism (`core/retry.ts`)
+- Exponential backoff with jitter
+- Configurable retry policies
+- แยก retryable vs non-retryable errors
 
-### ⚽ Sports Intelligence (Upgraded)
-- **Dual-Source Deep Dive:** Simultaneously scrapes news (BBC, Sky) and stats (Understat, FBref) for comprehensive coverage.
-- **Smart xG Extraction:** "Smart Extractor" technology specifically for Understat to get accurate Expected Goals data.
-- **Handicap Odds:** Dedicated search protocols for Asian Handicap and betting market analysis.
-- **Fallback Protection:** Intelligent warning system when API keys are missing.
+#### 1.3 Enhanced Cache (`core/cache.ts`)
+- Stale-while-revalidate pattern
+- TTL ลดลงสำหรับ live data (15 วินาที)
+- Background refresh
 
-### 🌐 Web Search Integration
-- Built-in support for **Exa**, **Brave**, **Google Search**, and **DuckDuckGo** (New!).
-- Allows the AI to "pause and research" during the thinking process.
+### Priority 2: Realtime Features
 
-## 🛠️ Recent Updates (v10000.0.7+)
+#### 2.1 Realtime Data Manager (`core/realtime-manager.ts`)
+- Polling ทุก 5-15 วินาที
+- Event-driven architecture
+- Score change detection
+- Odds change detection
 
-### 🔒 Security & Stability
-- **Enhanced Shell Protection:** Blocks dangerous shell metacharacters and risky commands (e.g., `curl | sh`, `rm -rf`).
-- **ReDoS Protection:** Validates regex patterns to prevent Denial of Service attacks.
-- **Path Safety:** Strict path traversal checks to keep operations within the project root.
-- **Resource Limits:** Enforces file size limits (10MB) for editing and parsing to prevent memory exhaustion.
+#### 2.2 Alert Manager (`core/alert-manager.ts`)
+- Rule-based alert engine
+- Multiple notification channels (webhook, slack, discord, email)
+- Cooldown และ rate limiting
+- Alert history
 
-### ⚡ Performance & Caching
-- **Graph Caching:** Implemented intelligent caching for the Knowledge Graph (max 1000 files) to speed up analysis.
-- **Rate Limiting:** Added request rate limiting for HTTP endpoints and search providers.
-- **Auto-Cleanup:** Automatically manages backup files (keeps last 10) and prunes old thought history.
+#### 2.3 Data Quality Validator (`core/data-quality.ts`)
+- Completeness, accuracy, freshness scoring
+- Issue detection
+- Improvement suggestions
 
-### ✨ New Capabilities
-- **DuckDuckGo Support:** Added a no-API-key search provider fallback.
-- **Graceful Shutdown:** Ensures data (thoughts, notes) is saved correctly when the server stops.
-- **Enhanced API:** Improved `/health` endpoint with system stats and added pagination to `/api/notes`.
+### Priority 3: Advanced Analytics
 
-## 📦 Installation
+#### 3.1 ML Prediction Engine (`core/ml-prediction.ts`)
+- Weighted factor analysis
+- Probability calculation
+- Confidence scoring
+- Over/Under & BTTS predictions
+
+#### 3.2 Historical Analyzer (`core/historical-analyzer.ts`)
+- Pattern detection
+- Trend analysis
+- Betting pattern analysis
+- Referee bias analysis
+
+#### 3.3 Dashboard Server (`dashboard/server.ts`)
+- Real-time monitoring
+- Cache statistics
+- Circuit breaker status
+- Alert management
+
+## การใช้งาน
+
+### 1. เริ่มต้นระบบ
+
+```typescript
+import { getRealtimeManager, getAlertManager, startDashboard } from './core/index.js';
+
+// Start realtime manager
+const realtime = getRealtimeManager();
+realtime.start();
+
+// Start alert manager
+const alerts = getAlertManager();
+alerts.start();
+
+// Start dashboard
+startDashboard(8080);
+```
+
+### 2. สมัครรับข้อมูลแบบ Realtime
+
+```typescript
+import { getRealtimeManager } from './core/index.js';
+
+const realtime = getRealtimeManager();
+
+// Subscribe to match events
+const unsubscribe = realtime.subscribeToMatch('match-123', (event) => {
+    console.log(`Event: ${event.type}`, event.data);
+});
+
+// Subscribe to odds changes
+realtime.subscribeToOdds('match-123', (event) => {
+    console.log(`Odds changed: ${event.data.newOdds}`);
+});
+```
+
+### 3. ตั้งค่า Alerts
+
+```typescript
+import { getAlertManager } from './core/index.js';
+
+const alerts = getAlertManager();
+
+// Add odds drop alert
+alerts.addRule({
+    name: 'Arsenal Odds Drop',
+    type: 'odds_drop',
+    condition: {
+        type: 'odds_drop',
+        matchId: 'match-123',
+        threshold: 2.0,
+        percentage: 15,
+    },
+    channels: [
+        { type: 'webhook', config: { url: 'https://your-webhook.com' } },
+        { type: 'slack', config: { webhook: 'https://hooks.slack.com/...' } },
+    ],
+    cooldown: 300000, // 5 minutes
+    enabled: true,
+});
+
+// Add goal alert
+alerts.addRule({
+    name: 'Goal Alert',
+    type: 'goal',
+    condition: {
+        type: 'event',
+        eventTypes: ['goal'],
+    },
+    channels: [{ type: 'console', config: {} }],
+    cooldown: 0,
+    enabled: true,
+});
+```
+
+### 4. ใช้ Retry และ Circuit Breaker
+
+```typescript
+import { withRetry, getCircuitBreaker } from './core/index.js';
+
+// Simple retry
+const data = await withRetry(
+    async () => fetchFromAPI(),
+    { maxAttempts: 5, initialDelay: 1000 },
+    'api-call'
+);
+
+// With circuit breaker
+const cb = getCircuitBreaker('api-football', { failureThreshold: 5 });
+const result = await cb.execute(() => fetchFromAPI());
+```
+
+### 5. ML Prediction
+
+```typescript
+import { getPredictionEngine } from './core/index.js';
+
+const ml = getPredictionEngine();
+
+const prediction = await ml.predict({
+    match: matchData,
+    homeForm: { last5: ['W', 'W', 'D', 'L', 'W'], goalsFor: 10, goalsAgainst: 5, xG: 8.5, xGA: 6.2 },
+    awayForm: { last5: ['L', 'D', 'W', 'L', 'L'], goalsFor: 6, goalsAgainst: 12, xG: 7.1, xGA: 10.5 },
+    h2h: headToHeadData,
+    homeStats: homeTeamStats,
+    awayStats: awayTeamStats,
+    injuries: { home: { keyPlayers: 1, total: 3 }, away: { keyPlayers: 0, total: 2 } },
+});
+
+console.log(`Home: ${prediction.homeWin * 100}%`);
+console.log(`Draw: ${prediction.draw * 100}%`);
+console.log(`Away: ${prediction.awayWin * 100}%`);
+console.log(`Confidence: ${prediction.confidence}%`);
+```
+
+### 6. Historical Analysis
+
+```typescript
+import { getHistoricalAnalyzer } from './core/index.js';
+
+const analyzer = getHistoricalAnalyzer();
+
+// Analyze team performance
+const performance = analyzer.analyzeTeamPerformance('team-123');
+
+// Find patterns
+const patterns = analyzer.findBettingPatterns({
+    league: 'Premier League',
+    dateFrom: new Date('2024-01-01'),
+});
+
+// Analyze trends
+const trends = analyzer.analyzeTrends('team-123', 10);
+```
+
+### 7. Data Quality Check
+
+```typescript
+import { getDataQualityValidator } from './core/index.js';
+
+const validator = getDataQualityValidator();
+
+const report = validator.validateMatchData(matchData);
+
+console.log(`Quality Score: ${report.overall}/100`);
+console.log(`Grade: ${validator.getGrade(report.overall)}`);
+
+if (report.issues.length > 0) {
+    console.log('Issues:', report.issues);
+}
+```
+
+## Dashboard
+
+เปิด browser ไปที่ `http://localhost:8080` เพื่อดู:
+- System status
+- Cache statistics
+- Circuit breaker status
+- Realtime data
+- Alert system
+
+## Environment Variables
 
 ```bash
-npx -y @gotza02/sequential-thinking
-```
+# API Keys
+API_FOOTBALL_KEY=your_key
+FOOTBALL_DATA_KEY=your_key
+ODDS_API_KEY=your_key
+SPORTRADAR_KEY=your_key
+
+# Cache
+SPORTS_CACHE_TTL=300000
+SPORTS_CACHE_PATH=.sports_cache.json
+
+# Dashboard
+DASHBOARD_PORT=8080
+```
+
+## ไฟล์ที่สร้างใหม่
+
+```
+src/tools/sports/core/
+├── circuit-breaker.ts    # Circuit breaker pattern
+├── retry.ts              # Retry mechanism
+├── cache.ts              # Enhanced cache (modified)
+├── realtime-manager.ts   # Realtime data manager
+├── alert-manager.ts      # Alert system
+├── data-quality.ts       # Data quality validator
+├── ml-prediction.ts      # ML prediction engine
+├── historical-analyzer.ts # Historical analysis
+├── types.ts              # Type definitions (updated)
+├── constants.ts          # Constants (updated)
+└── index.ts              # Exports
+
+src/dashboard/
+└── server.ts             # Dashboard server
+```
+
+## License
+
+MIT

package/dist/dashboard/server.d.ts

@@ -1,2 +1,45 @@
-import * as http from 'http';
-export declare function startDashboard(port: number, historyPath: string): Promise<http.Server>;
+/**
+ * DASHBOARD SERVER
+ */
+export interface DashboardStats {
+    cache: {
+        size: number;
+        maxSize: number;
+        hits: number;
+        breakdown: Record<string, number>;
+    };
+    circuitBreakers: Array<{
+        name: string;
+        state: string;
+        failures: number;
+    }>;
+    realtime: {
+        isRunning: boolean;
+        liveMatches: number;
+        subscribers: number;
+    };
+    alerts: {
+        totalRules: number;
+        enabledRules: number;
+        totalAlerts: number;
+    };
+}
+export declare class DashboardServer {
+    private server;
+    private port;
+    private updateInterval;
+    constructor(port?: number);
+    start(): void;
+    stop(): void;
+    private handleRequest;
+    private serveDashboard;
+    private serveStats;
+    private clearCache;
+    private resetCircuitBreakers;
+    private serveAlertRules;
+    private serveAlertHistory;
+    private collectStats;
+    private broadcastStats;
+}
+export declare function startDashboard(port?: number): DashboardServer;
+export declare function stopDashboard(): void;

package/dist/dashboard/server.js

@@ -1,67 +1,253 @@
-import * as http from 'http';
-import * as fs from 'fs';
-import * as path 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);
-                });
-            }
-            else {
-                res.writeHead(404);
-                res.end('Not found');
-            }
+/**
+ * DASHBOARD SERVER
+ */
+import { createServer } from 'http';
+import { CacheService } 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';
+// Simple logger fallback
+const logger = {
+    info: (...args) => console.log('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    debug: (...args) => { }
+};
+export class DashboardServer {
+    server = null;
+    port;
+    updateInterval = null;
+    constructor(port = 8080) {
+        this.port = port;
+    }
+    start() {
+        if (this.server)
+            return;
+        this.server = createServer((req, res) => {
+            this.handleRequest(req, res);
         });
-        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);
-            }
-            else {
-                console.error('[Dashboard] Server error:', e);
-                reject(e);
-            }
+        this.server.listen(this.port, () => {
+            logger.info(`[Dashboard] Server running on http://localhost:${this.port}`);
         });
-        server.listen(port, () => {
-            console.error(`[Dashboard] 📊 Dashboard running at http://localhost:${port}`);
-            resolve(server);
-        });
-    });
+        this.updateInterval = setInterval(() => {
+            this.broadcastStats();
+        }, 5000);
+    }
+    stop() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+            logger.info('[Dashboard] Server stopped');
+        }
+    }
+    handleRequest(req, res) {
+        const url = new URL(req.url, `http://localhost:${this.port}`);
+        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;
+        }
+        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' }));
+        }
+    }
+    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; }
+        .cb-closed { color: #22c55e; }
+        .cb-open { color: #ef4444; }
+        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; } }
+    </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>
+            <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>
+        <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>
+        </div>
+    </div>
+    <script>
+        async function fetchStats() {
+            try {
+                const response = await fetch('/api/stats');
+                const stats = await response.json();
+                updateDashboard(stats);
+            } catch (error) { console.error('Failed to fetch stats:', error); }
+        }
+        function updateDashboard(stats) {
+            document.getElementById('last-update').textContent = new Date().toLocaleTimeString();
+            document.getElementById('cache-size').textContent = stats.cache.size + ' / ' + stats.cache.maxSize;
+            document.getElementById('cache-hits').textContent = stats.cache.hits;
+            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('');
+            }
+            document.getElementById('live-matches').textContent = stats.realtime.liveMatches;
+            document.getElementById('subscribers').textContent = stats.realtime.subscribers;
+            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' }); fetchStats(); } catch (e) { alert('Failed'); }
+        }
+        async function resetCircuitBreakers() {
+            try { await fetch('/api/circuit-breakers/reset', { method: 'POST' }); fetchStats(); } catch (e) { alert('Failed'); }
+        }
+        fetchStats();
+        setInterval(fetchStats, 5000);
+    </script>
+</body>
+</html>`;
+        res.setHeader('Content-Type', 'text/html');
+        res.writeHead(200);
+        res.end(html);
+    }
+    serveStats(res) {
+        const stats = this.collectStats();
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify(stats));
+    }
+    clearCache(res) {
+        const cache = new CacheService();
+        cache.clear();
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({ success: true, message: 'Cache cleared' }));
+    }
+    resetCircuitBreakers(res) {
+        res.setHeader('Content-Type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({ success: true, message: 'Circuit breakers will reset automatically' }));
+    }
+    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));
+    }
+    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));
+    }
+    collectStats() {
+        const cache = new CacheService();
+        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,
+                liveMatches: realtimeManager.getLiveMatches().length,
+                subscribers: realtimeManager.listenerCount('event'),
+            },
+            alerts: alertManager.getStats(),
+        };
+    }
+    broadcastStats() {
+        // WebSocket broadcast would go here
+    }
+}
+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;
+    }
 }