@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

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,79 @@
-import * as http from 'http';
-export declare function startDashboard(port: number, historyPath: string): Promise<http.Server>;
+/**
+ * DASHBOARD SERVER
+ * Real-time monitoring dashboard for the football analysis system
+ */
+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 the dashboard server
+     */
+    start(): void;
+    /**
+     * Stop the dashboard server
+     */
+    stop(): void;
+    /**
+     * Handle HTTP requests
+     */
+    private handleRequest;
+    /**
+     * Serve the dashboard HTML
+     */
+    private serveDashboard;
+    /**
+     * Serve stats JSON
+     */
+    private serveStats;
+    /**
+     * Clear cache
+     */
+    private clearCache;
+    /**
+     * Reset circuit breakers
+     */
+    private resetCircuitBreakers;
+    /**
+     * Serve alert rules
+     */
+    private serveAlertRules;
+    /**
+     * Serve alert history
+     */
+    private serveAlertHistory;
+    /**
+     * Collect all stats
+     */
+    private collectStats;
+    /**
+     * Broadcast stats to all connected clients (for WebSocket upgrade)
+     */
+    private broadcastStats;
+}
+export declare function startDashboard(port?: number): DashboardServer;
+export declare function stopDashboard(): void;