Initial commit: NBA Sage Predictor for Hugging Face Spaces (with LFS for large files)

.dockerignore

@@ -0,0 +1,67 @@
+# Virtual environments
+venv/
+.venv/
+env/
+.env/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Node modules (will be rebuilt in container)
+node_modules/
+web/node_modules/
+
+# Build outputs (will be rebuilt)
+web/dist/
+dist/
+build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Logs
+*.log
+logs/
+
+# Test files
+tests/
+test_*.py
+*_test.py
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Local config
+.env
+.env.local
+*.local
+
+# Graphs and temporary files
+graphs/
+
+# App folder (Streamlit - not needed for this deployment)
+app/
+
+# Large raw data files not needed at runtime
+data/games_details.csv
+data/nba_games.csv
+data/players.csv
+data/ranking.csv
+data/teams.csv
+data/raw/
+data/api_data/

.gitattributes

@@ -0,0 +1,3 @@
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+data/api_data/** !text !filter !merge !diff

.gitignore

@@ -0,0 +1,64 @@
+# Virtual environments
+venv/
+.venv/
+env/
+.env/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Node modules
+node_modules/
+
+# Build outputs
+web/dist/
+dist/
+build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Test files
+tests/
+test_*.py
+*_test.py
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Local config
+.env.local
+*.local
+
+# Graphs
+graphs/
+
+# Large data files - keep only processed and models
+data/games_details.csv
+data/nba_games.csv
+data/players.csv
+data/ranking.csv
+data/teams.csv
+data/raw/
+data/api_data/
+
+# App folder (optional Streamlit)
+app/
+
+# Package lock (let npm generate fresh)
+web/package-lock.json

Dockerfile

@@ -0,0 +1,71 @@
+# syntax=docker/dockerfile:1
+
+# ============================================================================
+# NBA Sage Predictor - Hugging Face Spaces Docker Image
+# ============================================================================
+
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    git \
+    build-essential \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the web frontend package files
+COPY web/package*.json ./web/
+WORKDIR /app/web
+
+# Install Node dependencies
+RUN npm ci
+
+# Copy web source files and build
+COPY web/ .
+RUN npm run build
+
+# Move back to app root
+WORKDIR /app
+
+# Copy built frontend to static folder
+RUN mkdir -p static && cp -r web/dist/* static/
+
+# Copy Python source code
+COPY src/ ./src/
+COPY api/ ./api/
+COPY server.py .
+
+# Copy data and models
+COPY data/processed/ ./data/processed/
+COPY models/ ./models/
+
+# Create data directories for runtime
+RUN mkdir -p data/predictions data/injuries
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/api/health || exit 1
+
+# Run the production server
+CMD ["python", "server.py"]

README.md

@@ -0,0 +1,33 @@
+---
+title: NBA Sage Predictor
+emoji: 🏀
+colorFrom: blue
+colorTo: yellow
+sdk: docker
+pinned: true
+license: mit
+---
+
+# NBA Sage - ML Prediction System
+
+An advanced NBA game prediction system using machine learning and ELO ratings.
+
+## Features
+
+- 🎮 **Live Game Tracking** - Real-time scores and predictions
+- 🎯 **Game Predictions** - ML-powered win probability predictions
+- 📊 **Model Accuracy** - Track prediction performance
+- 🏆 **MVP Race** - Current MVP candidate rankings
+- 👑 **Championship Odds** - Team championship probability rankings
+- ⚔️ **Head to Head** - Compare any two teams
+
+## Tech Stack
+
+- **Frontend**: React + Vite
+- **Backend**: Flask API
+- **ML**: XGBoost, LightGBM, ELO Rating System
+- **Data**: NBA API
+
+## Author
+
+Built with ❤️ for NBA fans and data enthusiasts.

api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API package for NBA ML Predictor
+"""

api/api.py

@@ -0,0 +1,393 @@
+"""
+NBA ML Prediction System - Flask Backend
+=========================================
+REST API for the React frontend.
+"""
+
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+import sys
+import logging
+from pathlib import Path
+
+# Configure logging to reduce verbosity
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("src.injury_collector").setLevel(logging.WARNING)
+logging.getLogger("src.prediction_tracker").setLevel(logging.WARNING)
+logging.getLogger("chromadb").setLevel(logging.WARNING)
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.prediction_pipeline import PredictionPipeline
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app, origins=["http://localhost:5173", "http://localhost:3000", "http://127.0.0.1:5173"])
+
+# Initialize prediction pipeline (ELO ratings loaded on startup)
+print("Initializing prediction pipeline...")
+pipeline = PredictionPipeline()
+print("Pipeline ready!")
+
+
+@app.route("/api/health")
+def health_check():
+    """Health check endpoint."""
+    return jsonify({"status": "healthy", "pipeline_ready": pipeline is not None})
+
+
+@app.route("/api/games/live")
+def get_live_games():
+    """Get today's games with live scores and predictions."""
+    games = pipeline.get_games_with_predictions()
+    
+    # Process each game - save predictions for upcoming, update results for completed
+    for game in games:
+        status = game.get("status")
+        game_id = game.get("game_id")
+        pred = game.get("prediction", {})
+        
+        if game_id and pred:
+            if status == "NOT_STARTED":
+                # Only save if prediction doesn't already exist
+                existing = pipeline.prediction_tracker.get_prediction(game_id)
+                if not existing:
+                    pipeline.prediction_tracker.save_prediction(game_id, {
+                        "game_date": game.get("game_date"),
+                        "home_team": game.get("home_team"),
+                        "away_team": game.get("away_team"),
+                        "predicted_winner": pred.get("predicted_winner"),
+                        "home_win_probability": pred.get("home_win_probability"),
+                        "away_win_probability": pred.get("away_win_probability"),
+                        "confidence": pred.get("confidence"),
+                        "home_elo": pred.get("home_elo"),
+                        "away_elo": pred.get("away_elo"),
+                    })
+            elif status == "FINAL":
+                # Update result for completed game
+                home_score = game.get("home_score", 0)
+                away_score = game.get("away_score", 0)
+                actual_winner = game.get("home_team") if home_score > away_score else game.get("away_team")
+                
+                # Check if prediction exists, if not save it first
+                existing = pipeline.prediction_tracker.get_prediction(game_id)
+                if not existing:
+                    # Save prediction first (for games completed before tracking started)
+                    pipeline.prediction_tracker.save_prediction(game_id, {
+                        "game_date": game.get("game_date"),
+                        "home_team": game.get("home_team"),
+                        "away_team": game.get("away_team"),
+                        "predicted_winner": pred.get("predicted_winner"),
+                        "home_win_probability": pred.get("home_win_probability"),
+                        "away_win_probability": pred.get("away_win_probability"),
+                        "confidence": pred.get("confidence"),
+                        "home_elo": pred.get("home_elo"),
+                        "away_elo": pred.get("away_elo"),
+                    })
+                
+                # Now update with result
+                pipeline.prediction_tracker.update_result(
+                    game_id,
+                    actual_winner,
+                    home_score,
+                    away_score
+                )
+                
+                # Mark whether our prediction was correct
+                game["prediction_correct"] = pred.get("predicted_winner") == actual_winner
+    
+    # Separate by status
+    return jsonify({
+        "live": [g for g in games if g.get("status") == "IN_PROGRESS"],
+        "final": [g for g in games if g.get("status") == "FINAL"],
+        "upcoming": [g for g in games if g.get("status") == "NOT_STARTED"],
+        "total": len(games)
+    })
+
+
+@app.route("/api/games/upcoming")
+def get_upcoming_games():
+    """Get upcoming games for the next N days."""
+    days = request.args.get("days", 7, type=int)
+    days = max(1, min(days, 14))  # Clamp between 1-14
+    
+    games = pipeline.get_upcoming_games(days_ahead=days)
+    
+    # Add predictions to each game
+    enriched_games = []
+    for game in games:
+        pred = pipeline.predict_game(game["home_team"], game["away_team"])
+        enriched_games.append({
+            **game,
+            "prediction": pred
+        })
+    
+    return jsonify({"games": enriched_games, "count": len(enriched_games)})
+
+
+@app.route("/api/predict")
+def predict_game():
+    """Predict outcome for a single game."""
+    home = request.args.get("home", "").upper()
+    away = request.args.get("away", "").upper()
+    
+    if not home or not away:
+        return jsonify({"error": "Missing home or away team parameter"}), 400
+    
+    prediction = pipeline.predict_game(home, away)
+    return jsonify(prediction)
+
+
+@app.route("/api/accuracy")
+def get_accuracy():
+    """Get comprehensive model accuracy statistics."""
+    stats = pipeline.get_accuracy_stats()
+    recent = pipeline.get_recent_predictions(50)  # Get more for analysis
+    
+    # Calculate additional metrics
+    completed = [p for p in recent if p.get("is_correct", -1) >= 0]
+    correct = [p for p in completed if p.get("is_correct") == 1]
+    
+    # Home vs Away accuracy
+    home_picks = [p for p in completed if p.get("predicted_winner") == p.get("home_team")]
+    home_correct = [p for p in home_picks if p.get("is_correct") == 1]
+    away_picks = [p for p in completed if p.get("predicted_winner") == p.get("away_team")]
+    away_correct = [p for p in away_picks if p.get("is_correct") == 1]
+    
+    # Current streak
+    streak = 0
+    streak_type = None
+    for p in sorted(completed, key=lambda x: x.get("updated_at", ""), reverse=True):
+        if streak_type is None:
+            streak_type = "W" if p.get("is_correct") == 1 else "L"
+        if (p.get("is_correct") == 1 and streak_type == "W") or (p.get("is_correct") == 0 and streak_type == "L"):
+            streak += 1
+        else:
+            break
+    
+    # Last 10 games
+    last_10 = completed[:10] if len(completed) >= 10 else completed
+    last_10_correct = sum(1 for p in last_10 if p.get("is_correct") == 1)
+    
+    # Average win probability for correct vs incorrect predictions
+    correct_avg_prob = sum(max(p.get("home_win_prob", 0.5), p.get("away_win_prob", 0.5)) for p in correct) / len(correct) if correct else 0
+    incorrect = [p for p in completed if p.get("is_correct") == 0]
+    incorrect_avg_prob = sum(max(p.get("home_win_prob", 0.5), p.get("away_win_prob", 0.5)) for p in incorrect) / len(incorrect) if incorrect else 0
+    
+    # Build enhanced response
+    enhanced_stats = {
+        **stats,
+        "home_pick_accuracy": len(home_correct) / len(home_picks) if home_picks else 0,
+        "away_pick_accuracy": len(away_correct) / len(away_picks) if away_picks else 0,
+        "home_picks_total": len(home_picks),
+        "away_picks_total": len(away_picks),
+        "current_streak": streak,
+        "streak_type": streak_type or "N/A",
+        "last_10_record": f"{last_10_correct}-{len(last_10) - last_10_correct}",
+        "last_10_accuracy": last_10_correct / len(last_10) if last_10 else 0,
+        "avg_probability_correct": correct_avg_prob,
+        "avg_probability_incorrect": incorrect_avg_prob,
+        "pending_predictions": len([p for p in recent if p.get("is_correct", -1) == -1]),
+    }
+    
+    return jsonify({
+        "stats": enhanced_stats,
+        "recent_predictions": recent[:20]  # Return 20 most recent for display
+    })
+
+
+@app.route("/api/mvp")
+def get_mvp_race():
+    """Get current MVP race standings."""
+    mvp_df = pipeline.get_mvp_race()
+    
+    # Convert DataFrame to list of dicts
+    candidates = []
+    for idx, row in mvp_df.iterrows():
+        candidates.append({
+            "rank": len(candidates) + 1,
+            "name": row["PLAYER_NAME"],
+            "ppg": round(float(row["PTS"]), 1),
+            "rpg": round(float(row["REB"]), 1),
+            "apg": round(float(row["AST"]), 1),
+            "mvp_score": round(float(row["mvp_score"]), 1),
+            "similarity": round(float(row["mvp_similarity"]) * 100, 1)
+        })
+    
+    return jsonify({"candidates": candidates})
+
+
+@app.route("/api/championship")
+def get_championship_odds():
+    """Get current championship odds."""
+    champ_df = pipeline.get_championship_odds()
+    
+    # Convert DataFrame to list of dicts
+    teams = []
+    for idx, row in champ_df.iterrows():
+        # ChampionshipPredictor returns: TEAM_ABBREVIATION, W_PCT, playoff_experience, strength_rating, champ_probability
+        teams.append({
+            "rank": len(teams) + 1,
+            "team": row.get("TEAM_ABBREVIATION", row.get("Team", "N/A")),
+            "odds": round(float(row.get("champ_probability", row.get("Championship_Odds", 0))) * 100, 1),
+            "win_pct": round(float(row.get("W_PCT", 0.5)) * 100, 1)
+        })
+    
+    return jsonify({"teams": teams})
+
+
+@app.route("/api/teams")
+def get_teams():
+    """Get list of all NBA teams."""
+    from src.config import NBA_TEAMS
+    
+    teams = [{"id": tid, "abbrev": abbrev} for tid, abbrev in NBA_TEAMS.items()]
+    teams.sort(key=lambda x: x["abbrev"])
+    
+    return jsonify({"teams": teams})
+
+
+@app.route("/api/roster/<team_abbrev>")
+def get_team_roster(team_abbrev):
+    """Get projected starting 5 for a team using LIVE 2025-26 season stats."""
+    try:
+        from nba_api.stats.endpoints import leaguedashplayerstats
+        import time
+        
+        # Fetch current season player stats from NBA API
+        time.sleep(0.5)  # Rate limiting
+        stats = leaguedashplayerstats.LeagueDashPlayerStats(
+            season='2025-26',
+            per_mode_detailed='PerGame'
+        )
+        df = stats.get_data_frames()[0]
+        
+        # Filter by team
+        team_abbrev = team_abbrev.upper()
+        team_players = df[df['TEAM_ABBREVIATION'] == team_abbrev].copy()
+        
+        if team_players.empty:
+            return jsonify({"team": team_abbrev, "starters": []})
+        
+        # Sort by minutes played (starters play the most minutes)
+        team_players = team_players.sort_values('MIN', ascending=False)
+        
+        # Get top 5 players (projected starters)
+        starters = []
+        for _, player in team_players.head(5).iterrows():
+            starters.append({
+                'name': player['PLAYER_NAME'],
+                'position': player.get('POSITION', ''),
+                'pts': round(float(player['PTS']), 1),
+                'reb': round(float(player.get('REB', 0)), 1),
+                'ast': round(float(player.get('AST', 0)), 1),
+                'min': round(float(player.get('MIN', 0)), 1)
+            })
+        
+        return jsonify({"team": team_abbrev, "starters": starters})
+        
+    except Exception as e:
+        print(f"Error fetching roster for {team_abbrev}: {e}")
+        # Fallback to pipeline method
+        roster = pipeline.get_team_roster(team_abbrev.upper())
+        return jsonify({"team": team_abbrev.upper(), "starters": roster})
+
+
+@app.route("/api/standings")
+def get_standings():
+    """Get current NBA standings by conference."""
+    # Team name to abbreviation mapping for fallback - includes team names, cities, and variants
+    TEAM_NAME_TO_ABBREV = {
+        # Team nicknames
+        "hawks": "ATL", "celtics": "BOS", "nets": "BKN", "hornets": "CHA",
+        "bulls": "CHI", "cavaliers": "CLE", "cavs": "CLE", "mavericks": "DAL", "mavs": "DAL",
+        "nuggets": "DEN", "pistons": "DET", "warriors": "GSW", "dubs": "GSW",
+        "rockets": "HOU", "pacers": "IND", "clippers": "LAC", "lakers": "LAL",
+        "grizzlies": "MEM", "heat": "MIA", "bucks": "MIL", "timberwolves": "MIN", "wolves": "MIN",
+        "pelicans": "NOP", "pels": "NOP", "knicks": "NYK", "thunder": "OKC",
+        "magic": "ORL", "76ers": "PHI", "sixers": "PHI", "suns": "PHX",
+        "trail blazers": "POR", "blazers": "POR", "trailblazers": "POR",
+        "kings": "SAC", "spurs": "SAS", "raptors": "TOR", "jazz": "UTA", "wizards": "WAS",
+        # City names
+        "atlanta": "ATL", "boston": "BOS", "brooklyn": "BKN", "charlotte": "CHA",
+        "chicago": "CHI", "cleveland": "CLE", "dallas": "DAL", "denver": "DEN",
+        "detroit": "DET", "golden state": "GSW", "houston": "HOU", "indiana": "IND",
+        "los angeles c": "LAC", "la c": "LAC", "los angeles l": "LAL", "la l": "LAL",
+        "memphis": "MEM", "miami": "MIA", "milwaukee": "MIL", "minnesota": "MIN",
+        "new orleans": "NOP", "new york": "NYK", "oklahoma city": "OKC", "oklahoma": "OKC",
+        "orlando": "ORL", "philadelphia": "PHI", "phoenix": "PHX", "portland": "POR",
+        "sacramento": "SAC", "san antonio": "SAS", "toronto": "TOR", "utah": "UTA", "washington": "WAS"
+    }
+    
+    def get_abbrev_from_name(team_name):
+        """Extract abbreviation from team name."""
+        team_name_lower = team_name.lower().strip()
+        for name_part, abbrev in TEAM_NAME_TO_ABBREV.items():
+            if name_part in team_name_lower:
+                return abbrev
+        return ""
+    
+    try:
+        from nba_api.stats.endpoints import leaguestandings
+        import time
+        
+        time.sleep(0.5)
+        standings = leaguestandings.LeagueStandings(season='2025-26')
+        df = standings.get_data_frames()[0]
+        
+        # Debug: print column names on first run
+        print(f"Standings columns: {list(df.columns)}")
+        
+        east = []
+        west = []
+        
+        for _, row in df.iterrows():
+            # Try multiple possible column names for team abbreviation
+            abbrev = ""
+            for col_name in ["TeamSlug", "TeamAbbreviation", "TEAM_ABBREVIATION", "team_abbreviation"]:
+                if col_name in row.index and row.get(col_name):
+                    abbrev = str(row.get(col_name)).upper().strip()
+                    break
+            
+            # Build team name from city + name
+            team_city = str(row.get("TeamCity", ""))
+            team_name = str(row.get("TeamName", ""))
+            full_team_name = f"{team_city} {team_name}".strip()
+            
+            # If abbreviation still not found, extract from team name
+            if not abbrev:
+                abbrev = get_abbrev_from_name(full_team_name)
+            
+            team_data = {
+                "team": abbrev,  # Use abbreviation for frontend TeamLogo component
+                "team_abbrev": abbrev,  # Duplicate for clarity
+                "team_name": full_team_name,
+                "wins": int(row.get("WINS", 0)),
+                "losses": int(row.get("LOSSES", 0)),
+                "win_pct": float(row.get("WinPCT", 0)),
+                "gb": str(row.get("ConferenceGamesBack", "-")),
+                "streak": str(row.get("strCurrentStreak", "-")),
+                "conference": row.get("Conference", ""),
+            }
+            
+            if row.get("Conference") == "East":
+                east.append(team_data)
+            else:
+                west.append(team_data)
+        
+        # Sort by wins descending
+        east.sort(key=lambda x: (-x["wins"], x["losses"]))
+        west.sort(key=lambda x: (-x["wins"], x["losses"]))
+        
+        return jsonify({"east": east, "west": west})
+        
+    except Exception as e:
+        print(f"Error fetching standings: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({"east": [], "west": [], "error": str(e)})
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=8000, debug=True)

data/processed/game_dataset.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:942fe53289804148c25358df751e9bbb0080dd6d72c804ceadf91f7a88310ac4
+size 40839859

data/processed/game_features.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d5f377ae5eede6597cf5c42cfe714ebecfcf9a2765138f1bafb21f69e121222
+size 7078674

models/game_predictor.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98ea35c665375601bf707adaf9a9233078c4a94aff8a5d281b2a16acf2ec3f86
+size 3664164

process.md

@@ -0,0 +1,254 @@
+# NBA ML Prediction System - Process Guide
+
+## Prerequisites
+
+Before starting, ensure you have:
+- Python 3.10+ installed
+- Virtual environment activated: `.\venv\Scripts\activate`
+- All dependencies installed: `pip install -r requirements.txt`
+
+---
+
+## Step 1: Collect Training Data (COMPREHENSIVE)
+
+**Purpose**: Fetch 10 seasons of ALL NBA stats from the API including:
+- Games, Team Stats, Player Stats (basic)
+- Advanced Metrics (NET_RTG, PACE, PIE, TS%, eFG%)
+- Clutch Stats (performance in close games)
+- Hustle Stats (deflections, charges, loose balls)
+- Defense Stats
+
+**File**: `src/data_collector.py`
+
+**Command**:
+```bash
+python -m src.data_collector
+```
+
+**Duration**: ~2-4 hours (has resume capability if interrupted)
+
+**Output Files** (in `data/raw/`):
+- `all_games.parquet` - Game results
+- `all_team_stats.parquet` - Basic team stats
+- `all_team_advanced.parquet` - NET_RTG, PACE, PIE, TS%
+- `all_team_clutch.parquet` - Close game performance
+- `all_team_hustle.parquet` - Deflections, charges
+- `all_team_defense.parquet` - Defensive metrics
+- `all_player_stats.parquet` - Player averages
+- `all_player_advanced.parquet` - PER, USG%, TS%
+- `all_player_clutch.parquet` - Player clutch stats
+- `all_player_hustle.parquet` - Player hustle metrics
+
+---
+
+## Step 2: Generate Features
+
+**Purpose**: Create ~50+ features including ELO, rolling stats, momentum, rest/fatigue
+
+**File**: `src/feature_engineering.py`
+
+**Command**:
+```bash
+python -m src.feature_engineering --process
+```
+
+**Duration**: ~30-60 minutes
+
+**Output Files**:
+- `data/processed/game_features.parquet`
+
+**Features Generated**:
+- ELO ratings (team_elo, opponent_elo, elo_diff, elo_win_prob)
+- Rolling stats (PTS/AST/REB/FG_PCT last 5/10/20 games)
+- Defensive stats (STL, BLK, DREB rolling)
+- Momentum (wins_last5, hot_streak, cold_streak, plus_minus)
+- Rest/fatigue (days_rest, back_to_back, games_last_week)
+- Season averages (all stats)
+- Team advanced metrics (NET_RTG, PACE, clutch, hustle)
+- Player aggregations (top players avg, star concentration)
+
+---
+
+## Step 3: Build Dataset
+
+**Purpose**: Split data into train/val/test and prepare for training
+
+**File**: `src/preprocessing.py`
+
+**Command**:
+```bash
+python -m src.preprocessing --build
+```
+
+**Output Files**:
+- `data/processed/game_dataset.joblib`
+
+**What It Does**:
+- Automatically detects ALL numeric features
+- Splits by season (no data leakage)
+- Scales and imputes missing values
+
+---
+
+## Step 4: Train Model
+
+**Purpose**: Train XGBoost + LightGBM ensemble on ALL features
+
+**File**: `src/models/game_predictor.py`
+
+**Command**:
+```bash
+python -m src.models.game_predictor --train
+```
+
+**Expected Output**:
+```
+Loading dataset...
+Training XGBoost model...
+Training LightGBM model...
+Training complete!
+
+=== Test Metrics ===
+Test Accuracy: 0.67XX
+Test Brier Score: 0.21XX
+✓ Target accuracy (>65%) achieved!
+
+=== Top Features ===
+                feature  xgb_importance  lgb_importance  avg_importance
+0              elo_diff          0.XXX           0.XXX            0.XXX
+1          elo_win_prob          0.XXX           0.XXX            0.XXX
+...
+
+Saved model to models/game_predictor.joblib
+```
+
+**Output Files**:
+- `models/game_predictor.joblib`
+
+---
+
+## Step 5: Generate Visualizations
+
+**Purpose**: Create analysis charts saved to `graphs/`
+
+**File**: `src/visualization.py`
+
+**Command**:
+```bash
+python -m src.visualization
+```
+
+**Output Files** (in `graphs/`):
+- `mvp_race.png`
+- `mvp_stat_comparison.png`
+- `championship_odds_pie.png`
+- `strength_vs_experience.png`
+
+---
+
+## Step 6: Run the Dashboard
+
+**Purpose**: Launch Streamlit web interface
+
+**File**: `app/app.py`
+
+**Command**:
+```bash
+streamlit run app/app.py
+```
+
+**Opens**: `http://localhost:8501`
+
+**Pages**:
+- 🔴 Live Games - Real-time scores with predictions
+- 🎮 Game Predictions - Predict any matchup
+- 📈 Model Accuracy - Track prediction accuracy
+- 🏆 MVP Race - Top candidates
+- 👑 Championship Odds - Team probabilities
+- 📊 Team Explorer - Stats & injuries
+
+---
+
+## Quick Reference
+
+| Step | Command | Duration |
+|------|---------|----------|
+| 1 | `python -m src.data_collector` | 2-4 hours |
+| 2 | `python -m src.feature_engineering --process` | 30-60 min |
+| 3 | `python -m src.preprocessing --build` | 1-2 min |
+| 4 | `python -m src.models.game_predictor --train` | 2-5 min |
+| 5 | `python -m src.visualization` | 10 sec |
+| 6 | `streamlit run app/app.py` | Immediate |
+
+---
+
+## Live Data Features (NEW)
+
+### View Live Scoreboard
+```bash
+python -m src.live_data_collector
+```
+Shows today's NBA games with live scores.
+
+### Continuous Learning
+```bash
+# Ingest completed games
+python -m src.continuous_learner --ingest
+
+# Full update cycle (ingest + features + retrain)
+python -m src.continuous_learner --update
+
+# Update without retraining
+python -m src.continuous_learner --update --no-retrain
+```
+
+### Check Prediction Accuracy
+```bash
+python -m src.prediction_tracker
+```
+Shows accuracy stats from ChromaDB.
+
+---
+
+## Data Flow
+
+```
+NBA API
+   ↓
+[Step 1: data_collector.py]
+   ↓
+data/raw/*.parquet (10+ files)
+   ↓
+[Step 2: feature_engineering.py]
+   ↓
+data/processed/game_features.parquet (~50+ features)
+   ↓
+[Step 3: preprocessing.py]
+   ↓
+data/processed/game_dataset.joblib (train/val/test splits)
+   ↓
+[Step 4: game_predictor.py]
+   ↓
+models/game_predictor.joblib (trained ensemble)
+   ↓
+[Step 6: app.py] → Web Dashboard
+   ↓
+ChromaDB (prediction tracking)
+```
+
+---
+
+## Troubleshooting
+
+### ModuleNotFoundError: No module named 'src'
+Ensure you're in the project root directory.
+
+### API Rate Limit Errors
+The data collector handles this with exponential backoff. Just let it retry.
+
+### Resume Interrupted Collection
+Just run the command again - it has checkpoint capability and will skip completed data.
+
+### ChromaDB Connection Issues
+Check your API key in `src/config.py` under `ChromaDBConfig`.
+

requirements.txt

@@ -0,0 +1,21 @@
+nba_api>=1.4.1
+pandas>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+xgboost>=2.0.0
+lightgbm>=4.0.0
+streamlit>=1.28.0
+plotly>=5.18.0
+joblib>=1.3.0
+tqdm>=4.66.0
+pyarrow>=14.0.0
+requests>=2.31.0
+tenacity>=8.2.0
+matplotlib>=3.8.0
+seaborn>=0.13.0
+chromadb-client>=0.5.0
+streamlit-autorefresh>=1.0.1
+apscheduler>=3.10.0
+flask>=3.0.0
+flask-cors>=4.0.0
+

server.py

@@ -0,0 +1,341 @@
+"""
+NBA ML Prediction System - Production Server
+=============================================
+Serves the React frontend and Flask API for Hugging Face Spaces.
+"""
+
+from flask import Flask, jsonify, request, send_from_directory
+from flask_cors import CORS
+import sys
+import logging
+import os
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("chromadb").setLevel(logging.WARNING)
+
+# Add project root to path
+ROOT_DIR = Path(__file__).parent
+sys.path.insert(0, str(ROOT_DIR))
+
+from src.prediction_pipeline import PredictionPipeline
+
+# Initialize Flask app
+app = Flask(__name__, static_folder='static', static_url_path='')
+
+# Allow all origins for Hugging Face Spaces
+CORS(app, origins=["*"])
+
+# Initialize prediction pipeline
+print("Initializing prediction pipeline...")
+try:
+    pipeline = PredictionPipeline()
+    print("Pipeline ready!")
+except Exception as e:
+    print(f"Warning: Pipeline initialization failed: {e}")
+    pipeline = None
+
+
+# ============================================================================
+# Serve React Frontend
+# ============================================================================
+
+@app.route('/')
+def serve_frontend():
+    """Serve the React frontend."""
+    return send_from_directory('static', 'index.html')
+
+
+@app.route('/<path:path>')
+def serve_static(path):
+    """Serve static files, fallback to index.html for client-side routing."""
+    static_folder = Path(app.static_folder)
+    file_path = static_folder / path
+    
+    if file_path.exists() and file_path.is_file():
+        return send_from_directory('static', path)
+    return send_from_directory('static', 'index.html')
+
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+@app.route("/api/health")
+def health_check():
+    """Health check endpoint."""
+    return jsonify({"status": "healthy", "pipeline_ready": pipeline is not None})
+
+
+@app.route("/api/games/live")
+def get_live_games():
+    """Get today's games with live scores and predictions."""
+    if not pipeline:
+        return jsonify({"live": [], "final": [], "upcoming": [], "total": 0, "error": "Pipeline not ready"})
+    
+    try:
+        games = pipeline.get_games_with_predictions()
+        
+        # Process each game
+        for game in games:
+            status = game.get("status")
+            game_id = game.get("game_id")
+            pred = game.get("prediction", {})
+            
+            if game_id and pred:
+                if status == "NOT_STARTED":
+                    existing = pipeline.prediction_tracker.get_prediction(game_id)
+                    if not existing:
+                        pipeline.prediction_tracker.save_prediction(game_id, {
+                            "game_date": game.get("game_date"),
+                            "home_team": game.get("home_team"),
+                            "away_team": game.get("away_team"),
+                            "predicted_winner": pred.get("predicted_winner"),
+                            "home_win_probability": pred.get("home_win_probability"),
+                            "away_win_probability": pred.get("away_win_probability"),
+                            "confidence": pred.get("confidence"),
+                            "home_elo": pred.get("home_elo"),
+                            "away_elo": pred.get("away_elo"),
+                        })
+                elif status == "FINAL":
+                    home_score = game.get("home_score", 0)
+                    away_score = game.get("away_score", 0)
+                    actual_winner = game.get("home_team") if home_score > away_score else game.get("away_team")
+                    
+                    existing = pipeline.prediction_tracker.get_prediction(game_id)
+                    if not existing:
+                        pipeline.prediction_tracker.save_prediction(game_id, {
+                            "game_date": game.get("game_date"),
+                            "home_team": game.get("home_team"),
+                            "away_team": game.get("away_team"),
+                            "predicted_winner": pred.get("predicted_winner"),
+                            "home_win_probability": pred.get("home_win_probability"),
+                            "away_win_probability": pred.get("away_win_probability"),
+                            "confidence": pred.get("confidence"),
+                            "home_elo": pred.get("home_elo"),
+                            "away_elo": pred.get("away_elo"),
+                        })
+                    
+                    pipeline.prediction_tracker.update_result(game_id, actual_winner, home_score, away_score)
+                    game["prediction_correct"] = pred.get("predicted_winner") == actual_winner
+        
+        return jsonify({
+            "live": [g for g in games if g.get("status") == "IN_PROGRESS"],
+            "final": [g for g in games if g.get("status") == "FINAL"],
+            "upcoming": [g for g in games if g.get("status") == "NOT_STARTED"],
+            "total": len(games)
+        })
+    except Exception as e:
+        logging.error(f"Error in get_live_games: {e}")
+        return jsonify({"live": [], "final": [], "upcoming": [], "total": 0, "error": str(e)})
+
+
+@app.route("/api/games/upcoming")
+def get_upcoming_games():
+    """Get upcoming games for the next N days."""
+    if not pipeline:
+        return jsonify({"games": [], "count": 0, "error": "Pipeline not ready"})
+    
+    try:
+        days = request.args.get("days", 7, type=int)
+        days = max(1, min(days, 14))
+        
+        games = pipeline.get_upcoming_games(days_ahead=days)
+        
+        enriched_games = []
+        for game in games:
+            pred = pipeline.predict_game(game["home_team"], game["away_team"])
+            enriched_games.append({**game, "prediction": pred})
+        
+        return jsonify({"games": enriched_games, "count": len(enriched_games)})
+    except Exception as e:
+        logging.error(f"Error in get_upcoming_games: {e}")
+        return jsonify({"games": [], "count": 0, "error": str(e)})
+
+
+@app.route("/api/predict")
+def predict_game():
+    """Predict outcome for a single game."""
+    if not pipeline:
+        return jsonify({"error": "Pipeline not ready"}), 503
+    
+    home = request.args.get("home", "").upper()
+    away = request.args.get("away", "").upper()
+    
+    if not home or not away:
+        return jsonify({"error": "Missing home or away team parameter"}), 400
+    
+    try:
+        prediction = pipeline.predict_game(home, away)
+        return jsonify(prediction)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/accuracy")
+def get_accuracy():
+    """Get comprehensive model accuracy statistics."""
+    if not pipeline:
+        return jsonify({"stats": {}, "recent_predictions": [], "error": "Pipeline not ready"})
+    
+    try:
+        stats = pipeline.get_accuracy_stats()
+        recent = pipeline.get_recent_predictions(50)
+        
+        completed = [p for p in recent if p.get("is_correct", -1) >= 0]
+        correct = [p for p in completed if p.get("is_correct") == 1]
+        
+        home_picks = [p for p in completed if p.get("predicted_winner") == p.get("home_team")]
+        home_correct = [p for p in home_picks if p.get("is_correct") == 1]
+        away_picks = [p for p in completed if p.get("predicted_winner") == p.get("away_team")]
+        away_correct = [p for p in away_picks if p.get("is_correct") == 1]
+        
+        streak = 0
+        streak_type = None
+        for p in sorted(completed, key=lambda x: x.get("updated_at", ""), reverse=True):
+            if streak_type is None:
+                streak_type = "W" if p.get("is_correct") == 1 else "L"
+            if (p.get("is_correct") == 1 and streak_type == "W") or (p.get("is_correct") == 0 and streak_type == "L"):
+                streak += 1
+            else:
+                break
+        
+        last_10 = completed[:10] if len(completed) >= 10 else completed
+        last_10_correct = sum(1 for p in last_10 if p.get("is_correct") == 1)
+        
+        correct_avg_prob = sum(max(p.get("home_win_prob", 0.5), p.get("away_win_prob", 0.5)) for p in correct) / len(correct) if correct else 0
+        incorrect = [p for p in completed if p.get("is_correct") == 0]
+        incorrect_avg_prob = sum(max(p.get("home_win_prob", 0.5), p.get("away_win_prob", 0.5)) for p in incorrect) / len(incorrect) if incorrect else 0
+        
+        enhanced_stats = {
+            **stats,
+            "home_pick_accuracy": len(home_correct) / len(home_picks) if home_picks else 0,
+            "away_pick_accuracy": len(away_correct) / len(away_picks) if away_picks else 0,
+            "home_picks_total": len(home_picks),
+            "away_picks_total": len(away_picks),
+            "current_streak": streak,
+            "streak_type": streak_type or "N/A",
+            "last_10_record": f"{last_10_correct}-{len(last_10) - last_10_correct}",
+            "last_10_accuracy": last_10_correct / len(last_10) if last_10 else 0,
+            "avg_probability_correct": correct_avg_prob,
+            "avg_probability_incorrect": incorrect_avg_prob,
+            "pending_predictions": len([p for p in recent if p.get("is_correct", -1) == -1]),
+        }
+        
+        return jsonify({"stats": enhanced_stats, "recent_predictions": recent[:20]})
+    except Exception as e:
+        logging.error(f"Error in get_accuracy: {e}")
+        return jsonify({"stats": {}, "recent_predictions": [], "error": str(e)})
+
+
+@app.route("/api/mvp")
+def get_mvp_race():
+    """Get current MVP race standings."""
+    if not pipeline:
+        return jsonify({"candidates": [], "error": "Pipeline not ready"})
+    
+    try:
+        mvp_df = pipeline.get_mvp_race()
+        
+        candidates = []
+        for idx, row in mvp_df.iterrows():
+            candidates.append({
+                "rank": len(candidates) + 1,
+                "name": row["PLAYER_NAME"],
+                "ppg": round(float(row["PTS"]), 1),
+                "rpg": round(float(row["REB"]), 1),
+                "apg": round(float(row["AST"]), 1),
+                "mvp_score": round(float(row["mvp_score"]), 1),
+                "similarity": round(float(row["mvp_similarity"]) * 100, 1)
+            })
+        
+        return jsonify({"candidates": candidates})
+    except Exception as e:
+        logging.error(f"Error in get_mvp_race: {e}")
+        return jsonify({"candidates": [], "error": str(e)})
+
+
+@app.route("/api/championship")
+def get_championship_odds():
+    """Get current championship odds."""
+    if not pipeline:
+        return jsonify({"teams": [], "error": "Pipeline not ready"})
+    
+    try:
+        champ_df = pipeline.get_championship_odds()
+        
+        teams = []
+        for idx, row in champ_df.iterrows():
+            teams.append({
+                "rank": len(teams) + 1,
+                "team": row.get("TEAM_ABBREVIATION", row.get("Team", "N/A")),
+                "odds": round(float(row.get("champ_probability", row.get("Championship_Odds", 0))) * 100, 1),
+                "win_pct": round(float(row.get("W_PCT", 0.5)) * 100, 1)
+            })
+        
+        return jsonify({"teams": teams})
+    except Exception as e:
+        logging.error(f"Error in get_championship_odds: {e}")
+        return jsonify({"teams": [], "error": str(e)})
+
+
+@app.route("/api/teams")
+def get_teams():
+    """Get list of all NBA teams."""
+    try:
+        from src.config import NBA_TEAMS
+        teams = [{"id": tid, "abbrev": abbrev} for tid, abbrev in NBA_TEAMS.items()]
+        teams.sort(key=lambda x: x["abbrev"])
+        return jsonify({"teams": teams})
+    except Exception as e:
+        return jsonify({"teams": [], "error": str(e)})
+
+
+@app.route("/api/roster/<team_abbrev>")
+def get_team_roster(team_abbrev):
+    """Get projected starting 5 for a team."""
+    try:
+        from nba_api.stats.endpoints import leaguedashplayerstats
+        import time
+        
+        time.sleep(0.6)
+        stats = leaguedashplayerstats.LeagueDashPlayerStats(
+            season='2025-26',
+            per_mode_detailed='PerGame'
+        )
+        df = stats.get_data_frames()[0]
+        
+        team_abbrev = team_abbrev.upper()
+        team_players = df[df['TEAM_ABBREVIATION'] == team_abbrev].copy()
+        
+        if team_players.empty:
+            return jsonify({"team": team_abbrev, "starters": []})
+        
+        team_players = team_players.sort_values('MIN', ascending=False)
+        
+        starters = []
+        for _, player in team_players.head(5).iterrows():
+            starters.append({
+                'name': player['PLAYER_NAME'],
+                'position': player.get('POSITION', ''),
+                'pts': round(float(player['PTS']), 1),
+                'reb': round(float(player.get('REB', 0)), 1),
+                'ast': round(float(player.get('AST', 0)), 1),
+                'min': round(float(player.get('MIN', 0)), 1)
+            })
+        
+        return jsonify({"team": team_abbrev, "starters": starters})
+        
+    except Exception as e:
+        logging.error(f"Error fetching roster for {team_abbrev}: {e}")
+        if pipeline:
+            roster = pipeline.get_team_roster(team_abbrev.upper())
+            return jsonify({"team": team_abbrev.upper(), "starters": roster})
+        return jsonify({"team": team_abbrev, "starters": [], "error": str(e)})
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

src/__init__.py

@@ -0,0 +1 @@
+# Empty init file

src/auto_trainer.py

@@ -0,0 +1,278 @@
+"""
+NBA ML Prediction System - Auto Training Scheduler
+===================================================
+Background scheduler that automatically trains the model on new game data.
+Runs within the Streamlit app or as a standalone service.
+"""
+
+import logging
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Optional
+import atexit
+
+logger = logging.getLogger(__name__)
+
+
+class AutoTrainer:
+    """
+    Automatic model training scheduler.
+    
+    Runs background tasks to:
+    1. Ingest completed games every hour
+    2. Retrain the model daily
+    3. Update prediction results after games
+    """
+    
+    _instance: Optional['AutoTrainer'] = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        """Singleton pattern - only one auto trainer instance."""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._initialized = False
+            return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._initialized = True
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        
+        # Track last run times
+        self._last_ingest = None
+        self._last_retrain = None
+        self._last_results_check = None
+        
+        # Intervals (in seconds)
+        self.INGEST_INTERVAL = 3600  # 1 hour
+        self.RETRAIN_INTERVAL = 86400  # 24 hours (daily)
+        self.RESULTS_CHECK_INTERVAL = 1800  # 30 minutes
+        
+        logger.info("AutoTrainer initialized")
+    
+    def start(self):
+        """Start the background training scheduler."""
+        if self._running:
+            logger.info("AutoTrainer already running")
+            return
+        
+        self._running = True
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+        
+        # Register cleanup on exit
+        atexit.register(self.stop)
+        
+        logger.info("AutoTrainer started - background training enabled")
+    
+    def stop(self):
+        """Stop the background scheduler."""
+        if not self._running:
+            return
+        
+        self._running = False
+        self._stop_event.set()
+        
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5)
+        
+        logger.info("AutoTrainer stopped")
+    
+    def _run_loop(self):
+        """Main background loop - checks for tasks to run."""
+        logger.info("AutoTrainer loop started")
+        
+        while not self._stop_event.is_set():
+            try:
+                now = datetime.now()
+                
+                # Check and update prediction results (every 30 min)
+                if self._should_run(self._last_results_check, self.RESULTS_CHECK_INTERVAL):
+                    self._check_results()
+                    self._last_results_check = now
+                
+                # Ingest completed games (every hour)
+                if self._should_run(self._last_ingest, self.INGEST_INTERVAL):
+                    self._ingest_games()
+                    self._last_ingest = now
+                
+                # Retrain model only after all daily games are complete
+                # NBA games typically end by 1 AM ET, so we retrain at 4 AM ET (safe window)
+                # 4 AM ET = 1:30 PM IST
+                if self._should_run(self._last_retrain, self.RETRAIN_INTERVAL):
+                    if self._all_daily_games_complete():
+                        self._retrain_model()
+                        self._last_retrain = now
+                    else:
+                        logger.info("AutoTrainer: Waiting for all games to complete before retrain")
+                
+            except Exception as e:
+                logger.error(f"AutoTrainer error: {e}")
+            
+            # Sleep for 5 minutes between checks
+            self._stop_event.wait(300)
+    
+    def _all_daily_games_complete(self) -> bool:
+        """Check if all of today's games have completed."""
+        try:
+            from src.live_data_collector import LiveDataCollector
+            collector = LiveDataCollector()
+            
+            # Get live games - if any are still in progress, don't retrain
+            live_games = collector.get_live_games()
+            if live_games:
+                logger.info(f"AutoTrainer: {len(live_games)} games still in progress")
+                return False
+            
+            # Get upcoming games - if any haven't started, don't retrain yet
+            upcoming = collector.get_upcoming_games()
+            if upcoming:
+                logger.info(f"AutoTrainer: {len(upcoming)} games haven't started yet")
+                return False
+            
+            # All games completed (or no games today)
+            return True
+            
+        except Exception as e:
+            logger.warning(f"Could not check game status: {e}")
+            # Default to checking time - after 4 AM ET (safe window)
+            hour = datetime.now().hour
+            # 4 AM ET ≈ 1:30 PM IST, 9 AM UTC
+            return hour >= 4 or hour < 12  # Between 4 AM and noon
+    
+    def _should_run(self, last_run: Optional[datetime], interval: int) -> bool:
+        """Check if enough time has passed since last run."""
+        if last_run is None:
+            return True
+        return (datetime.now() - last_run).total_seconds() >= interval
+    
+    def _check_results(self):
+        """Check completed games and update prediction results."""
+        logger.info("AutoTrainer: Checking prediction results...")
+        try:
+            from src.prediction_pipeline import PredictionPipeline
+            pipeline = PredictionPipeline()
+            updated = pipeline.check_prediction_results()
+            logger.info(f"AutoTrainer: Updated {len(updated)} prediction results")
+        except Exception as e:
+            logger.error(f"AutoTrainer: Failed to check results: {e}")
+    
+    def _ingest_games(self):
+        """Ingest completed games into training data."""
+        logger.info("AutoTrainer: Ingesting completed games...")
+        try:
+            from src.continuous_learner import ContinuousLearner
+            learner = ContinuousLearner()
+            count = learner.ingest_completed_games()
+            logger.info(f"AutoTrainer: Ingested {count} new games")
+        except Exception as e:
+            logger.error(f"AutoTrainer: Failed to ingest games: {e}")
+    
+    def _retrain_model(self):
+        """Full model retrain cycle."""
+        logger.info("AutoTrainer: Starting daily model retrain...")
+        try:
+            from src.continuous_learner import ContinuousLearner
+            learner = ContinuousLearner()
+            results = learner.run_update_cycle(retrain=True)
+            
+            if results.get("model_retrained"):
+                accuracy = results.get("metrics", {}).get("test_accuracy", 0)
+                logger.info(f"AutoTrainer: Model retrained! Accuracy: {accuracy:.2%}")
+            else:
+                logger.info("AutoTrainer: No new data to retrain on")
+                
+        except Exception as e:
+            logger.error(f"AutoTrainer: Failed to retrain model: {e}")
+    
+    def get_status(self) -> dict:
+        """Get current auto-trainer status."""
+        return {
+            "running": self._running,
+            "last_ingest": self._last_ingest.isoformat() if self._last_ingest else None,
+            "last_retrain": self._last_retrain.isoformat() if self._last_retrain else None,
+            "last_results_check": self._last_results_check.isoformat() if self._last_results_check else None,
+            "next_ingest_in": self._time_until_next(self._last_ingest, self.INGEST_INTERVAL),
+            "next_retrain_in": self._time_until_next(self._last_retrain, self.RETRAIN_INTERVAL),
+        }
+    
+    def _time_until_next(self, last_run: Optional[datetime], interval: int) -> str:
+        """Human-readable time until next run."""
+        if last_run is None:
+            return "Soon"
+        
+        elapsed = (datetime.now() - last_run).total_seconds()
+        remaining = max(0, interval - elapsed)
+        
+        if remaining < 60:
+            return f"{int(remaining)}s"
+        elif remaining < 3600:
+            return f"{int(remaining / 60)}m"
+        else:
+            return f"{int(remaining / 3600)}h {int((remaining % 3600) / 60)}m"
+    
+    def force_ingest(self):
+        """Force an immediate game ingestion."""
+        threading.Thread(target=self._ingest_games, daemon=True).start()
+    
+    def force_retrain(self):
+        """Force an immediate model retrain."""
+        threading.Thread(target=self._retrain_model, daemon=True).start()
+
+
+# Global instance
+auto_trainer = AutoTrainer()
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    logging.basicConfig(level=logging.INFO)
+    
+    parser = argparse.ArgumentParser(description="NBA Auto Training Scheduler")
+    parser.add_argument("--start", action="store_true", help="Start the scheduler")
+    parser.add_argument("--status", action="store_true", help="Show scheduler status")
+    
+    args = parser.parse_args()
+    
+    if args.status:
+        status = auto_trainer.get_status()
+        print("\n=== Auto Trainer Status ===\n")
+        print(f"Running: {'Yes ✓' if status['running'] else 'No'}")
+        print(f"Last Ingest: {status['last_ingest'] or 'Never'}")
+        print(f"Last Retrain: {status['last_retrain'] or 'Never'}")
+        print(f"Next Ingest In: {status['next_ingest_in']}")
+        print(f"Next Retrain In: {status['next_retrain_in']}")
+    
+    elif args.start:
+        print("\n=== Starting Auto Trainer ===\n")
+        print("Background training enabled!")
+        print("- Checks prediction results every 30 minutes")
+        print("- Ingests completed games every 1 hour")
+        print("- Retrains model every 24 hours")
+        print("\nPress Ctrl+C to stop...\n")
+        
+        auto_trainer.start()
+        
+        try:
+            while True:
+                time.sleep(60)
+                status = auto_trainer.get_status()
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Running... Next ingest: {status['next_ingest_in']}, Next retrain: {status['next_retrain_in']}")
+        except KeyboardInterrupt:
+            print("\nStopping...")
+            auto_trainer.stop()
+    
+    else:
+        print("Use --start to begin auto training or --status to check status")

src/config.py

@@ -0,0 +1,154 @@
+"""
+NBA ML Prediction System - Configuration
+=========================================
+Central configuration for data collection, model training, and predictions.
+"""
+
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import List
+
+# =============================================================================
+# PATHS
+# =============================================================================
+PROJECT_ROOT = Path(__file__).parent.parent
+DATA_DIR = PROJECT_ROOT / "data"
+RAW_DATA_DIR = DATA_DIR / "raw"
+PROCESSED_DATA_DIR = DATA_DIR / "processed"
+API_CACHE_DIR = DATA_DIR / "api_data"
+MODELS_DIR = PROJECT_ROOT / "models"
+
+# Create directories if they don't exist
+for dir_path in [RAW_DATA_DIR, PROCESSED_DATA_DIR, API_CACHE_DIR, MODELS_DIR]:
+    dir_path.mkdir(parents=True, exist_ok=True)
+
+# =============================================================================
+# SEASONS
+# =============================================================================
+# Extended dataset: 23 years (2003-2026) for comprehensive training
+INITIAL_SEASON_START = 2003
+INITIAL_SEASON_END = 2026  # Current 2025-26 season
+FULL_SEASON_START = 2003  # Full dataset starts from 2003
+
+def get_season_strings(start_year: int = INITIAL_SEASON_START, 
+                       end_year: int = INITIAL_SEASON_END) -> List[str]:
+    """Generate season strings like '2003-04', '2004-05', etc."""
+    return [f"{year}-{str(year+1)[-2:]}" for year in range(start_year, end_year)]
+
+SEASON_STRINGS = get_season_strings()
+
+# =============================================================================
+# CHROMADB CONFIGURATION
+# =============================================================================
+@dataclass
+class ChromaDBConfig:
+    """Configuration for ChromaDB prediction tracking."""
+    tenant: str = "70e82e68-9fa7-4224-9975-d49d355f6328"
+    database: str = "NBA_ML"
+    api_key: str = "ck-2bXunZK4X3BFSPHtwLG2Ki9xr5r6ZPxzADESDperHweT"
+    collection_name: str = "predictions"
+    
+CHROMADB_CONFIG = ChromaDBConfig()
+
+# =============================================================================
+# LIVE DATA CONFIGURATION
+# =============================================================================
+LIVE_REFRESH_INTERVAL = 15  # Seconds between live score refreshes
+
+# =============================================================================
+# API CONFIGURATION
+# =============================================================================
+@dataclass
+class APIConfig:
+    """Configuration for NBA API requests with robustness features."""
+    base_delay: float = 0.6  # Base delay between requests (seconds)
+    max_retries: int = 3  # Maximum retry attempts
+    initial_backoff: float = 2.0  # Initial backoff in seconds
+    max_backoff: float = 60.0  # Maximum backoff in seconds
+    backoff_multiplier: float = 2.0  # Exponential backoff multiplier
+    timeout: int = 30  # Request timeout in seconds
+    
+API_CONFIG = APIConfig()
+
+# =============================================================================
+# ELO CONFIGURATION
+# =============================================================================
+@dataclass
+class ELOConfig:
+    """Configuration for ELO rating calculations."""
+    initial_rating: float = 1500.0
+    k_factor: float = 20.0  # How much ratings change per game
+    home_advantage: float = 100.0  # ELO points added for home team
+    season_regression: float = 0.85  # Regress to mean at season start (85% = only 15% carryover)
+    
+ELO_CONFIG = ELOConfig()
+
+# =============================================================================
+# FEATURE CONFIGURATION
+# =============================================================================
+@dataclass
+class FeatureConfig:
+    """Configuration for feature engineering."""
+    rolling_windows: List[int] = field(default_factory=lambda: [5, 10, 20])
+    min_games_for_features: int = 5  # Minimum games before generating features
+    
+FEATURE_CONFIG = FeatureConfig()
+
+# =============================================================================
+# MODEL CONFIGURATION
+# =============================================================================
+@dataclass
+class ModelConfig:
+    """Configuration for model training."""
+    test_seasons: List[str] = field(default_factory=lambda: ["2024-25"])
+    val_seasons: List[str] = field(default_factory=lambda: ["2023-24"])
+    random_state: int = 42
+    
+    # XGBoost defaults
+    xgb_params: dict = field(default_factory=lambda: {
+        "n_estimators": 500,
+        "max_depth": 6,
+        "learning_rate": 0.05,
+        "subsample": 0.8,
+        "colsample_bytree": 0.8,
+        "random_state": 42
+    })
+    
+    # LightGBM defaults
+    lgb_params: dict = field(default_factory=lambda: {
+        "n_estimators": 500,
+        "max_depth": 6,
+        "learning_rate": 0.05,
+        "subsample": 0.8,
+        "colsample_bytree": 0.8,
+        "random_state": 42,
+        "verbose": -1
+    })
+    
+MODEL_CONFIG = ModelConfig()
+
+# =============================================================================
+# TEAM MAPPINGS
+# =============================================================================
+# NBA Team IDs (for reference)
+NBA_TEAMS = {
+    1610612737: "ATL", 1610612738: "BOS", 1610612739: "CLE", 1610612740: "NOP",
+    1610612741: "CHI", 1610612742: "DAL", 1610612743: "DEN", 1610612744: "GSW",
+    1610612745: "HOU", 1610612746: "LAC", 1610612747: "LAL", 1610612748: "MIA",
+    1610612749: "MIL", 1610612750: "MIN", 1610612751: "BKN", 1610612752: "NYK",
+    1610612753: "ORL", 1610612754: "IND", 1610612755: "PHI", 1610612756: "PHX",
+    1610612757: "POR", 1610612758: "SAC", 1610612759: "SAS", 1610612760: "OKC",
+    1610612761: "TOR", 1610612762: "UTA", 1610612763: "MEM", 1610612764: "WAS",
+    1610612765: "DET", 1610612766: "CHA"
+}
+
+# =============================================================================
+# INJURY STATUS WEIGHTS
+# =============================================================================
+INJURY_IMPACT = {
+    "Out": 1.0,  # Full impact - player not available
+    "Doubtful": 0.8,
+    "Questionable": 0.5,
+    "Probable": 0.2,
+    "Available": 0.0
+}

src/continuous_learner.py

@@ -0,0 +1,306 @@
+"""
+NBA ML Prediction System - Continuous Learner
+==============================================
+Handles incremental model updates with new game data.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+import time
+
+import pandas as pd
+import numpy as np
+
+from src.config import (
+    RAW_DATA_DIR, 
+    PROCESSED_DATA_DIR, 
+    MODELS_DIR,
+    SEASON_STRINGS,
+    API_CONFIG
+)
+from src.data_collector import GameDataCollector, TeamDataCollector, PlayerDataCollector, CacheManager
+from src.feature_engineering import FeatureGenerator
+from src.preprocessing import DataPreprocessor
+from src.models.game_predictor import GamePredictor, train_game_predictor
+from src.live_data_collector import LiveDataCollector
+from src.prediction_tracker import PredictionTracker
+
+logger = logging.getLogger(__name__)
+
+
+class ContinuousLearner:
+    """
+    Handles model updates with new game data.
+    
+    Workflow:
+    1. Ingest completed games from live API
+    2. Update raw data files
+    3. Re-run feature engineering
+    4. Retrain model (incremental or full)
+    """
+    
+    def __init__(self):
+        self.game_collector = GameDataCollector()
+        self.live_collector = LiveDataCollector()
+        self.prediction_tracker = PredictionTracker()
+        self.feature_gen = FeatureGenerator()
+        self.cache = CacheManager()
+        
+        # Checkpoint file for tracking last ingested game
+        self.checkpoint_file = PROCESSED_DATA_DIR / "continuous_learning_checkpoint.json"
+    
+    def _load_checkpoint(self) -> Dict:
+        """Load checkpoint of last processed game."""
+        import json
+        if self.checkpoint_file.exists():
+            with open(self.checkpoint_file, 'r') as f:
+                return json.load(f)
+        return {"last_game_date": None, "last_game_ids": []}
+    
+    def _save_checkpoint(self, checkpoint: Dict):
+        """Save checkpoint after processing."""
+        import json
+        with open(self.checkpoint_file, 'w') as f:
+            json.dump(checkpoint, f, indent=2)
+    
+    def ingest_completed_games(self) -> int:
+        """
+        Fetch completed games from live API and add to training data.
+        
+        Returns:
+            Number of new games ingested
+        """
+        logger.info("Checking for completed games to ingest...")
+        
+        # Get completed games from today
+        final_games = self.live_collector.get_final_games()
+        
+        if not final_games:
+            logger.info("No completed games to ingest")
+            return 0
+        
+        # Load checkpoint
+        checkpoint = self._load_checkpoint()
+        processed_ids = set(checkpoint.get("last_game_ids", []))
+        
+        # Filter to new games only
+        new_games = [g for g in final_games if g["game_id"] not in processed_ids]
+        
+        if not new_games:
+            logger.info("All completed games already processed")
+            return 0
+        
+        logger.info(f"Found {len(new_games)} new completed games")
+        
+        # Update prediction tracker with results
+        for game in new_games:
+            winner = game["home_team"] if game["home_score"] > game["away_score"] else game["away_team"]
+            self.prediction_tracker.update_result(
+                game_id=game["game_id"],
+                actual_winner=winner,
+                home_score=game["home_score"],
+                away_score=game["away_score"]
+            )
+            processed_ids.add(game["game_id"])
+        
+        # Append new games to raw data
+        self._append_games_to_raw_data(new_games)
+        
+        # Update checkpoint
+        checkpoint = {
+            "last_game_date": datetime.now().isoformat(),
+            "last_game_ids": list(processed_ids)[-100]  # Keep last 100 IDs
+        }
+        self._save_checkpoint(checkpoint)
+        
+        logger.info(f"Ingested {len(new_games)} new games")
+        return len(new_games)
+    
+    def _append_games_to_raw_data(self, games: List[Dict]):
+        """Append new game data to raw parquet files."""
+        try:
+            # Load existing games
+            games_file = RAW_DATA_DIR / "all_games.parquet"
+            if games_file.exists():
+                existing_df = pd.read_parquet(games_file)
+            else:
+                existing_df = pd.DataFrame()
+            
+            # Convert new games to DataFrame
+            new_rows = []
+            for game in games:
+                new_rows.append({
+                    "GAME_ID": game["game_id"],
+                    "GAME_DATE": game.get("game_date", ""),
+                    "HOME_TEAM_ID": game["home_team_id"],
+                    "VISITOR_TEAM_ID": game["away_team_id"],
+                    "HOME_TEAM_ABBREVIATION": game["home_team"],
+                    "VISITOR_TEAM_ABBREVIATION": game["away_team"],
+                    "PTS_home": game["home_score"],
+                    "PTS_away": game["away_score"],
+                    "HOME_TEAM_WINS": 1 if game["home_score"] > game["away_score"] else 0,
+                    "SEASON_ID": self._get_current_season_id(),
+                })
+            
+            new_df = pd.DataFrame(new_rows)
+            
+            # Append and deduplicate
+            combined_df = pd.concat([existing_df, new_df], ignore_index=True)
+            combined_df = combined_df.drop_duplicates(subset=["GAME_ID"], keep="last")
+            
+            # Save
+            combined_df.to_parquet(games_file, index=False)
+            logger.info(f"Updated raw games data: {len(combined_df)} total games")
+            
+        except Exception as e:
+            logger.error(f"Failed to append games to raw data: {e}")
+    
+    def _get_current_season_id(self) -> str:
+        """Get current NBA season ID."""
+        now = datetime.now()
+        year = now.year if now.month >= 10 else now.year - 1
+        return f"2{year}"  # e.g., "22024" for 2024-25 season
+    
+    def update_features(self) -> bool:
+        """
+        Re-run feature engineering with updated data.
+        
+        Returns:
+            True if successful
+        """
+        logger.info("Updating features with new data...")
+        
+        try:
+            # Re-run feature generation
+            self.feature_gen.process_all_data(force_regenerate=True)
+            logger.info("Feature update complete")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to update features: {e}")
+            return False
+    
+    def retrain_model(self, incremental: bool = True) -> Dict:
+        """
+        Retrain the game prediction model.
+        
+        Args:
+            incremental: If True, use warm start from existing model.
+                        If False, train from scratch.
+        
+        Returns:
+            Dict with training metrics
+        """
+        logger.info(f"Retraining model (incremental={incremental})...")
+        
+        try:
+            import joblib
+            
+            # Load dataset
+            dataset_path = PROCESSED_DATA_DIR / "game_dataset.joblib"
+            if not dataset_path.exists():
+                logger.error("Dataset not found. Run preprocessing first.")
+                return {"error": "Dataset not found"}
+            
+            dataset = joblib.load(dataset_path)
+            
+            # Train model
+            metrics = train_game_predictor(dataset)
+            
+            logger.info(f"Model retrained. Accuracy: {metrics.get('test_accuracy', 0):.2%}")
+            return metrics
+            
+        except Exception as e:
+            logger.error(f"Failed to retrain model: {e}")
+            return {"error": str(e)}
+    
+    def run_update_cycle(self, retrain: bool = True) -> Dict:
+        """
+        Full update cycle: ingest -> features -> retrain.
+        
+        Args:
+            retrain: Whether to retrain model after updating data
+        
+        Returns:
+            Dict with cycle results
+        """
+        logger.info("Starting continuous learning update cycle...")
+        
+        results = {
+            "timestamp": datetime.now().isoformat(),
+            "games_ingested": 0,
+            "features_updated": False,
+            "model_retrained": False,
+            "metrics": {}
+        }
+        
+        # Step 1: Ingest completed games
+        games_ingested = self.ingest_completed_games()
+        results["games_ingested"] = games_ingested
+        
+        if games_ingested == 0:
+            logger.info("No new games to process, skipping update")
+            return results
+        
+        # Step 2: Update features
+        features_updated = self.update_features()
+        results["features_updated"] = features_updated
+        
+        if not features_updated:
+            logger.warning("Feature update failed, skipping retrain")
+            return results
+        
+        # Step 3: Retrain model (if requested)
+        if retrain:
+            # Rebuild dataset
+            preprocessor = DataPreprocessor()
+            preprocessor.build_dataset()
+            
+            # Retrain
+            metrics = self.retrain_model(incremental=True)
+            results["model_retrained"] = "error" not in metrics
+            results["metrics"] = metrics
+        
+        logger.info("Update cycle complete")
+        return results
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    logging.basicConfig(level=logging.INFO)
+    
+    parser = argparse.ArgumentParser(description="NBA Continuous Learning System")
+    parser.add_argument("--ingest", action="store_true", help="Ingest completed games only")
+    parser.add_argument("--update", action="store_true", help="Full update cycle")
+    parser.add_argument("--no-retrain", action="store_true", help="Skip model retraining")
+    
+    args = parser.parse_args()
+    
+    learner = ContinuousLearner()
+    
+    if args.ingest:
+        print("\n=== Ingesting Completed Games ===\n")
+        count = learner.ingest_completed_games()
+        print(f"Ingested {count} new games")
+    
+    elif args.update:
+        print("\n=== Running Update Cycle ===\n")
+        results = learner.run_update_cycle(retrain=not args.no_retrain)
+        print(f"Games ingested: {results['games_ingested']}")
+        print(f"Features updated: {results['features_updated']}")
+        print(f"Model retrained: {results['model_retrained']}")
+        if results['metrics']:
+            print(f"Test accuracy: {results['metrics'].get('test_accuracy', 'N/A')}")
+    
+    else:
+        print("Use --ingest or --update")
+        print("\nUsage:")
+        print("  python -m src.continuous_learner --ingest")
+        print("  python -m src.continuous_learner --update")
+        print("  python -m src.continuous_learner --update --no-retrain")

src/data_collector.py

@@ -0,0 +1,649 @@
+"""
+NBA ML Prediction System - Comprehensive Data Collector
+========================================================
+Full data collection from NBA API with all available endpoints:
+- Games, Team Stats, Player Stats (basic)
+- Advanced Metrics, Clutch Stats, Hustle Stats
+- Box Scores, Standings, Play Types
+"""
+
+import time
+import json
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from tqdm import tqdm
+import logging
+
+from nba_api.stats.endpoints import (
+    # Basic endpoints
+    leaguegamefinder,
+    leaguestandings,
+    leaguedashteamstats,
+    leaguedashplayerstats,
+    playergamelog,
+    boxscoretraditionalv2,
+    boxscoreadvancedv2,
+    leagueleaders,
+    # Advanced endpoints
+    teamestimatedmetrics,
+    playerestimatedmetrics,
+    leaguedashteamclutch,
+    leaguedashplayerclutch,
+    leaguehustlestatsteam,
+    leaguehustlestatsplayer,
+    leaguedashptteamdefend,
+    leaguedashptstats,
+    leaguestandingsv3,
+    teamyearbyyearstats,
+    # Box score variants
+    boxscoremiscv2,
+    boxscorescoringv2,
+    boxscoreusagev2,
+    # Shooting
+    leaguedashteamptshot,
+    leaguedashplayerptshot,
+)
+from nba_api.stats.static import teams, players
+
+from src.config import (
+    API_CONFIG, 
+    SEASON_STRINGS, 
+    API_CACHE_DIR, 
+    RAW_DATA_DIR,
+    NBA_TEAMS
+)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# RETRY DECORATOR WITH EXPONENTIAL BACKOFF
+# =============================================================================
+def retry_with_backoff(func):
+    """Decorator to retry API calls with exponential backoff."""
+    def wrapper(*args, **kwargs):
+        backoff = API_CONFIG.initial_backoff
+        last_exception = None
+        
+        for attempt in range(API_CONFIG.max_retries + 1):
+            try:
+                time.sleep(API_CONFIG.base_delay)
+                return func(*args, **kwargs)
+            except Exception as e:
+                last_exception = e
+                if attempt < API_CONFIG.max_retries:
+                    logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {backoff}s...")
+                    time.sleep(backoff)
+                    backoff = min(backoff * API_CONFIG.backoff_multiplier, API_CONFIG.max_backoff)
+                else:
+                    logger.error(f"All {API_CONFIG.max_retries + 1} attempts failed for {func.__name__}")
+        
+        raise last_exception
+    return wrapper
+
+
+# =============================================================================
+# CACHE MANAGER
+# =============================================================================
+class CacheManager:
+    """Manages caching of API responses with per-endpoint, per-season storage."""
+    
+    def __init__(self, cache_dir: Path = API_CACHE_DIR):
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.checkpoint_file = cache_dir / "checkpoint.json"
+    
+    def get_cache_path(self, endpoint: str, season: str, entity_id: Optional[str] = None) -> Path:
+        if entity_id:
+            return self.cache_dir / f"{endpoint}_{season}_{entity_id}.parquet"
+        return self.cache_dir / f"{endpoint}_{season}.parquet"
+    
+    def is_cached(self, endpoint: str, season: str, entity_id: Optional[str] = None) -> bool:
+        return self.get_cache_path(endpoint, season, entity_id).exists()
+    
+    def load_cached(self, endpoint: str, season: str, entity_id: Optional[str] = None) -> Optional[pd.DataFrame]:
+        cache_path = self.get_cache_path(endpoint, season, entity_id)
+        if cache_path.exists():
+            return pd.read_parquet(cache_path)
+        return None
+    
+    def save_to_cache(self, df: pd.DataFrame, endpoint: str, season: str, entity_id: Optional[str] = None):
+        cache_path = self.get_cache_path(endpoint, season, entity_id)
+        df.to_parquet(cache_path, index=False)
+        logger.info(f"Cached {len(df)} rows to {cache_path.name}")
+    
+    def load_checkpoint(self) -> Dict[str, Any]:
+        if self.checkpoint_file.exists():
+            with open(self.checkpoint_file, 'r') as f:
+                return json.load(f)
+        return {"completed_seasons": [], "last_endpoint": None, "last_season": None}
+    
+    def save_checkpoint(self, checkpoint: Dict[str, Any]):
+        with open(self.checkpoint_file, 'w') as f:
+            json.dump(checkpoint, f, indent=2)
+    
+    def mark_season_complete(self, endpoint: str, season: str):
+        checkpoint = self.load_checkpoint()
+        key = f"{endpoint}_{season}"
+        if key not in checkpoint["completed_seasons"]:
+            checkpoint["completed_seasons"].append(key)
+        checkpoint["last_endpoint"] = endpoint
+        checkpoint["last_season"] = season
+        self.save_checkpoint(checkpoint)
+    
+    def is_season_complete(self, endpoint: str, season: str) -> bool:
+        checkpoint = self.load_checkpoint()
+        return f"{endpoint}_{season}" in checkpoint["completed_seasons"]
+
+
+# =============================================================================
+# GAME DATA COLLECTOR
+# =============================================================================
+class GameDataCollector:
+    """Collects game-level data."""
+    
+    def __init__(self):
+        self.cache = CacheManager()
+    
+    @retry_with_backoff
+    def _fetch_season_games(self, season: str) -> pd.DataFrame:
+        games = leaguegamefinder.LeagueGameFinder(
+            season_nullable=season,
+            league_id_nullable="00"
+        )
+        return games.get_data_frames()[0]
+    
+    def get_season_games(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("games", season):
+            logger.info(f"Loading cached games for {season}")
+            return self.cache.load_cached("games", season)
+        
+        logger.info(f"Fetching games for {season} from API...")
+        df = self._fetch_season_games(season)
+        self.cache.save_to_cache(df, "games", season)
+        self.cache.mark_season_complete("games", season)
+        return df
+    
+    def collect_all_seasons(self, seasons: List[str] = None, force_refresh: bool = False) -> pd.DataFrame:
+        if seasons is None:
+            seasons = SEASON_STRINGS
+        
+        all_games = []
+        for season in tqdm(seasons, desc="Collecting games"):
+            if not force_refresh and self.cache.is_season_complete("games", season):
+                df = self.cache.load_cached("games", season)
+            else:
+                df = self.get_season_games(season, force_refresh)
+            all_games.append(df)
+        
+        combined = pd.concat(all_games, ignore_index=True)
+        combined.to_parquet(RAW_DATA_DIR / "all_games.parquet", index=False)
+        logger.info(f"Saved {len(combined)} total games to all_games.parquet")
+        return combined
+
+
+# =============================================================================
+# TEAM DATA COLLECTOR (ENHANCED)
+# =============================================================================
+class TeamDataCollector:
+    """Collects comprehensive team statistics."""
+    
+    def __init__(self):
+        self.cache = CacheManager()
+    
+    @retry_with_backoff
+    def _fetch_team_stats(self, season: str) -> pd.DataFrame:
+        stats = leaguedashteamstats.LeagueDashTeamStats(
+            season=season,
+            per_mode_detailed="PerGame"
+        )
+        return stats.get_data_frames()[0]
+    
+    @retry_with_backoff
+    def _fetch_team_advanced(self, season: str) -> pd.DataFrame:
+        """Fetch advanced team metrics: NET_RTG, PACE, PIE, TS%, eFG%"""
+        try:
+            stats = teamestimatedmetrics.TeamEstimatedMetrics(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"TeamEstimatedMetrics failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_team_clutch(self, season: str) -> pd.DataFrame:
+        """Fetch clutch stats: performance in close games"""
+        try:
+            stats = leaguedashteamclutch.LeagueDashTeamClutch(
+                season=season,
+                clutch_time="Last 5 Minutes",
+                point_diff=5
+            )
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Team clutch stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_team_hustle(self, season: str) -> pd.DataFrame:
+        """Fetch hustle stats: deflections, loose balls, charges"""
+        try:
+            stats = leaguehustlestatsteam.LeagueHustleStatsTeam(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Team hustle stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_team_defense(self, season: str) -> pd.DataFrame:
+        """Fetch defensive stats"""
+        try:
+            stats = leaguedashptteamdefend.LeagueDashPtTeamDefend(
+                season=season,
+                defense_category="Overall"
+            )
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Team defense stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_team_shooting(self, season: str) -> pd.DataFrame:
+        """Fetch team shooting stats"""
+        try:
+            stats = leaguedashteamptshot.LeagueDashTeamPtShot(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Team shooting stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_standings(self, season: str) -> pd.DataFrame:
+        """Fetch standings with win streaks"""
+        try:
+            standings = leaguestandingsv3.LeagueStandingsV3(
+                season=season,
+                league_id="00"
+            )
+            return standings.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Standings failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    def get_team_stats(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("team_stats", season):
+            logger.info(f"Loading cached team stats for {season}")
+            return self.cache.load_cached("team_stats", season)
+        
+        logger.info(f"Fetching team stats for {season}...")
+        df = self._fetch_team_stats(season)
+        self.cache.save_to_cache(df, "team_stats", season)
+        return df
+    
+    def get_team_advanced(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("team_advanced", season):
+            return self.cache.load_cached("team_advanced", season)
+        
+        logger.info(f"Fetching team advanced metrics for {season}...")
+        df = self._fetch_team_advanced(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "team_advanced", season)
+        return df
+    
+    def get_team_clutch(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("team_clutch", season):
+            return self.cache.load_cached("team_clutch", season)
+        
+        logger.info(f"Fetching team clutch stats for {season}...")
+        df = self._fetch_team_clutch(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "team_clutch", season)
+        return df
+    
+    def get_team_hustle(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("team_hustle", season):
+            return self.cache.load_cached("team_hustle", season)
+        
+        logger.info(f"Fetching team hustle stats for {season}...")
+        df = self._fetch_team_hustle(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "team_hustle", season)
+        return df
+    
+    def get_team_defense(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("team_defense", season):
+            return self.cache.load_cached("team_defense", season)
+        
+        logger.info(f"Fetching team defense stats for {season}...")
+        df = self._fetch_team_defense(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "team_defense", season)
+        return df
+    
+    def get_standings(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("standings", season):
+            return self.cache.load_cached("standings", season)
+        
+        logger.info(f"Fetching standings for {season}...")
+        df = self._fetch_standings(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "standings", season)
+        return df
+    
+    def collect_all_seasons(self, seasons: List[str] = None, force_refresh: bool = False) -> Dict[str, pd.DataFrame]:
+        if seasons is None:
+            seasons = SEASON_STRINGS
+        
+        results = {
+            "team_stats": [],
+            "team_advanced": [],
+            "team_clutch": [],
+            "team_hustle": [],
+            "team_defense": [],
+            "standings": []
+        }
+        
+        for season in tqdm(seasons, desc="Collecting team data"):
+            # Basic stats
+            df = self.get_team_stats(season, force_refresh)
+            df["SEASON"] = season
+            results["team_stats"].append(df)
+            
+            # Advanced metrics
+            df = self.get_team_advanced(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["team_advanced"].append(df)
+            
+            # Clutch stats
+            df = self.get_team_clutch(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["team_clutch"].append(df)
+            
+            # Hustle stats
+            df = self.get_team_hustle(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["team_hustle"].append(df)
+            
+            # Defense stats
+            df = self.get_team_defense(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["team_defense"].append(df)
+            
+            # Standings
+            df = self.get_standings(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["standings"].append(df)
+        
+        # Save all combined data
+        for key, data in results.items():
+            if data:
+                combined = pd.concat(data, ignore_index=True)
+                combined.to_parquet(RAW_DATA_DIR / f"all_{key}.parquet", index=False)
+                logger.info(f"Saved {len(combined)} rows to all_{key}.parquet")
+        
+        return results
+
+
+# =============================================================================
+# PLAYER DATA COLLECTOR (ENHANCED)
+# =============================================================================
+class PlayerDataCollector:
+    """Collects comprehensive player statistics."""
+    
+    def __init__(self):
+        self.cache = CacheManager()
+    
+    @retry_with_backoff
+    def _fetch_player_stats(self, season: str) -> pd.DataFrame:
+        stats = leaguedashplayerstats.LeagueDashPlayerStats(
+            season=season,
+            per_mode_detailed="PerGame"
+        )
+        return stats.get_data_frames()[0]
+    
+    @retry_with_backoff
+    def _fetch_player_advanced(self, season: str) -> pd.DataFrame:
+        """Fetch advanced player metrics: PER, USG%, TS%, eFG%"""
+        try:
+            stats = playerestimatedmetrics.PlayerEstimatedMetrics(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"PlayerEstimatedMetrics failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_player_clutch(self, season: str) -> pd.DataFrame:
+        """Fetch player clutch stats"""
+        try:
+            stats = leaguedashplayerclutch.LeagueDashPlayerClutch(
+                season=season,
+                clutch_time="Last 5 Minutes",
+                point_diff=5
+            )
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Player clutch stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_player_hustle(self, season: str) -> pd.DataFrame:
+        """Fetch player hustle stats"""
+        try:
+            stats = leaguehustlestatsplayer.LeagueHustleStatsPlayer(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Player hustle stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    @retry_with_backoff
+    def _fetch_player_shooting(self, season: str) -> pd.DataFrame:
+        """Fetch player shooting stats"""
+        try:
+            stats = leaguedashplayerptshot.LeagueDashPlayerPtShot(season=season)
+            return stats.get_data_frames()[0]
+        except Exception as e:
+            logger.warning(f"Player shooting stats failed for {season}: {e}")
+            return pd.DataFrame()
+    
+    def get_player_stats(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("player_stats", season):
+            logger.info(f"Loading cached player stats for {season}")
+            return self.cache.load_cached("player_stats", season)
+        
+        logger.info(f"Fetching player stats for {season}...")
+        df = self._fetch_player_stats(season)
+        self.cache.save_to_cache(df, "player_stats", season)
+        return df
+    
+    def get_player_advanced(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("player_advanced", season):
+            return self.cache.load_cached("player_advanced", season)
+        
+        logger.info(f"Fetching player advanced metrics for {season}...")
+        df = self._fetch_player_advanced(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "player_advanced", season)
+        return df
+    
+    def get_player_clutch(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("player_clutch", season):
+            return self.cache.load_cached("player_clutch", season)
+        
+        logger.info(f"Fetching player clutch stats for {season}...")
+        df = self._fetch_player_clutch(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "player_clutch", season)
+        return df
+    
+    def get_player_hustle(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("player_hustle", season):
+            return self.cache.load_cached("player_hustle", season)
+        
+        logger.info(f"Fetching player hustle stats for {season}...")
+        df = self._fetch_player_hustle(season)
+        if not df.empty:
+            self.cache.save_to_cache(df, "player_hustle", season)
+        return df
+    
+    def collect_all_seasons(self, seasons: List[str] = None, force_refresh: bool = False) -> Dict[str, pd.DataFrame]:
+        if seasons is None:
+            seasons = SEASON_STRINGS
+        
+        results = {
+            "player_stats": [],
+            "player_advanced": [],
+            "player_clutch": [],
+            "player_hustle": []
+        }
+        
+        for season in tqdm(seasons, desc="Collecting player data"):
+            # Basic stats
+            df = self.get_player_stats(season, force_refresh)
+            df["SEASON"] = season
+            results["player_stats"].append(df)
+            
+            # Advanced metrics
+            df = self.get_player_advanced(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["player_advanced"].append(df)
+            
+            # Clutch stats
+            df = self.get_player_clutch(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["player_clutch"].append(df)
+            
+            # Hustle stats
+            df = self.get_player_hustle(season, force_refresh)
+            if not df.empty:
+                df["SEASON"] = season
+                results["player_hustle"].append(df)
+        
+        # Save all combined data
+        for key, data in results.items():
+            if data:
+                combined = pd.concat(data, ignore_index=True)
+                combined.to_parquet(RAW_DATA_DIR / f"all_{key}.parquet", index=False)
+                logger.info(f"Saved {len(combined)} rows to all_{key}.parquet")
+        
+        return results
+
+
+# =============================================================================
+# LEAGUE LEADERS COLLECTOR
+# =============================================================================
+class LeagueLeadersCollector:
+    """Collects league leaders data."""
+    
+    def __init__(self):
+        self.cache = CacheManager()
+    
+    @retry_with_backoff
+    def _fetch_leaders(self, season: str, stat_category: str = "PTS") -> pd.DataFrame:
+        leaders = leagueleaders.LeagueLeaders(
+            season=season,
+            stat_category_abbreviation=stat_category
+        )
+        return leaders.get_data_frames()[0]
+    
+    def get_leaders(self, season: str, force_refresh: bool = False) -> pd.DataFrame:
+        if not force_refresh and self.cache.is_cached("leaders", season):
+            return self.cache.load_cached("leaders", season)
+        
+        logger.info(f"Fetching league leaders for {season}...")
+        df = self._fetch_leaders(season)
+        self.cache.save_to_cache(df, "leaders", season)
+        return df
+
+
+# =============================================================================
+# MASTER COLLECTOR
+# =============================================================================
+class NBADataCollector:
+    """Master collector that orchestrates ALL data collection."""
+    
+    def __init__(self):
+        self.games = GameDataCollector()
+        self.teams = TeamDataCollector()
+        self.players = PlayerDataCollector()
+        self.leaders = LeagueLeadersCollector()
+        self.cache = CacheManager()
+    
+    def collect_all(self, seasons: List[str] = None, force_refresh: bool = False):
+        """Collect ALL data for specified seasons."""
+        if seasons is None:
+            seasons = SEASON_STRINGS
+        
+        logger.info(f"Starting COMPREHENSIVE data collection for {len(seasons)} seasons...")
+        logger.info(f"Seasons: {seasons[0]} to {seasons[-1]}")
+        logger.info("This will take several hours. Data is cached, so it can resume if interrupted.\n")
+        
+        # Collect games
+        logger.info("=" * 50)
+        logger.info("=== PHASE 1: Collecting Games ===")
+        logger.info("=" * 50)
+        self.games.collect_all_seasons(seasons, force_refresh)
+        
+        # Collect team stats (all types)
+        logger.info("\n" + "=" * 50)
+        logger.info("=== PHASE 2: Collecting Team Stats (6 data types) ===")
+        logger.info("=" * 50)
+        self.teams.collect_all_seasons(seasons, force_refresh)
+        
+        # Collect player stats (all types)
+        logger.info("\n" + "=" * 50)
+        logger.info("=== PHASE 3: Collecting Player Stats (4 data types) ===")
+        logger.info("=" * 50)
+        self.players.collect_all_seasons(seasons, force_refresh)
+        
+        logger.info("\n" + "=" * 50)
+        logger.info("=== DATA COLLECTION COMPLETE ===")
+        logger.info("=" * 50)
+        logger.info(f"Data saved to: {RAW_DATA_DIR}")
+        
+        # List all generated files
+        parquet_files = list(RAW_DATA_DIR.glob("*.parquet"))
+        logger.info(f"\nGenerated {len(parquet_files)} data files:")
+        for f in parquet_files:
+            size_mb = f.stat().st_size / (1024 * 1024)
+            logger.info(f"  - {f.name} ({size_mb:.2f} MB)")
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="NBA Comprehensive Data Collector")
+    parser.add_argument("--seasons", nargs="+", help="Specific seasons to collect (e.g., 2023-24)")
+    parser.add_argument("--force", action="store_true", help="Force refresh, ignore cache")
+    parser.add_argument("--games-only", action="store_true", help="Only collect games")
+    parser.add_argument("--teams-only", action="store_true", help="Only collect team stats")
+    parser.add_argument("--players-only", action="store_true", help="Only collect player stats")
+    parser.add_argument("--test", action="store_true", help="Test with single season")
+    
+    args = parser.parse_args()
+    
+    collector = NBADataCollector()
+    
+    if args.test:
+        print("Running in test mode (single season 2024-25)...")
+        collector.collect_all(["2024-25"], args.force)
+        print("Test complete!")
+    elif args.games_only:
+        collector.games.collect_all_seasons(args.seasons, args.force)
+    elif args.teams_only:
+        collector.teams.collect_all_seasons(args.seasons, args.force)
+    elif args.players_only:
+        collector.players.collect_all_seasons(args.seasons, args.force)
+    else:
+        collector.collect_all(args.seasons, args.force)

src/feature_engineering.py

@@ -0,0 +1,695 @@
+"""
+NBA ML Prediction System - Comprehensive Feature Engineering
+=============================================================
+Time-aware feature generation using ALL available stats:
+- ELO ratings
+- Era normalization (Z-score by season)
+- Rolling averages (basic + advanced)
+- Clutch performance
+- Hustle metrics
+- Defensive ratings
+- Data leakage prevention
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+import logging
+
+from src.config import (
+    ELO_CONFIG, 
+    FEATURE_CONFIG, 
+    RAW_DATA_DIR, 
+    PROCESSED_DATA_DIR,
+    NBA_TEAMS
+)
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# ALL STAT COLUMNS BY CATEGORY
+# =============================================================================
+BASIC_STATS = ["PTS", "AST", "REB", "STL", "BLK", "TOV", "FGM", "FGA", "FG_PCT", 
+               "FG3M", "FG3A", "FG3_PCT", "FTM", "FTA", "FT_PCT", "OREB", "DREB"]
+
+ADVANCED_STATS = ["E_OFF_RATING", "E_DEF_RATING", "E_NET_RATING", "E_PACE", 
+                  "E_AST_RATIO", "E_OREB_PCT", "E_DREB_PCT", "E_REB_PCT", 
+                  "E_TM_TOV_PCT", "E_EFG_PCT", "E_TS_PCT"]
+
+CLUTCH_STATS = ["CLUTCH_PTS", "CLUTCH_FG_PCT", "CLUTCH_FG3_PCT", "CLUTCH_PLUS_MINUS"]
+
+HUSTLE_STATS = ["DEFLECTIONS", "LOOSE_BALLS_RECOVERED", "CHARGES_DRAWN", 
+                "CONTESTED_SHOTS", "SCREEN_ASSISTS"]
+
+
+# =============================================================================
+# ELO RATING SYSTEM
+# =============================================================================
+class ELOCalculator:
+    """
+    Calculates ELO ratings for NBA teams.
+    ELO is extremely predictive in sports - can add +3-5% accuracy.
+    """
+    
+    def __init__(self, config=ELO_CONFIG):
+        self.initial_rating = config.initial_rating
+        self.k_factor = config.k_factor
+        self.home_advantage = config.home_advantage
+        self.season_regression = config.season_regression
+        self.ratings: Dict[int, float] = {}
+    
+    def reset_ratings(self):
+        self.ratings = {}
+    
+    def get_rating(self, team_id: int) -> float:
+        if team_id not in self.ratings:
+            self.ratings[team_id] = self.initial_rating
+        return self.ratings[team_id]
+    
+    def regress_to_mean(self):
+        mean_rating = np.mean(list(self.ratings.values())) if self.ratings else self.initial_rating
+        for team_id in self.ratings:
+            self.ratings[team_id] = (
+                self.season_regression * mean_rating + 
+                (1 - self.season_regression) * self.ratings[team_id]
+            )
+    
+    def expected_win_probability(self, team_rating: float, opponent_rating: float, 
+                                  is_home: bool = False) -> float:
+        rating_diff = team_rating - opponent_rating
+        if is_home:
+            rating_diff += self.home_advantage
+        return 1.0 / (1.0 + 10 ** (-rating_diff / 400))
+    
+    def update_ratings(self, team_id: int, opponent_id: int, 
+                       won: bool, is_home: bool = False) -> Tuple[float, float]:
+        team_rating = self.get_rating(team_id)
+        opponent_rating = self.get_rating(opponent_id)
+        
+        expected = self.expected_win_probability(team_rating, opponent_rating, is_home)
+        actual = 1.0 if won else 0.0
+        
+        delta = self.k_factor * (actual - expected)
+        self.ratings[team_id] = team_rating + delta
+        self.ratings[opponent_id] = opponent_rating - delta
+        
+        return self.ratings[team_id], self.ratings[opponent_id]
+    
+    def calculate_game_features(self, team_id: int, opponent_id: int, 
+                                 is_home: bool) -> Dict[str, float]:
+        team_elo = self.get_rating(team_id)
+        opponent_elo = self.get_rating(opponent_id)
+        
+        return {
+            "team_elo": team_elo,
+            "opponent_elo": opponent_elo,
+            "elo_diff": team_elo - opponent_elo,
+            "elo_win_prob": self.expected_win_probability(team_elo, opponent_elo, is_home),
+            "home_elo_boost": self.home_advantage if is_home else 0
+        }
+
+
+# =============================================================================
+# ERA NORMALIZATION
+# =============================================================================
+class EraNormalizer:
+    """Z-score normalization within season to handle era differences."""
+    
+    def __init__(self):
+        self.season_stats: Dict[str, Dict[str, Tuple[float, float]]] = {}
+    
+    def fit_season(self, df: pd.DataFrame, season: str, stat_columns: List[str]):
+        self.season_stats[season] = {}
+        for col in stat_columns:
+            if col in df.columns:
+                mean = df[col].mean()
+                std = df[col].std()
+                self.season_stats[season][col] = (mean, std if std > 0 else 1.0)
+    
+    def transform(self, df: pd.DataFrame, season: str, stat_columns: List[str]) -> pd.DataFrame:
+        df = df.copy()
+        if season not in self.season_stats:
+            return df
+        
+        for col in stat_columns:
+            if col in df.columns and col in self.season_stats[season]:
+                mean, std = self.season_stats[season][col]
+                df[f"{col}_zscore"] = (df[col] - mean) / std
+        
+        return df
+
+
+# =============================================================================
+# COMPREHENSIVE STAT LOADER
+# =============================================================================
+class StatLoader:
+    """Loads and merges all collected stats for a team/player."""
+    
+    def __init__(self):
+        self.team_stats = None
+        self.team_advanced = None
+        self.team_clutch = None
+        self.team_hustle = None
+        self.team_defense = None
+        self.player_stats = None
+        self.player_advanced = None
+        self._loaded = False
+    
+    def load_all_stats(self):
+        """Load all available stat files."""
+        if self._loaded:
+            return
+        
+        logger.info("Loading all stat files...")
+        
+        # Team stats
+        try:
+            self.team_stats = pd.read_parquet(RAW_DATA_DIR / "all_team_stats.parquet")
+            logger.info(f"  Loaded team_stats: {len(self.team_stats)} rows")
+        except:
+            self.team_stats = pd.DataFrame()
+        
+        try:
+            self.team_advanced = pd.read_parquet(RAW_DATA_DIR / "all_team_advanced.parquet")
+            logger.info(f"  Loaded team_advanced: {len(self.team_advanced)} rows")
+        except:
+            self.team_advanced = pd.DataFrame()
+        
+        try:
+            self.team_clutch = pd.read_parquet(RAW_DATA_DIR / "all_team_clutch.parquet")
+            logger.info(f"  Loaded team_clutch: {len(self.team_clutch)} rows")
+        except:
+            self.team_clutch = pd.DataFrame()
+        
+        try:
+            self.team_hustle = pd.read_parquet(RAW_DATA_DIR / "all_team_hustle.parquet")
+            logger.info(f"  Loaded team_hustle: {len(self.team_hustle)} rows")
+        except:
+            self.team_hustle = pd.DataFrame()
+        
+        try:
+            self.team_defense = pd.read_parquet(RAW_DATA_DIR / "all_team_defense.parquet")
+            logger.info(f"  Loaded team_defense: {len(self.team_defense)} rows")
+        except:
+            self.team_defense = pd.DataFrame()
+        
+        # Player stats
+        try:
+            self.player_stats = pd.read_parquet(RAW_DATA_DIR / "all_player_stats.parquet")
+            logger.info(f"  Loaded player_stats: {len(self.player_stats)} rows")
+        except:
+            self.player_stats = pd.DataFrame()
+        
+        try:
+            self.player_advanced = pd.read_parquet(RAW_DATA_DIR / "all_player_advanced.parquet")
+            logger.info(f"  Loaded player_advanced: {len(self.player_advanced)} rows")
+        except:
+            self.player_advanced = pd.DataFrame()
+        
+        self._loaded = True
+    
+    def get_team_season_stats(self, team_id: int, season: str) -> Dict[str, float]:
+        """Get all stats for a team in a season."""
+        self.load_all_stats()
+        
+        features = {}
+        
+        # Basic team stats
+        if not self.team_stats.empty:
+            mask = (self.team_stats["TEAM_ID"] == team_id) & (self.team_stats["SEASON"] == season)
+            row = self.team_stats[mask]
+            if not row.empty:
+                row = row.iloc[0]
+                for col in BASIC_STATS:
+                    if col in row.index:
+                        features[f"team_{col}"] = row[col]
+        
+        # Advanced metrics
+        if not self.team_advanced.empty:
+            mask = (self.team_advanced["TEAM_ID"] == team_id) & (self.team_advanced["SEASON"] == season)
+            row = self.team_advanced[mask]
+            if not row.empty:
+                row = row.iloc[0]
+                for col in ADVANCED_STATS:
+                    if col in row.index:
+                        features[f"team_{col}"] = row[col]
+        
+        # Clutch stats
+        if not self.team_clutch.empty:
+            mask = (self.team_clutch["TEAM_ID"] == team_id) & (self.team_clutch["SEASON"] == season)
+            row = self.team_clutch[mask]
+            if not row.empty:
+                row = row.iloc[0]
+                features["team_clutch_pts"] = row.get("PTS", 0)
+                features["team_clutch_fg_pct"] = row.get("FG_PCT", 0)
+                features["team_clutch_plus_minus"] = row.get("PLUS_MINUS", 0)
+        
+        # Hustle stats
+        if not self.team_hustle.empty:
+            mask = (self.team_hustle["TEAM_ID"] == team_id) & (self.team_hustle["SEASON"] == season)
+            row = self.team_hustle[mask]
+            if not row.empty:
+                row = row.iloc[0]
+                for col in ["DEFLECTIONS", "LOOSE_BALLS_RECOVERED", "CHARGES_DRAWN", 
+                           "CONTESTED_SHOTS_2PT", "CONTESTED_SHOTS_3PT"]:
+                    if col in row.index:
+                        features[f"team_{col.lower()}"] = row[col]
+        
+        return features
+    
+    def get_team_top_players_stats(self, team_id: int, season: str, top_n: int = 5) -> Dict[str, float]:
+        """Get aggregated stats for top N players on a team."""
+        self.load_all_stats()
+        
+        features = {}
+        
+        if self.player_stats.empty:
+            return features
+        
+        # Get team's players for the season
+        mask = (self.player_stats["TEAM_ID"] == team_id) & (self.player_stats["SEASON"] == season)
+        team_players = self.player_stats[mask].copy()
+        
+        if team_players.empty:
+            return features
+        
+        # Sort by minutes and get top players
+        if "MIN" in team_players.columns:
+            team_players = team_players.sort_values("MIN", ascending=False).head(top_n)
+        
+        # Aggregate stats
+        features["top_players_avg_pts"] = team_players["PTS"].mean() if "PTS" in team_players.columns else 0
+        features["top_players_avg_ast"] = team_players["AST"].mean() if "AST" in team_players.columns else 0
+        features["top_players_avg_reb"] = team_players["REB"].mean() if "REB" in team_players.columns else 0
+        features["top_players_avg_stl"] = team_players["STL"].mean() if "STL" in team_players.columns else 0
+        features["top_players_avg_blk"] = team_players["BLK"].mean() if "BLK" in team_players.columns else 0
+        
+        # Star player concentration (how much does top player score vs team)
+        if "PTS" in team_players.columns and len(team_players) > 0:
+            top_scorer_pts = team_players["PTS"].max()
+            total_pts = team_players["PTS"].sum()
+            features["star_concentration"] = top_scorer_pts / total_pts if total_pts > 0 else 0
+        
+        return features
+
+
+# =============================================================================
+# COMPREHENSIVE FEATURE GENERATOR
+# =============================================================================
+class FeatureGenerator:
+    """Generates ALL features with strict data leakage prevention."""
+    
+    def __init__(self, config=FEATURE_CONFIG):
+        self.rolling_windows = config.rolling_windows
+        self.min_games = config.min_games_for_features
+        self.elo = ELOCalculator()
+        self.normalizer = EraNormalizer()
+        self.stat_loader = StatLoader()
+    
+    # League-average fills for cold-start handling (typical NBA averages)
+    LEAGUE_AVERAGES = {
+        "PTS": 112.0,
+        "AST": 25.0,
+        "REB": 44.0,
+        "FG_PCT": 0.465,
+        "FG3_PCT": 0.360,
+        "FT_PCT": 0.780,
+        "PLUS_MINUS": 0.0,
+        "STL": 7.5,
+        "BLK": 5.0,
+        "DREB": 34.0,
+    }
+    
+    def calculate_rolling_stats(self, team_games: pd.DataFrame, 
+                                 current_date: datetime,
+                                 stat_columns: List[str]) -> Dict[str, float]:
+        """
+        Calculate rolling averages (time-aware) with cold-start handling.
+        
+        For early-season games with insufficient history, uses league-average
+        fills instead of NaN to maintain prediction quality.
+        """
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        past_games = past_games.sort_values("GAME_DATE", ascending=False)
+        
+        features = {}
+        games_available = len(past_games)
+        
+        for window in self.rolling_windows:
+            recent_games = past_games.head(window)
+            
+            if len(recent_games) < self.min_games:
+                # Cold-start: Use league averages instead of NaN
+                for col in stat_columns:
+                    league_avg = self.LEAGUE_AVERAGES.get(col, 0)
+                    
+                    if games_available > 0 and col in past_games.columns:
+                        # Blend available data with league average
+                        # Weight: available_games / min_games
+                        blend_weight = games_available / self.min_games
+                        team_avg = past_games.head(games_available)[col].mean()
+                        features[f"{col}_last{window}"] = (
+                            blend_weight * team_avg + 
+                            (1 - blend_weight) * league_avg
+                        )
+                    else:
+                        features[f"{col}_last{window}"] = league_avg
+            else:
+                for col in stat_columns:
+                    if col in recent_games.columns:
+                        features[f"{col}_last{window}"] = recent_games[col].mean()
+                    else:
+                        features[f"{col}_last{window}"] = self.LEAGUE_AVERAGES.get(col, 0)
+        
+        return features
+    
+    def calculate_defensive_stats(self, team_games: pd.DataFrame,
+                                   current_date: datetime) -> Dict[str, float]:
+        """Calculate defensive rolling stats."""
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        past_games = past_games.sort_values("GAME_DATE", ascending=False).head(10)
+        
+        features = {}
+        
+        if len(past_games) >= 3:
+            for col in ["STL", "BLK", "DREB"]:
+                if col in past_games.columns:
+                    features[f"{col}_last10"] = past_games[col].mean()
+            
+            # Points allowed (opponent points)
+            # This would need opponent data, so we estimate from +/-
+            if "PLUS_MINUS" in past_games.columns and "PTS" in past_games.columns:
+                features["pts_allowed_last10"] = past_games["PTS"].mean() - past_games["PLUS_MINUS"].mean()
+        
+        return features
+    
+    def calculate_season_stats(self, team_games: pd.DataFrame,
+                                current_date: datetime,
+                                stat_columns: List[str]) -> Dict[str, float]:
+        """Calculate season-to-date stats (time-aware)."""
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        
+        features = {}
+        for col in stat_columns:
+            if col in past_games.columns:
+                features[f"{col}_season_avg"] = past_games[col].mean()
+        
+        # Win percentage
+        if "WL" in past_games.columns:
+            wins = (past_games["WL"] == "W").sum()
+            total = len(past_games)
+            features["win_pct_season"] = wins / total if total > 0 else 0.5
+            features["games_played"] = total
+        
+        return features
+    
+    def calculate_momentum(self, team_games: pd.DataFrame,
+                           current_date: datetime) -> Dict[str, float]:
+        """Calculate momentum features (streaks, recent form)."""
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        past_games = past_games.sort_values("GAME_DATE", ascending=False)
+        
+        features = {}
+        
+        if len(past_games) >= 5:
+            last5 = past_games.head(5)
+            
+            # Win streak
+            wins_last5 = (last5["WL"] == "W").sum() if "WL" in last5.columns else 0
+            features["wins_last5"] = wins_last5
+            features["hot_streak"] = 1 if wins_last5 >= 4 else 0
+            features["cold_streak"] = 1 if wins_last5 <= 1 else 0
+            
+            # Point differential trend
+            if "PLUS_MINUS" in last5.columns:
+                features["plus_minus_last5"] = last5["PLUS_MINUS"].mean()
+        
+        if len(past_games) >= 10:
+            last10 = past_games.head(10)
+            wins_last10 = (last10["WL"] == "W").sum() if "WL" in last10.columns else 0
+            features["wins_last10"] = wins_last10
+        
+        return features
+    
+    def calculate_rest_fatigue(self, team_games: pd.DataFrame,
+                                current_date: datetime) -> Dict[str, float]:
+        """Calculate rest and fatigue features."""
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        past_games = past_games.sort_values("GAME_DATE", ascending=False)
+        
+        features = {}
+        
+        if len(past_games) > 0:
+            last_game = pd.to_datetime(past_games["GAME_DATE"].iloc[0])
+            days_rest = (current_date - last_game).days
+            features["days_rest"] = days_rest
+            features["back_to_back"] = 1 if days_rest == 1 else 0
+            features["well_rested"] = 1 if days_rest >= 3 else 0
+        else:
+            features["days_rest"] = 3
+            features["back_to_back"] = 0
+            features["well_rested"] = 1
+        
+        # Games in last 7 days (fatigue)
+        week_ago = current_date - pd.Timedelta(days=7)
+        recent_games = past_games[pd.to_datetime(past_games["GAME_DATE"]) >= week_ago]
+        features["games_last_week"] = len(recent_games)
+        
+        return features
+    
+    def calculate_form_index(self, team_games: pd.DataFrame,
+                             current_date: datetime) -> Dict[str, float]:
+        """
+        Calculate exponentially-weighted form index for fast regime-change detection.
+        
+        Recent games are weighted more heavily than older games, allowing the model
+        to quickly adapt when a team's performance regime changes (e.g., after
+        major trades, injuries, or coaching changes).
+        """
+        past_games = team_games[pd.to_datetime(team_games["GAME_DATE"]) < current_date]
+        past_games = past_games.sort_values("GAME_DATE", ascending=False).head(10)
+        
+        features = {}
+        
+        if len(past_games) < 3:
+            features["form_index"] = 0.5  # Neutral for cold start
+            features["form_trend"] = 0.0
+            return features
+        
+        # Exponential weights: most recent game has ~2x weight of 5th game
+        # decay_rate=0.15 means game 5 has weight e^(-0.15*4) ≈ 0.55 vs 1.0 for game 1
+        weights = np.exp(-np.arange(len(past_games)) * 0.15)
+        weights = weights / weights.sum()  # Normalize to sum to 1
+        
+        # Win-based form index (0-1 scale)
+        if "WL" in past_games.columns:
+            wins = (past_games["WL"] == "W").astype(float).values
+            form_index = (wins * weights).sum()
+            features["form_index"] = form_index
+            
+            # Form trend: compare last 3 vs previous 3
+            if len(past_games) >= 6:
+                recent_3_wins = (past_games.head(3)["WL"] == "W").mean()
+                prev_3_wins = (past_games.iloc[3:6]["WL"] == "W").mean()
+                features["form_trend"] = recent_3_wins - prev_3_wins
+            else:
+                features["form_trend"] = 0.0
+        else:
+            features["form_index"] = 0.5
+            features["form_trend"] = 0.0
+        
+        # Point differential form (exponentially weighted)
+        if "PLUS_MINUS" in past_games.columns:
+            pm_values = past_games["PLUS_MINUS"].fillna(0).values
+            features["form_plus_minus"] = (pm_values * weights).sum()
+        
+        return features
+    
+    def generate_game_features(self, games_df: pd.DataFrame, 
+                                game_row: pd.Series,
+                                season: str = None) -> Dict[str, float]:
+        """Generate ALL features for a single game prediction."""
+        game_date = pd.to_datetime(game_row["GAME_DATE"])
+        team_id = game_row["TEAM_ID"]
+        matchup = game_row.get("MATCHUP", "")
+        is_home = "@" not in matchup
+        
+        # Get opponent ID
+        opponent_abbrev = matchup.split(" ")[-1] if matchup else ""
+        opponent_id = next(
+            (tid for tid, abbrev in NBA_TEAMS.items() if abbrev == opponent_abbrev), 
+            None
+        )
+        
+        # Get team's past games
+        team_games = games_df[
+            (games_df["TEAM_ID"] == team_id) & 
+            (pd.to_datetime(games_df["GAME_DATE"]) < game_date)
+        ]
+        
+        # Start with basic features
+        features = {"is_home": 1 if is_home else 0}
+        
+        # ELO features
+        if opponent_id:
+            elo_features = self.elo.calculate_game_features(team_id, opponent_id, is_home)
+            features.update(elo_features)
+        
+        # Rolling stats (basic)
+        basic_cols = ["PTS", "AST", "REB", "FG_PCT", "FG3_PCT", "FT_PCT", "PLUS_MINUS"]
+        rolling_features = self.calculate_rolling_stats(team_games, game_date, basic_cols)
+        features.update(rolling_features)
+        
+        # Defensive stats
+        def_features = self.calculate_defensive_stats(team_games, game_date)
+        features.update(def_features)
+        
+        # Season-to-date stats
+        season_features = self.calculate_season_stats(team_games, game_date, basic_cols)
+        features.update(season_features)
+        
+        # Momentum features
+        momentum_features = self.calculate_momentum(team_games, game_date)
+        features.update(momentum_features)
+        
+        # Rest/fatigue features
+        rest_features = self.calculate_rest_fatigue(team_games, game_date)
+        features.update(rest_features)
+        
+        # Form index (exponentially-weighted recent performance)
+        form_features = self.calculate_form_index(team_games, game_date)
+        features.update(form_features)
+        
+        # Season-level team stats (advanced, clutch, hustle)
+        if season:
+            team_season_stats = self.stat_loader.get_team_season_stats(team_id, season)
+            features.update(team_season_stats)
+            
+            # Top players stats
+            player_features = self.stat_loader.get_team_top_players_stats(team_id, season)
+            features.update(player_features)
+        
+        return features
+
+
+# =============================================================================
+# BATCH PROCESSOR
+# =============================================================================
+def process_all_games(games_df: pd.DataFrame, 
+                       output_path: Optional[Path] = None) -> pd.DataFrame:
+    """Process ALL games with comprehensive features."""
+    logger.info(f"Processing {len(games_df)} games with COMPREHENSIVE features...")
+    
+    games_df = games_df.sort_values("GAME_DATE").copy()
+    
+    generator = FeatureGenerator()
+    all_features = []
+    current_season = None
+    
+    from tqdm import tqdm
+    
+    for idx, row in tqdm(games_df.iterrows(), total=len(games_df), desc="Processing games"):
+        season = row.get("SEASON_ID", "")
+        
+        # Parse season for stat lookup
+        if isinstance(season, str) and len(season) >= 5:
+            year = season[1:5]
+            season_str = f"{year}-{str(int(year)+1)[-2:]}"
+        else:
+            season_str = None
+        
+        # Regress ELO at season change
+        if season != current_season:
+            if current_season is not None:
+                generator.elo.regress_to_mean()
+            current_season = season
+        
+        # Generate features
+        features = generator.generate_game_features(games_df, row, season_str)
+        features["GAME_ID"] = row["GAME_ID"]
+        features["TEAM_ID"] = row["TEAM_ID"]
+        features["GAME_DATE"] = row["GAME_DATE"]
+        features["SEASON_ID"] = row.get("SEASON_ID", "")
+        features["WL"] = row.get("WL", None)
+        
+        all_features.append(features)
+        
+        # Update ELO after game
+        if row.get("WL") and features.get("opponent_elo"):
+            opponent_abbrev = row.get("MATCHUP", "").split(" ")[-1]
+            opponent_id = next(
+                (tid for tid, abbrev in NBA_TEAMS.items() if abbrev == opponent_abbrev), 
+                None
+            )
+            if opponent_id:
+                won = row["WL"] == "W"
+                is_home = "@" not in row.get("MATCHUP", "")
+                generator.elo.update_ratings(row["TEAM_ID"], opponent_id, won, is_home)
+    
+    result_df = pd.DataFrame(all_features)
+    
+    if output_path:
+        PROCESSED_DATA_DIR.mkdir(parents=True, exist_ok=True)
+        result_df.to_parquet(output_path, index=False)
+        logger.info(f"Saved features to {output_path}")
+    
+    return result_df
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Comprehensive Feature Engineering")
+    parser.add_argument("--test", action="store_true", help="Run tests only")
+    parser.add_argument("--process", action="store_true", help="Process collected data")
+    
+    args = parser.parse_args()
+    
+    logging.basicConfig(level=logging.INFO)
+    
+    if args.test or (not args.process and not args.test):
+        print("Testing ELO Calculator...")
+        elo = ELOCalculator()
+        
+        lal_rating = elo.get_rating(1610612747)
+        bos_rating = elo.get_rating(1610612738)
+        
+        print(f"Initial ratings - LAL: {lal_rating}, BOS: {bos_rating}")
+        
+        elo.update_ratings(1610612747, 1610612738, won=True, is_home=True)
+        print(f"After LAL home win - LAL: {elo.get_rating(1610612747):.1f}, BOS: {elo.get_rating(1610612738):.1f}")
+        
+        features = elo.calculate_game_features(1610612747, 1610612738, is_home=True)
+        print(f"\nGame features: {features}")
+    
+    if args.process:
+        print("\n=== Processing Collected Data with COMPREHENSIVE Features ===")
+        
+        games_path = RAW_DATA_DIR / "all_games.parquet"
+        output_path = PROCESSED_DATA_DIR / "game_features.parquet"
+        
+        if not games_path.exists():
+            print(f"ERROR: Games data not found at {games_path}")
+            print("Run 'python -m src.data_collector' first to collect data.")
+            exit(1)
+        
+        print(f"Loading games from {games_path}...")
+        games_df = pd.read_parquet(games_path)
+        print(f"Loaded {len(games_df)} games")
+        
+        print("\nGenerating COMPREHENSIVE features (this may take a while)...")
+        print("Features include: ELO, rolling stats, defense, momentum, rest, advanced metrics, clutch, hustle...")
+        
+        result_df = process_all_games(games_df, output_path)
+        
+        print(f"\n✅ Features saved to: {output_path}")
+        print(f"   Total rows: {len(result_df)}")
+        print(f"   Total features: {len(result_df.columns)}")
+        print(f"\nFeature columns ({len(result_df.columns)} total):")
+        for col in sorted(result_df.columns):
+            print(f"  - {col}")

src/injury_collector.py

@@ -0,0 +1,224 @@
+"""
+NBA ML Prediction System - Injury Collector
+============================================
+Real-time injury data integration using nbainjuries package.
+"""
+
+import pandas as pd
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List
+import json
+import logging
+
+# Try to import nbainjuries, fall back to manual fetching if not available
+try:
+    from nbainjuries import injuries
+    HAS_NBA_INJURIES = True
+except ImportError:
+    HAS_NBA_INJURIES = False
+    logging.warning("nbainjuries package not installed. Using fallback injury data.")
+
+from src.config import API_CACHE_DIR, INJURY_IMPACT
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# INJURY CACHE
+# =============================================================================
+class InjuryCache:
+    """Cache for injury data with configurable refresh interval."""
+    
+    def __init__(self, cache_dir: Path = API_CACHE_DIR, cache_hours: float = 3.0):
+        self.cache_dir = cache_dir
+        self.cache_file = cache_dir / "injury_cache.json"
+        self.cache_hours = cache_hours
+    
+    def is_cache_valid(self) -> bool:
+        """Check if cache exists and is within refresh window."""
+        if not self.cache_file.exists():
+            return False
+        
+        with open(self.cache_file, 'r') as f:
+            cache_data = json.load(f)
+        
+        cached_time = datetime.fromisoformat(cache_data.get("timestamp", "2000-01-01"))
+        return datetime.now() - cached_time < timedelta(hours=self.cache_hours)
+    
+    def load(self) -> Optional[Dict]:
+        """Load cached injury data."""
+        if not self.cache_file.exists():
+            return None
+        
+        with open(self.cache_file, 'r') as f:
+            return json.load(f)
+    
+    def save(self, data: Dict):
+        """Save injury data to cache."""
+        cache_data = {
+            "timestamp": datetime.now().isoformat(),
+            "injuries": data
+        }
+        with open(self.cache_file, 'w') as f:
+            json.dump(cache_data, f, indent=2)
+
+
+# =============================================================================
+# INJURY COLLECTOR
+# =============================================================================
+class InjuryCollector:
+    """Collects and processes injury data for predictions."""
+    
+    def __init__(self, cache_hours: float = 3.0):
+        self.cache = InjuryCache(cache_hours=cache_hours)
+        self._injuries_df = None
+        self._last_fetch_time = None
+        self._memory_cache_ttl = 300  # 5 minutes in-memory cache
+    
+    def fetch_injuries(self, force_refresh: bool = False) -> pd.DataFrame:
+        """
+        Fetch current injury data.
+        
+        Returns DataFrame with columns:
+        - player_name: Player's full name
+        - team: Team abbreviation
+        - status: Out, Questionable, Doubtful, Probable, Available
+        - injury: Injury description
+        - date: Report date
+        """
+        # Use in-memory cache if fresh (for fast repeated calls)
+        if not force_refresh and self._injuries_df is not None and self._last_fetch_time:
+            from datetime import datetime
+            elapsed = (datetime.now() - self._last_fetch_time).total_seconds()
+            if elapsed < self._memory_cache_ttl:
+                return self._injuries_df
+        
+        # Check file cache next
+        if not force_refresh and self.cache.is_cache_valid():
+            cache_data = self.cache.load()
+            if cache_data and "injuries" in cache_data:
+                self._injuries_df = pd.DataFrame(cache_data["injuries"])
+                from datetime import datetime
+                self._last_fetch_time = datetime.now()
+                return self._injuries_df
+        
+        # Fetch fresh data only if needed
+        if HAS_NBA_INJURIES:
+            try:
+                injury_data = injuries.get_injuries()
+                df = pd.DataFrame(injury_data)
+                self.cache.save(df.to_dict('records'))
+                self._injuries_df = df
+                from datetime import datetime
+                self._last_fetch_time = datetime.now()
+                return df
+            except Exception as e:
+                pass
+        
+        # Return empty DataFrame without logging every time
+        self._injuries_df = self._get_empty_injuries_df()
+        from datetime import datetime
+        self._last_fetch_time = datetime.now()
+        return self._injuries_df
+    
+    def _get_empty_injuries_df(self) -> pd.DataFrame:
+        """Return empty injuries DataFrame with proper schema."""
+        return pd.DataFrame(columns=[
+            "player_name", "team", "status", "injury", "date"
+        ])
+    
+    def get_team_injuries(self, team_abbrev: str) -> pd.DataFrame:
+        """Get injuries for a specific team."""
+        df = self.fetch_injuries()
+        if df.empty:
+            return df
+        return df[df["team"] == team_abbrev]
+    
+    def calculate_injury_impact(self, team_abbrev: str, 
+                                 player_usage: Optional[Dict[str, float]] = None) -> float:
+        """
+        Calculate total injury impact for a team.
+        
+        Args:
+            team_abbrev: Team abbreviation (e.g., "LAL")
+            player_usage: Dict mapping player names to usage rates (0-1)
+                         If None, uses equal weighting
+        
+        Returns:
+            Injury impact score (0 = no injuries, higher = more impact)
+        """
+        team_injuries = self.get_team_injuries(team_abbrev)
+        
+        if team_injuries.empty:
+            return 0.0
+        
+        total_impact = 0.0
+        for _, injury in team_injuries.iterrows():
+            status = injury.get("status", "Available")
+            base_impact = INJURY_IMPACT.get(status, 0.0)
+            
+            # Weight by player usage if provided
+            if player_usage and injury["player_name"] in player_usage:
+                player_weight = player_usage[injury["player_name"]]
+            else:
+                # Default: assume equal importance for all injured players
+                player_weight = 0.2
+            
+            total_impact += base_impact * player_weight
+        
+        return min(total_impact, 1.0)  # Cap at 1.0
+    
+    def get_injury_summary(self, team_abbrev: str) -> Dict:
+        """Get a summary of team injuries for display."""
+        team_injuries = self.get_team_injuries(team_abbrev)
+        
+        summary = {
+            "total_injuries": len(team_injuries),
+            "out": 0,
+            "questionable": 0,
+            "doubtful": 0,
+            "probable": 0,
+            "players": []
+        }
+        
+        if team_injuries.empty:
+            return summary
+        
+        for _, injury in team_injuries.iterrows():
+            status = injury.get("status", "").lower()
+            if "out" in status:
+                summary["out"] += 1
+            elif "questionable" in status:
+                summary["questionable"] += 1
+            elif "doubtful" in status:
+                summary["doubtful"] += 1
+            elif "probable" in status:
+                summary["probable"] += 1
+            
+            summary["players"].append({
+                "name": injury.get("player_name", "Unknown"),
+                "status": injury.get("status", "Unknown"),
+                "injury": injury.get("injury", "Unknown")
+            })
+        
+        return summary
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    collector = InjuryCollector()
+    
+    print("Fetching current NBA injuries...")
+    injuries_df = collector.fetch_injuries()
+    
+    if not injuries_df.empty:
+        print(f"\nFound {len(injuries_df)} injury reports")
+        print("\nSample injuries:")
+        print(injuries_df.head(10))
+        
+        # Test impact calculation
+        print("\nInjury impact for LAL:", collector.calculate_injury_impact("LAL"))
+    else:
+        print("No injury data available")

src/live_data_collector.py

@@ -0,0 +1,235 @@
+"""
+NBA ML Prediction System - Live Data Collector
+===============================================
+Real-time data collection from NBA Live API endpoints.
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+import time
+
+from nba_api.live.nba.endpoints import scoreboard, boxscore
+
+from src.config import API_CONFIG, NBA_TEAMS
+
+logger = logging.getLogger(__name__)
+
+
+class LiveDataCollector:
+    """
+    Collects live game data from NBA API.
+    
+    Uses nba_api.live endpoints:
+    - scoreboard.ScoreBoard() for today's games with live scores
+    - boxscore.BoxScore(game_id) for detailed game box scores
+    """
+    
+    GAME_STATUS_MAP = {
+        1: "NOT_STARTED",
+        2: "IN_PROGRESS", 
+        3: "FINAL"
+    }
+    
+    def __init__(self):
+        self._last_scoreboard_fetch = None
+        self._cached_scoreboard = None
+        self._cache_ttl = 10  # Seconds to cache scoreboard
+    
+    def get_live_scoreboard(self, force_refresh: bool = False) -> List[Dict]:
+        """
+        Get today's games with live scores.
+        
+        Returns list of games with:
+        - game_id, game_code
+        - home_team, away_team (tricodes)
+        - home_score, away_score
+        - status (NOT_STARTED, IN_PROGRESS, FINAL)
+        - period, clock
+        - home_record, away_record
+        """
+        # Use cache if available and fresh
+        if not force_refresh and self._cached_scoreboard:
+            if self._last_scoreboard_fetch:
+                elapsed = (datetime.now() - self._last_scoreboard_fetch).total_seconds()
+                if elapsed < self._cache_ttl:
+                    return self._cached_scoreboard
+        
+        try:
+            sb = scoreboard.ScoreBoard()
+            games_data = sb.games.get_dict()
+            
+            games_list = []
+            for game in games_data:
+                game_status = game.get("gameStatus", 1)
+                home_team = game.get("homeTeam", {})
+                away_team = game.get("awayTeam", {})
+                
+                # Parse periods for quarter scores
+                home_periods = [p.get("score", 0) for p in home_team.get("periods", [])]
+                away_periods = [p.get("score", 0) for p in away_team.get("periods", [])]
+                
+                games_list.append({
+                    "game_id": game.get("gameId", ""),
+                    "game_code": game.get("gameCode", ""),
+                    "game_date": game.get("gameEt", "")[:10] if game.get("gameEt") else "",
+                    "game_time_utc": game.get("gameTimeUTC", ""),
+                    "game_time_et": game.get("gameEt", ""),
+                    
+                    # Teams
+                    "home_team": home_team.get("teamTricode", ""),
+                    "away_team": away_team.get("teamTricode", ""),
+                    "home_team_id": home_team.get("teamId", 0),
+                    "away_team_id": away_team.get("teamId", 0),
+                    "home_team_name": home_team.get("teamName", ""),
+                    "away_team_name": away_team.get("teamName", ""),
+                    
+                    # Scores
+                    "home_score": home_team.get("score", 0),
+                    "away_score": away_team.get("score", 0),
+                    "home_periods": home_periods,
+                    "away_periods": away_periods,
+                    
+                    # Status
+                    "status": self.GAME_STATUS_MAP.get(game_status, "UNKNOWN"),
+                    "status_text": game.get("gameStatusText", ""),
+                    "period": game.get("period", 0),
+                    "clock": game.get("gameClock", ""),
+                    
+                    # Records
+                    "home_wins": home_team.get("wins", 0),
+                    "home_losses": home_team.get("losses", 0),
+                    "away_wins": away_team.get("wins", 0),
+                    "away_losses": away_team.get("losses", 0),
+                    "home_record": f"{home_team.get('wins', 0)}-{home_team.get('losses', 0)}",
+                    "away_record": f"{away_team.get('wins', 0)}-{away_team.get('losses', 0)}",
+                    
+                    # Leaders (for in-progress/final games)
+                    "home_leader": game.get("gameLeaders", {}).get("homeLeaders", {}),
+                    "away_leader": game.get("gameLeaders", {}).get("awayLeaders", {}),
+                })
+            
+            # Update cache
+            self._cached_scoreboard = games_list
+            self._last_scoreboard_fetch = datetime.now()
+            
+            logger.info(f"Fetched {len(games_list)} games from Live Scoreboard")
+            return games_list
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch live scoreboard: {e}")
+            return self._cached_scoreboard or []
+    
+    def get_game_boxscore(self, game_id: str) -> Optional[Dict]:
+        """
+        Get detailed box score for a specific game.
+        
+        Returns:
+            Dict with game details, team stats, player stats
+        """
+        try:
+            box = boxscore.BoxScore(game_id)
+            game_data = box.game.get_dict()
+            
+            return {
+                "game_id": game_data.get("gameId", game_id),
+                "game_status": game_data.get("gameStatus", 1),
+                "game_status_text": game_data.get("gameStatusText", ""),
+                "period": game_data.get("period", 0),
+                "clock": game_data.get("gameClock", ""),
+                
+                "home_team": game_data.get("homeTeam", {}),
+                "away_team": game_data.get("awayTeam", {}),
+                
+                "arena": game_data.get("arena", {}),
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch boxscore for {game_id}: {e}")
+            return None
+    
+    def get_game_status(self, game_id: str) -> str:
+        """
+        Get current status for a specific game.
+        
+        Returns:
+            'NOT_STARTED', 'IN_PROGRESS', or 'FINAL'
+        """
+        games = self.get_live_scoreboard()
+        for game in games:
+            if game["game_id"] == game_id:
+                return game["status"]
+        return "UNKNOWN"
+    
+    def get_winner(self, game_id: str) -> Optional[str]:
+        """
+        Get the winner of a completed game.
+        
+        Returns:
+            Team tricode of winner, or None if game not finished
+        """
+        games = self.get_live_scoreboard()
+        for game in games:
+            if game["game_id"] == game_id:
+                if game["status"] == "FINAL":
+                    if game["home_score"] > game["away_score"]:
+                        return game["home_team"]
+                    else:
+                        return game["away_team"]
+        return None
+    
+    def get_games_by_status(self, status: str) -> List[Dict]:
+        """
+        Filter games by status.
+        
+        Args:
+            status: 'NOT_STARTED', 'IN_PROGRESS', or 'FINAL'
+        """
+        games = self.get_live_scoreboard()
+        return [g for g in games if g["status"] == status]
+    
+    def get_live_games(self) -> List[Dict]:
+        """Get all currently in-progress games."""
+        return self.get_games_by_status("IN_PROGRESS")
+    
+    def get_final_games(self) -> List[Dict]:
+        """Get all completed games from today."""
+        return self.get_games_by_status("FINAL")
+    
+    def get_upcoming_games(self) -> List[Dict]:
+        """Get all not-yet-started games from today."""
+        return self.get_games_by_status("NOT_STARTED")
+    
+    def format_game_summary(self, game: Dict) -> str:
+        """Format a game into a readable summary string."""
+        status = game["status"]
+        away = game["away_team"]
+        home = game["home_team"]
+        
+        if status == "NOT_STARTED":
+            return f"{away} @ {home} - {game['status_text']}"
+        elif status == "IN_PROGRESS":
+            return f"{away} {game['away_score']} @ {home} {game['home_score']} - {game['status_text']}"
+        else:  # FINAL
+            return f"{away} {game['away_score']} @ {home} {game['home_score']} - FINAL"
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    collector = LiveDataCollector()
+    
+    print("\n=== Today's NBA Games ===\n")
+    games = collector.get_live_scoreboard()
+    
+    if not games:
+        print("No games scheduled for today")
+    else:
+        for game in games:
+            print(collector.format_game_summary(game))
+            if game["status"] == "IN_PROGRESS":
+                print(f"  Q{game['period']} {game['clock']}")
+            print()

src/models/__init__.py

@@ -0,0 +1 @@
+# Empty init file

src/models/championship_predictor.py

@@ -0,0 +1,237 @@
+"""
+NBA ML Prediction System - Championship Predictor
+==================================================
+Model to predict NBA Finals winner with playoff experience features.
+"""
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import Dict, List, Optional
+import xgboost as xgb
+import joblib
+import logging
+
+from src.config import MODELS_DIR, NBA_TEAMS
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# PLAYOFF EXPERIENCE INDEX
+# =============================================================================
+class PlayoffExperienceCalculator:
+    """
+    Calculates playoff experience index for teams.
+    Teams with playoff experience perform better in postseason.
+    """
+    
+    # Historical playoff appearances (last 5 years weight)
+    PLAYOFF_HISTORY = {
+        "BOS": {"appearances": 5, "finals": 2, "championships": 1},
+        "MIA": {"appearances": 4, "finals": 2, "championships": 0},
+        "DEN": {"appearances": 4, "finals": 1, "championships": 1},
+        "GSW": {"appearances": 5, "finals": 3, "championships": 2},
+        "PHX": {"appearances": 3, "finals": 1, "championships": 0},
+        "MIL": {"appearances": 5, "finals": 1, "championships": 1},
+        "LAL": {"appearances": 4, "finals": 1, "championships": 1},
+        "DAL": {"appearances": 3, "finals": 1, "championships": 0},
+        "CLE": {"appearances": 3, "finals": 0, "championships": 0},
+        "OKC": {"appearances": 2, "finals": 0, "championships": 0},
+    }
+    
+    def calculate_experience_index(self, team_abbrev: str, 
+                                    core_continuity: float = 0.8) -> float:
+        """
+        Calculate playoff experience index.
+        
+        Args:
+            team_abbrev: Team abbreviation
+            core_continuity: How much of the playoff core remains (0-1)
+        
+        Returns:
+            Experience index (0-1 scale)
+        """
+        history = self.PLAYOFF_HISTORY.get(team_abbrev, {
+            "appearances": 0, "finals": 0, "championships": 0
+        })
+        
+        # Weight factors
+        appearance_weight = 0.3
+        finals_weight = 0.4
+        championship_weight = 0.3
+        
+        # Calculate raw score
+        raw_score = (
+            history["appearances"] / 5 * appearance_weight +
+            history["finals"] / 3 * finals_weight +
+            history["championships"] / 2 * championship_weight
+        )
+        
+        # Apply core continuity discount
+        adjusted_score = raw_score * core_continuity
+        
+        return min(adjusted_score, 1.0)
+
+
+# =============================================================================
+# CHAMPIONSHIP PREDICTOR
+# =============================================================================
+class ChampionshipPredictor:
+    """
+    Predicts championship probability for each team.
+    """
+    
+    def __init__(self):
+        self.model = None
+        self.experience_calc = PlayoffExperienceCalculator()
+        self.feature_columns = None
+        self.trained = False
+    
+    def calculate_team_strength(self, team_stats: Dict) -> float:
+        """Calculate overall team strength rating."""
+        # Weighted combination of team metrics
+        strength = (
+            team_stats.get("win_pct", 0.5) * 30 +
+            team_stats.get("net_rating", 0) * 0.5 +
+            team_stats.get("elo", 1500) / 100 +
+            team_stats.get("playoff_experience", 0) * 10
+        )
+        return strength
+    
+    def calculate_injury_sensitivity(self, team_stats: Dict) -> float:
+        """
+        Calculate how dependent team is on star players.
+        High sensitivity = risky championship bet.
+        """
+        # Simplified: use points concentration
+        top_scorer_pts = team_stats.get("top_scorer_ppg", 25)
+        team_ppg = team_stats.get("team_ppg", 110)
+        
+        # High concentration = high sensitivity
+        concentration = top_scorer_pts / team_ppg if team_ppg > 0 else 0.3
+        
+        return concentration
+    
+    def prepare_features(self, team_df: pd.DataFrame) -> pd.DataFrame:
+        """Prepare features for championship prediction."""
+        df = team_df.copy()
+        
+        # Add playoff experience
+        df["playoff_experience"] = df["TEAM_ABBREVIATION"].apply(
+            lambda x: self.experience_calc.calculate_experience_index(x)
+        )
+        
+        # Calculate strength rating
+        df["strength_rating"] = df.apply(lambda row: self.calculate_team_strength({
+            "win_pct": row.get("W_PCT", 0.5),
+            "net_rating": row.get("NET_RATING", 0),
+            "elo": row.get("ELO", 1500),
+            "playoff_experience": row.get("playoff_experience", 0)
+        }), axis=1)
+        
+        return df
+    
+    def predict_probabilities(self, team_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Predict championship probability for each team.
+        Uses a formula-based approach if model not trained.
+        """
+        df = self.prepare_features(team_df)
+        
+        # Calculate raw championship scores
+        df["champ_score"] = (
+            df.get("W_PCT", 0.5) * 40 +
+            df.get("NET_RATING", 0) * 2 +
+            df["playoff_experience"] * 20 +
+            df["strength_rating"] * 0.5
+        )
+        
+        # Convert to probabilities (softmax-like normalization)
+        total = df["champ_score"].sum()
+        df["champ_probability"] = df["champ_score"] / total if total > 0 else 1/len(df)
+        
+        # Sort by probability
+        df = df.sort_values("champ_probability", ascending=False)
+        
+        return df[["TEAM_ABBREVIATION", "W_PCT", "playoff_experience", 
+                   "strength_rating", "champ_probability"]]
+    
+    def get_top_contenders(self, team_df: pd.DataFrame, top_n: int = 8) -> pd.DataFrame:
+        """Get top championship contenders."""
+        probs = self.predict_probabilities(team_df)
+        return probs.head(top_n)
+    
+    def simulate_playoff_bracket(self, team_df: pd.DataFrame) -> Dict:
+        """
+        Simple playoff bracket simulation.
+        Returns predicted conference champions and finals winner.
+        """
+        probs = self.predict_probabilities(team_df)
+        
+        # Split by conference (simplified - top 8 each)
+        # In reality, would use actual standings
+        top_teams = probs.head(16)
+        
+        east_teams = top_teams.head(8)  # Simplified
+        west_teams = top_teams.tail(8)
+        
+        # Pick conference champions (highest probability each)
+        east_champ = east_teams.iloc[0]["TEAM_ABBREVIATION"]
+        west_champ = west_teams.iloc[0]["TEAM_ABBREVIATION"]
+        
+        # Finals winner
+        finals_winner = probs.iloc[0]["TEAM_ABBREVIATION"]
+        
+        return {
+            "east_champion": east_champ,
+            "west_champion": west_champ,
+            "finals_winner": finals_winner,
+            "champion_probability": probs.iloc[0]["champ_probability"]
+        }
+    
+    def save(self, path: Path = None):
+        """Save model to disk."""
+        if path is None:
+            path = MODELS_DIR / "championship_predictor.joblib"
+        
+        joblib.dump({
+            "model": self.model,
+            "feature_columns": self.feature_columns,
+            "trained": self.trained
+        }, path)
+        logger.info(f"Saved championship model to {path}")
+    
+    def load(self, path: Path = None):
+        """Load model from disk."""
+        if path is None:
+            path = MODELS_DIR / "championship_predictor.joblib"
+        
+        data = joblib.load(path)
+        self.model = data["model"]
+        self.feature_columns = data["feature_columns"]
+        self.trained = data["trained"]
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    print("Testing Championship Predictor...")
+    
+    # Create sample team data
+    sample_teams = pd.DataFrame({
+        "TEAM_ABBREVIATION": ["BOS", "DEN", "MIL", "PHX", "GSW", "MIA", "LAL", "DAL"],
+        "W_PCT": [0.68, 0.65, 0.63, 0.60, 0.58, 0.55, 0.52, 0.50],
+        "NET_RATING": [8.5, 6.2, 5.1, 4.0, 3.5, 2.0, 1.5, 0.5]
+    })
+    
+    predictor = ChampionshipPredictor()
+    
+    print("\nChampionship Probabilities:")
+    probs = predictor.get_top_contenders(sample_teams)
+    print(probs.to_string(index=False))
+    
+    print("\nPlayoff Bracket Simulation:")
+    bracket = predictor.simulate_playoff_bracket(sample_teams)
+    for k, v in bracket.items():
+        print(f"  {k}: {v}")

src/models/game_predictor.py

@@ -0,0 +1,331 @@
+"""
+NBA ML Prediction System - Game Predictor
+==========================================
+XGBoost + LightGBM ensemble for game win prediction.
+"""
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+from sklearn.metrics import accuracy_score, brier_score_loss, log_loss
+from sklearn.calibration import calibration_curve
+import xgboost as xgb
+import lightgbm as lgb
+import joblib
+import logging
+
+from src.config import MODEL_CONFIG, MODELS_DIR
+# Import preprocessing so pickle can find DataPreprocessor class
+from src.preprocessing import DataPreprocessor, GameDatasetBuilder
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# GAME PREDICTOR MODEL
+# =============================================================================
+class GamePredictor:
+    """
+    Ensemble model for predicting game outcomes.
+    Uses XGBoost + LightGBM with weighted averaging.
+    """
+    
+    def __init__(self, 
+                 xgb_weight: float = 0.5,
+                 lgb_weight: float = 0.5):
+        self.xgb_weight = xgb_weight
+        self.lgb_weight = lgb_weight
+        
+        self.xgb_model = None
+        self.lgb_model = None
+        self.feature_columns = None
+        self.trained = False
+    
+    def train(self, X_train: np.ndarray, y_train: np.ndarray,
+              X_val: np.ndarray = None, y_val: np.ndarray = None,
+              feature_columns: List[str] = None):
+        """
+        Train both XGBoost and LightGBM models.
+        """
+        self.feature_columns = feature_columns
+        
+        logger.info("Training XGBoost model...")
+        self.xgb_model = xgb.XGBClassifier(**MODEL_CONFIG.xgb_params)
+        
+        if X_val is not None:
+            self.xgb_model.fit(
+                X_train, y_train,
+                eval_set=[(X_val, y_val)],
+                verbose=False
+            )
+        else:
+            self.xgb_model.fit(X_train, y_train)
+        
+        logger.info("Training LightGBM model...")
+        self.lgb_model = lgb.LGBMClassifier(**MODEL_CONFIG.lgb_params)
+        
+        if X_val is not None:
+            self.lgb_model.fit(
+                X_train, y_train,
+                eval_set=[(X_val, y_val)]
+            )
+        else:
+            self.lgb_model.fit(X_train, y_train)
+        
+        self.trained = True
+        logger.info("Training complete!")
+    
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """
+        Predict win probabilities using ensemble.
+        
+        Returns:
+            Array of shape (n_samples, 2) with [loss_prob, win_prob]
+        """
+        if not self.trained:
+            raise ValueError("Model not trained. Call train() first.")
+        
+        xgb_proba = self.xgb_model.predict_proba(X)
+        lgb_proba = self.lgb_model.predict_proba(X)
+        
+        # Weighted average
+        ensemble_proba = (
+            self.xgb_weight * xgb_proba + 
+            self.lgb_weight * lgb_proba
+        )
+        
+        return ensemble_proba
+    
+    def predict(self, X: np.ndarray, threshold: float = 0.5) -> np.ndarray:
+        """Predict win/loss (1/0)."""
+        proba = self.predict_proba(X)
+        return (proba[:, 1] >= threshold).astype(int)
+    
+    def predict_with_confidence(self, X: np.ndarray) -> List[Dict]:
+        """
+        Predict with detailed confidence information.
+        Shows individual model predictions and disagreement.
+        """
+        xgb_proba = self.xgb_model.predict_proba(X)[:, 1]
+        lgb_proba = self.lgb_model.predict_proba(X)[:, 1]
+        ensemble_proba = self.predict_proba(X)[:, 1]
+        
+        results = []
+        for i in range(len(X)):
+            # Check model disagreement
+            disagreement = abs(xgb_proba[i] - lgb_proba[i])
+            
+            results.append({
+                "win_probability": ensemble_proba[i],
+                "xgb_probability": xgb_proba[i],
+                "lgb_probability": lgb_proba[i],
+                "model_disagreement": disagreement,
+                "confidence": "high" if disagreement < 0.1 else ("medium" if disagreement < 0.2 else "low"),
+                "prediction": "WIN" if ensemble_proba[i] >= 0.5 else "LOSS"
+            })
+        
+        return results
+    
+    def evaluate(self, X: np.ndarray, y: np.ndarray) -> Dict[str, float]:
+        """
+        Comprehensive model evaluation.
+        
+        Returns:
+            Dict with accuracy, brier score, and other metrics
+        """
+        y_pred = self.predict(X)
+        y_proba = self.predict_proba(X)[:, 1]
+        
+        metrics = {
+            "accuracy": accuracy_score(y, y_pred),
+            "brier_score": brier_score_loss(y, y_proba),
+            "log_loss": log_loss(y, y_proba)
+        }
+        
+        # Individual model metrics
+        xgb_pred = self.xgb_model.predict(X)
+        lgb_pred = self.lgb_model.predict(X)
+        
+        metrics["xgb_accuracy"] = accuracy_score(y, xgb_pred)
+        metrics["lgb_accuracy"] = accuracy_score(y, lgb_pred)
+        
+        return metrics
+    
+    def get_feature_importance(self) -> pd.DataFrame:
+        """Get feature importance from both models."""
+        if not self.trained or self.feature_columns is None:
+            return pd.DataFrame()
+        
+        xgb_importance = self.xgb_model.feature_importances_
+        lgb_importance = self.lgb_model.feature_importances_
+        
+        df = pd.DataFrame({
+            "feature": self.feature_columns,
+            "xgb_importance": xgb_importance,
+            "lgb_importance": lgb_importance,
+            "avg_importance": (xgb_importance + lgb_importance) / 2
+        })
+        
+        return df.sort_values("avg_importance", ascending=False)
+    
+    def explain_prediction(self, X: np.ndarray, top_n: int = 5) -> List[Dict]:
+        """
+        Explain predictions using feature importance.
+        Returns top N contributing features for each prediction.
+        """
+        if not self.trained or self.feature_columns is None:
+            return []
+        
+        importance = self.get_feature_importance()
+        top_features = importance.head(top_n)["feature"].tolist()
+        
+        explanations = []
+        for i in range(len(X)):
+            feature_contributions = []
+            for j, feat in enumerate(self.feature_columns):
+                if feat in top_features:
+                    feature_contributions.append({
+                        "feature": feat,
+                        "value": X[i, j],
+                        "importance": importance[importance["feature"] == feat]["avg_importance"].values[0]
+                    })
+            
+            # Sort by importance
+            feature_contributions.sort(key=lambda x: x["importance"], reverse=True)
+            
+            explanations.append({
+                "top_features": feature_contributions[:top_n],
+                "prediction": self.predict(X[i:i+1])[0]
+            })
+        
+        return explanations
+    
+    def save(self, path: Path = None):
+        """Save model to disk."""
+        if path is None:
+            path = MODELS_DIR / "game_predictor.joblib"
+        
+        joblib.dump({
+            "xgb_model": self.xgb_model,
+            "lgb_model": self.lgb_model,
+            "xgb_weight": self.xgb_weight,
+            "lgb_weight": self.lgb_weight,
+            "feature_columns": self.feature_columns,
+            "trained": self.trained
+        }, path)
+        logger.info(f"Saved model to {path}")
+    
+    def load(self, path: Path = None):
+        """Load model from disk."""
+        if path is None:
+            path = MODELS_DIR / "game_predictor.joblib"
+        
+        data = joblib.load(path)
+        self.xgb_model = data["xgb_model"]
+        self.lgb_model = data["lgb_model"]
+        self.xgb_weight = data["xgb_weight"]
+        self.lgb_weight = data["lgb_weight"]
+        self.feature_columns = data["feature_columns"]
+        self.trained = data["trained"]
+        logger.info(f"Loaded model from {path}")
+
+
+# =============================================================================
+# TRAINING PIPELINE
+# =============================================================================
+def train_game_predictor(dataset: Dict) -> GamePredictor:
+    """
+    Full training pipeline for game predictor.
+    """
+    logger.info("Starting game predictor training...")
+    
+    model = GamePredictor()
+    model.train(
+        X_train=dataset["X_train"],
+        y_train=dataset["y_train"],
+        X_val=dataset["X_val"],
+        y_val=dataset["y_val"],
+        feature_columns=dataset["feature_columns"]
+    )
+    
+    # Evaluate on all splits
+    logger.info("\n=== Training Metrics ===")
+    train_metrics = model.evaluate(dataset["X_train"], dataset["y_train"])
+    logger.info(f"Train Accuracy: {train_metrics['accuracy']:.4f}")
+    
+    logger.info("\n=== Validation Metrics ===")
+    val_metrics = model.evaluate(dataset["X_val"], dataset["y_val"])
+    logger.info(f"Val Accuracy: {val_metrics['accuracy']:.4f}")
+    logger.info(f"Val Brier Score: {val_metrics['brier_score']:.4f}")
+    
+    logger.info("\n=== Test Metrics ===")
+    test_metrics = model.evaluate(dataset["X_test"], dataset["y_test"])
+    logger.info(f"Test Accuracy: {test_metrics['accuracy']:.4f}")
+    logger.info(f"Test Brier Score: {test_metrics['brier_score']:.4f}")
+    
+    # Check if we meet target
+    if test_metrics["accuracy"] >= 0.65:
+        logger.info("✓ Target accuracy (>65%) achieved!")
+    else:
+        logger.warning(f"✗ Below target accuracy. Got {test_metrics['accuracy']:.2%}")
+    
+    # Feature importance
+    logger.info("\n=== Top Features ===")
+    importance = model.get_feature_importance()
+    print(importance.head(10))
+    
+    # Save model
+    model.save()
+    
+    return model
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Game Predictor Training")
+    parser.add_argument("--train", action="store_true", help="Train model")
+    parser.add_argument("--evaluate", action="store_true", help="Evaluate existing model")
+    
+    args = parser.parse_args()
+    
+    if args.train:
+        from src.preprocessing import GameDatasetBuilder
+        
+        logging.basicConfig(level=logging.INFO)
+        
+        print("Loading dataset...")
+        builder = GameDatasetBuilder()
+        
+        try:
+            dataset = builder.load_dataset()
+            print(f"Loaded dataset with {len(dataset['feature_columns'])} features")
+        except FileNotFoundError:
+            print("No dataset found. Please run 'python -m src.preprocessing --build' first.")
+            exit(1)
+        except Exception as e:
+            print(f"Error loading dataset: {e}")
+            import traceback
+            traceback.print_exc()
+            exit(1)
+        
+        model = train_game_predictor(dataset)
+        print("\nTraining complete!")
+    
+    elif args.evaluate:
+        model = GamePredictor()
+        model.load()
+        
+        from src.preprocessing import GameDatasetBuilder
+        builder = GameDatasetBuilder()
+        dataset = builder.load_dataset()
+        
+        metrics = model.evaluate(dataset["X_test"], dataset["y_test"])
+        print("\n=== Test Metrics ===")
+        for k, v in metrics.items():
+            print(f"{k}: {v:.4f}")
+    else:
+        print("Use --train to train or --evaluate to evaluate")

src/models/mvp_predictor.py

@@ -0,0 +1,257 @@
+"""
+NBA ML Prediction System - MVP Predictor
+=========================================
+Model to predict MVP based on player performance, team success, 
+and historical MVP similarity.
+"""
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import Dict, List, Optional
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import StandardScaler
+import xgboost as xgb
+import joblib
+import logging
+
+from src.config import MODELS_DIR, RAW_DATA_DIR
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# HISTORICAL MVP PROFILES
+# =============================================================================
+# Historical MVP seasons (approximate stats for similarity comparison)
+HISTORICAL_MVP_PROFILES = {
+    "2023-24": {"player": "Nikola Jokic", "ppg": 26.4, "rpg": 12.4, "apg": 9.0, "ws": 17.8, "team_wins": 57},
+    "2022-23": {"player": "Joel Embiid", "ppg": 33.1, "rpg": 10.2, "apg": 4.2, "ws": 14.3, "team_wins": 54},
+    "2021-22": {"player": "Nikola Jokic", "ppg": 27.1, "rpg": 13.8, "apg": 7.9, "ws": 15.2, "team_wins": 48},
+    "2020-21": {"player": "Nikola Jokic", "ppg": 26.4, "rpg": 10.8, "apg": 8.3, "ws": 15.6, "team_wins": 47},
+    "2019-20": {"player": "Giannis Antetokounmpo", "ppg": 29.5, "rpg": 13.6, "apg": 5.6, "ws": 14.4, "team_wins": 56},
+    "2018-19": {"player": "Giannis Antetokounmpo", "ppg": 27.7, "rpg": 12.5, "apg": 5.9, "ws": 14.4, "team_wins": 60},
+    "2017-18": {"player": "James Harden", "ppg": 30.4, "rpg": 5.4, "apg": 8.8, "ws": 15.4, "team_wins": 65},
+    "2016-17": {"player": "Russell Westbrook", "ppg": 31.6, "rpg": 10.7, "apg": 10.4, "ws": 13.1, "team_wins": 47},
+    "2015-16": {"player": "Stephen Curry", "ppg": 30.1, "rpg": 5.4, "apg": 6.7, "ws": 17.9, "team_wins": 73},
+}
+
+
+# =============================================================================
+# MVP PREDICTOR
+# =============================================================================
+class MVPPredictor:
+    """
+    Predicts MVP vote share using gradient boosting with narrative features.
+    """
+    
+    def __init__(self):
+        self.model = None
+        self.scaler = StandardScaler()
+        self.feature_columns = None
+        self.trained = False
+    
+    def calculate_mvp_similarity(self, player_stats: Dict) -> float:
+        """
+        Calculate cosine similarity to historical MVP profiles.
+        Captures voter psychology by finding players who "look like" past MVPs.
+        """
+        # Create feature vector for player
+        player_vector = np.array([
+            player_stats.get("ppg", 0),
+            player_stats.get("rpg", 0),
+            player_stats.get("apg", 0),
+            player_stats.get("ws", 0),
+            player_stats.get("team_wins", 0) / 82  # Normalize to 0-1
+        ]).reshape(1, -1)
+        
+        # Create matrix of historical MVP profiles
+        mvp_vectors = []
+        for season, profile in HISTORICAL_MVP_PROFILES.items():
+            mvp_vectors.append([
+                profile["ppg"],
+                profile["rpg"],
+                profile["apg"],
+                profile["ws"],
+                profile["team_wins"] / 82
+            ])
+        
+        mvp_matrix = np.array(mvp_vectors)
+        
+        # Normalize
+        if len(mvp_matrix) > 0:
+            mvp_matrix_normalized = self.scaler.fit_transform(mvp_matrix)
+            player_normalized = self.scaler.transform(player_vector)
+            
+            # Calculate similarity to each MVP season
+            similarities = cosine_similarity(player_normalized, mvp_matrix_normalized)[0]
+            
+            # Return max similarity (closest to any MVP)
+            return float(np.max(similarities))
+        
+        return 0.0
+    
+    def calculate_narrative_features(self, player_stats: Dict, 
+                                      prev_season_stats: Optional[Dict] = None) -> Dict:
+        """
+        Calculate narrative momentum features that voters care about.
+        """
+        features = {}
+        
+        # Stat improvement year-over-year
+        if prev_season_stats:
+            features["ppg_improvement"] = player_stats.get("ppg", 0) - prev_season_stats.get("ppg", 0)
+            features["rpg_improvement"] = player_stats.get("rpg", 0) - prev_season_stats.get("rpg", 0)
+            features["apg_improvement"] = player_stats.get("apg", 0) - prev_season_stats.get("apg", 0)
+        else:
+            features["ppg_improvement"] = 0
+            features["rpg_improvement"] = 0
+            features["apg_improvement"] = 0
+        
+        # Team success
+        features["team_wins"] = player_stats.get("team_wins", 0)
+        features["team_win_pct"] = player_stats.get("team_wins", 41) / 82
+        
+        # Games played (durability matters)
+        features["games_played"] = player_stats.get("gp", 0)
+        features["games_played_pct"] = player_stats.get("gp", 0) / 82
+        
+        return features
+    
+    def prepare_features(self, player_df: pd.DataFrame) -> pd.DataFrame:
+        """Prepare all features for MVP prediction."""
+        features = player_df.copy()
+        
+        # Calculate MVP similarity for each player
+        features["mvp_similarity"] = features.apply(
+            lambda row: self.calculate_mvp_similarity({
+                "ppg": row.get("PTS", 0),
+                "rpg": row.get("REB", 0),
+                "apg": row.get("AST", 0),
+                "ws": row.get("WS", 10),  # Default if not available
+                "team_wins": row.get("TEAM_WINS", 41)
+            }), axis=1
+        )
+        
+        return features
+    
+    def train(self, X: np.ndarray, y: np.ndarray, feature_columns: List[str]):
+        """Train the MVP prediction model."""
+        self.feature_columns = feature_columns
+        
+        self.model = xgb.XGBRegressor(
+            n_estimators=200,
+            max_depth=5,
+            learning_rate=0.1,
+            random_state=42
+        )
+        
+        self.model.fit(X, y)
+        self.trained = True
+        logger.info("MVP model trained")
+    
+    def predict_vote_share(self, X: np.ndarray) -> np.ndarray:
+        """Predict MVP vote share (0-1 scale)."""
+        if not self.trained:
+            raise ValueError("Model not trained")
+        return self.model.predict(X)
+    
+    def rank_candidates(self, player_df: pd.DataFrame, top_n: int = 10) -> pd.DataFrame:
+        """
+        Rank MVP candidates and return top N.
+        Uses real stats-based scoring formula.
+        """
+        df = player_df.copy()
+        
+        # MVP score based on stats available from NBA API
+        # Weighted formula considering:
+        # - Scoring (30%): Points per game
+        # - Playmaking (20%): Assists per game
+        # - Rebounding (15%): Rebounds per game
+        # - Defense (10%): Steals + Blocks
+        # - Efficiency (10%): Plus/Minus and FG%
+        # - Team Success (15%): Team win percentage
+        
+        pts = df.get("PTS", pd.Series([0]*len(df))).fillna(0)
+        ast = df.get("AST", pd.Series([0]*len(df))).fillna(0)
+        reb = df.get("REB", pd.Series([0]*len(df))).fillna(0)
+        stl = df.get("STL", pd.Series([0]*len(df))).fillna(0)
+        blk = df.get("BLK", pd.Series([0]*len(df))).fillna(0)
+        plus_minus = df.get("PLUS_MINUS", pd.Series([0]*len(df))).fillna(0)
+        fg_pct = df.get("FG_PCT", pd.Series([0.45]*len(df))).fillna(0.45)
+        team_win_pct = df.get("TEAM_WIN_PCT", pd.Series([0.5]*len(df))).fillna(0.5)
+        
+        df["mvp_score"] = (
+            pts * 1.0 +                    # Points (raw weight)
+            ast * 2.0 +                    # Assists (weighted more for playmaking)
+            reb * 1.0 +                    # Rebounds
+            (stl + blk) * 1.5 +            # Defense
+            plus_minus * 0.3 +             # Impact metric
+            fg_pct * 20 +                  # Efficiency bonus
+            team_win_pct * 30              # Team success (big factor for MVP)
+        )
+        
+        # Add MVP similarity if we can calculate it
+        if "mvp_similarity" not in df.columns:
+            df = self.prepare_features(df)
+        
+        if "mvp_similarity" in df.columns:
+            df["mvp_score"] = df["mvp_score"] + df["mvp_similarity"].fillna(0) * 10
+        
+        # Sort and return top candidates
+        df = df.sort_values("mvp_score", ascending=False)
+        
+        # Ensure columns exist for return
+        if "mvp_similarity" not in df.columns:
+            df["mvp_similarity"] = 0.0
+        
+        return df.head(top_n)[["PLAYER_NAME", "PTS", "REB", "AST", "mvp_score", "mvp_similarity"]]
+    
+    def save(self, path: Path = None):
+        """Save model to disk."""
+        if path is None:
+            path = MODELS_DIR / "mvp_predictor.joblib"
+        
+        joblib.dump({
+            "model": self.model,
+            "scaler": self.scaler,
+            "feature_columns": self.feature_columns,
+            "trained": self.trained
+        }, path)
+        logger.info(f"Saved MVP model to {path}")
+    
+    def load(self, path: Path = None):
+        """Load model from disk."""
+        if path is None:
+            path = MODELS_DIR / "mvp_predictor.joblib"
+        
+        data = joblib.load(path)
+        self.model = data["model"]
+        self.scaler = data["scaler"]
+        self.feature_columns = data["feature_columns"]
+        self.trained = data["trained"]
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    print("Testing MVP Similarity Calculator...")
+    
+    predictor = MVPPredictor()
+    
+    # Test with a hypothetical MVP-caliber season
+    test_stats = {
+        "ppg": 28.5,
+        "rpg": 12.0,
+        "apg": 8.5,
+        "ws": 15.0,
+        "team_wins": 55
+    }
+    
+    similarity = predictor.calculate_mvp_similarity(test_stats)
+    print(f"MVP Similarity Score: {similarity:.3f}")
+    
+    # Test narrative features
+    prev_stats = {"ppg": 25.0, "rpg": 10.0, "apg": 7.0}
+    narrative = predictor.calculate_narrative_features(test_stats, prev_stats)
+    print(f"Narrative Features: {narrative}")

src/prediction_pipeline.py

@@ -0,0 +1,636 @@
+"""
+NBA ML Prediction System - Prediction Pipeline
+===============================================
+End-to-end pipeline for generating predictions with live data integration.
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+import logging
+
+from nba_api.stats.endpoints import leaguegamefinder
+from nba_api.stats.static import teams
+
+from src.config import (
+    API_CACHE_DIR, 
+    MODELS_DIR, 
+    NBA_TEAMS,
+    API_CONFIG
+)
+from src.data_collector import CacheManager, retry_with_backoff
+from src.feature_engineering import FeatureGenerator
+from src.injury_collector import InjuryCollector
+from src.models.game_predictor import GamePredictor
+from src.models.mvp_predictor import MVPPredictor
+from src.models.championship_predictor import ChampionshipPredictor
+from src.preprocessing import DataPreprocessor
+from src.live_data_collector import LiveDataCollector
+from src.prediction_tracker import PredictionTracker
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# PREDICTION PIPELINE
+# =============================================================================
+class PredictionPipeline:
+    """
+    End-to-end prediction pipeline for:
+    - Today's games (with live scores)
+    - Upcoming games with predictions
+    - MVP race
+    - Championship odds
+    - Prediction tracking and accuracy
+    """
+    
+    def __init__(self):
+        self.cache = CacheManager()
+        self.feature_gen = FeatureGenerator()
+        self.injury_collector = InjuryCollector()
+        
+        # Live data and tracking
+        self.live_collector = LiveDataCollector()
+        self.prediction_tracker = PredictionTracker()
+        
+        # Models (loaded on demand)
+        self._game_model = None
+        self._mvp_model = None
+        self._champ_model = None
+        self._preprocessor = None
+        
+        # Initialize ELO ratings from historical games
+        self._initialize_elo_from_history()
+    
+    def _initialize_elo_from_history(self):
+        """
+        Process all historical games to build accurate ELO ratings.
+        This ensures predictions reflect actual team strength.
+        """
+        try:
+            from src.config import API_CACHE_DIR
+            
+            games_path = API_CACHE_DIR / "all_games_summary.parquet"
+            if not games_path.exists():
+                logger.warning("No historical game data found for ELO initialization")
+                return
+            
+            games_df = pd.read_parquet(games_path)
+            
+            # Sort by date to process games chronologically
+            games_df = games_df.sort_values("GAME_DATE").copy()
+            
+            # Track processed game IDs to avoid double-counting (home & away)
+            processed_games = set()
+            current_season = None
+            
+            for _, row in games_df.iterrows():
+                game_id = row["GAME_ID"]
+                
+                # Skip if we've already processed this game
+                if game_id in processed_games:
+                    continue
+                processed_games.add(game_id)
+                
+                # Regress ELO at season changes
+                season = row.get("SEASON_ID", "")
+                if season != current_season:
+                    if current_season is not None:
+                        self.feature_gen.elo.regress_to_mean()
+                    current_season = season
+                
+                team_id = row["TEAM_ID"]
+                matchup = row.get("MATCHUP", "")
+                wl = row.get("WL", "")
+                
+                if not matchup or not wl:
+                    continue
+                
+                # Parse opponent from matchup (e.g., "LAL vs. BOS" or "LAL @ BOS")
+                is_home = "vs." in matchup
+                opponent_abbrev = matchup.split(" ")[-1]
+                
+                opponent_id = next(
+                    (tid for tid, abbr in NBA_TEAMS.items() if abbr == opponent_abbrev),
+                    None
+                )
+                
+                if opponent_id:
+                    won = wl == "W"
+                    self.feature_gen.elo.update_ratings(team_id, opponent_id, won, is_home)
+            
+            logger.info(f"Initialized ELO ratings from {len(processed_games)} games")
+            
+            # Log some example ratings for verification
+            sample_teams = ["LAL", "BOS", "GSW", "MIL", "DEN"]
+            for abbrev in sample_teams:
+                team_id = next((tid for tid, abbr in NBA_TEAMS.items() if abbr == abbrev), None)
+                if team_id:
+                    rating = self.feature_gen.elo.get_rating(team_id)
+                    logger.info(f"  {abbrev}: {rating:.0f}")
+                    
+        except Exception as e:
+            logger.warning(f"Could not initialize ELO from history: {e}")
+    
+    @property
+    def game_model(self) -> GamePredictor:
+        if self._game_model is None:
+            self._game_model = GamePredictor()
+            try:
+                self._game_model.load()
+            except:
+                logger.warning("Game model not found, using untrained model")
+        return self._game_model
+    
+    @property
+    def mvp_model(self) -> MVPPredictor:
+        if self._mvp_model is None:
+            self._mvp_model = MVPPredictor()
+            try:
+                self._mvp_model.load()
+            except:
+                logger.warning("MVP model not found, using untrained model")
+        return self._mvp_model
+    
+    @property
+    def champ_model(self) -> ChampionshipPredictor:
+        if self._champ_model is None:
+            self._champ_model = ChampionshipPredictor()
+            try:
+                self._champ_model.load()
+            except:
+                logger.warning("Championship model not found, using untrained model")
+        return self._champ_model
+    
+    def get_todays_games(self) -> List[Dict]:
+        """Fetch today's games from NBA Live API using LiveDataCollector."""
+        return self.live_collector.get_live_scoreboard()
+    
+    def get_live_games(self) -> List[Dict]:
+        """Get currently in-progress games."""
+        return self.live_collector.get_live_games()
+    
+    def get_final_games(self) -> List[Dict]:
+        """Get completed games from today."""
+        return self.live_collector.get_final_games()
+    
+    def get_upcoming_games(self, days_ahead: int = 7) -> List[Dict]:
+        """
+        Get upcoming games using REAL NBA schedule.
+        
+        Uses live API for today's not-started games, plus NBA schedule API
+        for future days.
+        """
+        from datetime import timedelta
+        import time
+        
+        upcoming = []
+        base_date = datetime.now()
+        
+        # Today's not-started games from live API
+        todays_upcoming = self.live_collector.get_upcoming_games()
+        for game in todays_upcoming:
+            upcoming.append({
+                "game_id": game["game_id"],
+                "date": game["game_date"] or base_date.strftime("%Y-%m-%d"),
+                "time": game["status_text"] or "TBD",
+                "day_name": base_date.strftime("%A"),
+                "home_team": game["home_team"],
+                "away_team": game["away_team"],
+                "home_record": game.get("home_record", ""),
+                "away_record": game.get("away_record", ""),
+            })
+        
+        # Note: NBA API doesn't reliably provide future game schedules
+        # Today's games from live scoreboard are accurate
+        # Future schedule requires web scraping or third-party API
+        
+        return upcoming
+    
+    def get_team_roster(self, team_abbrev: str) -> List[Dict]:
+        """Get current roster with projected starters for a team."""
+        try:
+            from nba_api.stats.endpoints import commonteamroster
+            
+            team_id = next((tid for tid, abbr in NBA_TEAMS.items() if abbr == team_abbrev), None)
+            if not team_id:
+                return self._get_mock_roster(team_abbrev)
+            
+            roster = commonteamroster.CommonTeamRoster(team_id=team_id, season="2024-25")
+            players_df = roster.get_data_frames()[0]
+            
+            players = []
+            for _, row in players_df.iterrows():
+                players.append({
+                    "name": row.get("PLAYER", "Unknown"),
+                    "number": row.get("NUM", ""),
+                    "position": row.get("POSITION", ""),
+                    "height": row.get("HEIGHT", ""),
+                    "weight": row.get("WEIGHT", ""),
+                    "age": row.get("AGE", ""),
+                })
+            
+            # Return top 5 as projected starters (by roster order which is usually starters first)
+            return players[:5] if len(players) >= 5 else players
+            
+        except Exception as e:
+            logger.warning(f"Could not fetch roster for {team_abbrev}: {e}")
+            return self._get_mock_roster(team_abbrev)
+    
+    def _get_mock_roster(self, team_abbrev: str) -> List[Dict]:
+        """Return mock starters for teams when API fails."""
+        # Real NBA starters for 2024-25 season
+        rosters = {
+            "BOS": [
+                {"name": "Jayson Tatum", "position": "SF", "number": "0"},
+                {"name": "Jaylen Brown", "position": "SG", "number": "7"},
+                {"name": "Derrick White", "position": "PG", "number": "9"},
+                {"name": "Kristaps Porzingis", "position": "C", "number": "8"},
+                {"name": "Al Horford", "position": "PF", "number": "42"},
+            ],
+            "LAL": [
+                {"name": "LeBron James", "position": "SF", "number": "23"},
+                {"name": "Anthony Davis", "position": "PF", "number": "3"},
+                {"name": "Austin Reaves", "position": "SG", "number": "15"},
+                {"name": "D'Angelo Russell", "position": "PG", "number": "1"},
+                {"name": "Rui Hachimura", "position": "PF", "number": "28"},
+            ],
+            "GSW": [
+                {"name": "Stephen Curry", "position": "PG", "number": "30"},
+                {"name": "Klay Thompson", "position": "SG", "number": "11"},
+                {"name": "Andrew Wiggins", "position": "SF", "number": "22"},
+                {"name": "Draymond Green", "position": "PF", "number": "23"},
+                {"name": "Kevon Looney", "position": "C", "number": "5"},
+            ],
+            "MIL": [
+                {"name": "Giannis Antetokounmpo", "position": "PF", "number": "34"},
+                {"name": "Damian Lillard", "position": "PG", "number": "0"},
+                {"name": "Khris Middleton", "position": "SF", "number": "22"},
+                {"name": "Brook Lopez", "position": "C", "number": "11"},
+                {"name": "Malik Beasley", "position": "SG", "number": "5"},
+            ],
+            "DEN": [
+                {"name": "Nikola Jokic", "position": "C", "number": "15"},
+                {"name": "Jamal Murray", "position": "PG", "number": "27"},
+                {"name": "Michael Porter Jr.", "position": "SF", "number": "1"},
+                {"name": "Aaron Gordon", "position": "PF", "number": "50"},
+                {"name": "Kentavious Caldwell-Pope", "position": "SG", "number": "5"},
+            ],
+            "OKC": [
+                {"name": "Shai Gilgeous-Alexander", "position": "PG", "number": "2"},
+                {"name": "Jalen Williams", "position": "SF", "number": "8"},
+                {"name": "Chet Holmgren", "position": "C", "number": "7"},
+                {"name": "Lu Dort", "position": "SG", "number": "5"},
+                {"name": "Josh Giddey", "position": "PG", "number": "3"},
+            ],
+            "PHX": [
+                {"name": "Kevin Durant", "position": "SF", "number": "35"},
+                {"name": "Devin Booker", "position": "SG", "number": "1"},
+                {"name": "Bradley Beal", "position": "PG", "number": "3"},
+                {"name": "Jusuf Nurkic", "position": "C", "number": "20"},
+                {"name": "Grayson Allen", "position": "SG", "number": "12"},
+            ],
+            "DAL": [
+                {"name": "Luka Doncic", "position": "PG", "number": "77"},
+                {"name": "Kyrie Irving", "position": "SG", "number": "11"},
+                {"name": "Daniel Gafford", "position": "C", "number": "21"},
+                {"name": "P.J. Washington", "position": "PF", "number": "25"},
+                {"name": "Derrick Jones Jr.", "position": "SF", "number": "55"},
+            ],
+        }
+        
+        # Default roster if team not found
+        default = [
+            {"name": "Player 1", "position": "PG", "number": "1"},
+            {"name": "Player 2", "position": "SG", "number": "2"},
+            {"name": "Player 3", "position": "SF", "number": "3"},
+            {"name": "Player 4", "position": "PF", "number": "4"},
+            {"name": "Player 5", "position": "C", "number": "5"},
+        ]
+        
+        return rosters.get(team_abbrev, default)
+    
+    def get_team_record(self, team_id: int, season: str = "2024-25") -> Dict:
+        """Get current record for a team."""
+        try:
+            games = leaguegamefinder.LeagueGameFinder(
+                team_id_nullable=team_id,
+                season_nullable=season
+            ).get_data_frames()[0]
+            
+            if games.empty:
+                return {"wins": 0, "losses": 0, "win_pct": 0.5}
+            
+            wins = (games["WL"] == "W").sum()
+            losses = (games["WL"] == "L").sum()
+            
+            return {
+                "wins": wins,
+                "losses": losses,
+                "win_pct": wins / (wins + losses) if (wins + losses) > 0 else 0.5
+            }
+        except:
+            return {"wins": 0, "losses": 0, "win_pct": 0.5}
+    
+    def predict_game(self, home_team: str, away_team: str) -> Dict:
+        """
+        Generate prediction for a single game.
+        
+        Args:
+            home_team: Home team abbreviation (e.g., "LAL")
+            away_team: Away team abbreviation (e.g., "BOS")
+        
+        Returns:
+            Prediction dict with probabilities and explanations
+        """
+        # Get team IDs
+        home_id = next((tid for tid, abbr in NBA_TEAMS.items() if abbr == home_team), None)
+        away_id = next((tid for tid, abbr in NBA_TEAMS.items() if abbr == away_team), None)
+        
+        if not home_id or not away_id:
+            return {"error": "Unknown team"}
+        
+        # Get ELO features
+        elo_features = self.feature_gen.elo.calculate_game_features(
+            home_id, away_id, is_home=True
+        )
+        
+        # Get injury impact
+        home_injuries = self.injury_collector.get_injury_summary(home_team)
+        away_injuries = self.injury_collector.get_injury_summary(away_team)
+        
+        home_injury_impact = self.injury_collector.calculate_injury_impact(home_team)
+        away_injury_impact = self.injury_collector.calculate_injury_impact(away_team)
+        
+        # Build prediction result
+        result = {
+            "home_team": home_team,
+            "away_team": away_team,
+            "home_win_probability": elo_features["elo_win_prob"],
+            "away_win_probability": 1 - elo_features["elo_win_prob"],
+            "predicted_winner": home_team if elo_features["elo_win_prob"] > 0.5 else away_team,
+            "confidence": "high" if abs(elo_features["elo_win_prob"] - 0.5) > 0.15 else "medium",
+            "home_elo": elo_features["team_elo"],
+            "away_elo": elo_features["opponent_elo"],
+            "elo_diff": elo_features["elo_diff"],
+            "home_injuries": home_injuries,
+            "away_injuries": away_injuries,
+            "home_injury_impact": home_injury_impact,
+            "away_injury_impact": away_injury_impact,
+            "factors": []
+        }
+        
+        # Add explaining factors
+        if elo_features["elo_diff"] > 50:
+            result["factors"].append(f"{home_team} has higher ELO rating (+{elo_features['elo_diff']:.0f})")
+        elif elo_features["elo_diff"] < -50:
+            result["factors"].append(f"{away_team} has higher ELO rating (+{-elo_features['elo_diff']:.0f})")
+        
+        result["factors"].append(f"Home court advantage for {home_team}")
+        
+        if home_injuries["total_injuries"] > 0:
+            result["factors"].append(f"{home_team} has {home_injuries['total_injuries']} injuries")
+        if away_injuries["total_injuries"] > 0:
+            result["factors"].append(f"{away_team} has {away_injuries['total_injuries']} injuries")
+        
+        return result
+    
+    def predict_todays_games(self, save_predictions: bool = True) -> List[Dict]:
+        """
+        Generate predictions for all of today's games.
+        
+        Args:
+            save_predictions: If True, save predictions to ChromaDB tracker
+        """
+        games = self.get_todays_games()
+        
+        if not games:
+            logger.info("No games today")
+            return []
+        
+        predictions = []
+        for game in games:
+            home_team = game.get("home_team", "")
+            away_team = game.get("away_team", "")
+            
+            if home_team and away_team:
+                pred = self.predict_game(home_team, away_team)
+                pred["game_id"] = game.get("game_id", "")
+                pred["game_date"] = game.get("game_date", "")
+                pred["game_status"] = game.get("status", "")
+                pred["current_home_score"] = game.get("home_score", 0)
+                pred["current_away_score"] = game.get("away_score", 0)
+                
+                # Save prediction if game hasn't started and tracking enabled
+                if save_predictions and game.get("status") == "NOT_STARTED":
+                    self.save_prediction_for_game(game["game_id"], pred)
+                
+                predictions.append(pred)
+        
+        return predictions
+    
+    def save_prediction_for_game(self, game_id: str, prediction: Dict) -> bool:
+        """Save a prediction to the tracker before game starts."""
+        return self.prediction_tracker.save_prediction(game_id, prediction)
+    
+    def check_prediction_results(self) -> List[Dict]:
+        """
+        Check completed games and update prediction results.
+        
+        Returns:
+            List of updated predictions with results
+        """
+        final_games = self.get_final_games()
+        updated = []
+        
+        for game in final_games:
+            game_id = game["game_id"]
+            home_score = game["home_score"]
+            away_score = game["away_score"]
+            actual_winner = game["home_team"] if home_score > away_score else game["away_team"]
+            
+            # Update the prediction in tracker
+            success = self.prediction_tracker.update_result(
+                game_id=game_id,
+                actual_winner=actual_winner,
+                home_score=home_score,
+                away_score=away_score
+            )
+            
+            if success:
+                pred = self.prediction_tracker.get_prediction(game_id)
+                if pred:
+                    pred["actual_winner"] = actual_winner
+                    pred["home_score"] = home_score
+                    pred["away_score"] = away_score
+                    updated.append(pred)
+        
+        return updated
+    
+    def get_accuracy_stats(self) -> Dict:
+        """Get comprehensive model accuracy statistics."""
+        return self.prediction_tracker.get_accuracy_stats()
+    
+    def get_recent_predictions(self, n: int = 20) -> List[Dict]:
+        """Get recent predictions with results."""
+        return self.prediction_tracker.get_recent_predictions(n)
+    
+    def get_pending_predictions(self) -> List[Dict]:
+        """Get predictions for games not yet completed."""
+        return self.prediction_tracker.get_pending_predictions()
+    
+    def get_games_with_predictions(self) -> List[Dict]:
+        """
+        Get all today's games with prediction data and live scores.
+        Enriches each game with prediction info and correctness status.
+        """
+        games = self.get_todays_games()
+        enriched = []
+        
+        for game in games:
+            game_data = dict(game)  # Copy
+            
+            # Get prediction for this game
+            pred = self.predict_game(game["home_team"], game["away_team"])
+            game_data["prediction"] = pred
+            
+            # Check if prediction was correct (for completed games)
+            if game["status"] == "FINAL":
+                actual_winner = game["home_team"] if game["home_score"] > game["away_score"] else game["away_team"]
+                game_data["actual_winner"] = actual_winner
+                game_data["prediction_correct"] = pred["predicted_winner"] == actual_winner
+            else:
+                game_data["actual_winner"] = None
+                game_data["prediction_correct"] = None
+            
+            enriched.append(game_data)
+        
+        return enriched
+    
+    def get_mvp_race(self, player_df: pd.DataFrame = None) -> pd.DataFrame:
+        """Get current MVP race standings using ONLY current 2025-26 season data."""
+        # Always fetch real current season player stats from NBA API
+        try:
+            from nba_api.stats.endpoints import leaguedashplayerstats, leaguestandings
+            import time
+            
+            time.sleep(0.5)
+            stats = leaguedashplayerstats.LeagueDashPlayerStats(
+                season='2025-26',
+                per_mode_detailed='PerGame'
+            )
+            df = stats.get_data_frames()[0]
+            
+            # Get team standings for team win percentage
+            time.sleep(0.5)
+            standings = leaguestandings.LeagueStandings(season='2025-26')
+            standings_df = standings.get_data_frames()[0]
+            
+            # Map team win% to players by TEAM_ID
+            team_win_pct = {}
+            for _, row in standings_df.iterrows():
+                team_id = row.get('TeamID', 0)
+                wins = row.get('WINS', 0)
+                losses = row.get('LOSSES', 0)
+                total = wins + losses
+                if total > 0:
+                    team_win_pct[team_id] = wins / total
+            
+            # Add team win% to player stats
+            df['TEAM_WIN_PCT'] = df['TEAM_ID'].map(team_win_pct).fillna(0.5)
+            
+            # Filter to players with significant minutes (starters/key players)
+            df = df[
+                (df['MIN'] >= 25) & 
+                (df['GP'] >= 15)
+            ].copy()
+            
+            # Calculate MVP score directly (no model dependency)
+            df['mvp_score'] = (
+                df['PTS'].fillna(0) * 1.0 +           # Points
+                df['AST'].fillna(0) * 2.0 +           # Assists (playmaking)
+                df['REB'].fillna(0) * 1.0 +           # Rebounds
+                (df['STL'].fillna(0) + df['BLK'].fillna(0)) * 1.5 +  # Defense
+                df['PLUS_MINUS'].fillna(0) * 0.3 +    # Impact
+                df['FG_PCT'].fillna(0.45) * 20 +      # Efficiency
+                df['TEAM_WIN_PCT'].fillna(0.5) * 30   # Team success
+            )
+            
+            # Add similarity score (simplified - based on stats profile)
+            df['mvp_similarity'] = (
+                (df['PTS'] / 30.0).clip(0, 1) * 0.4 +  # Elite scorer
+                (df['REB'] / 12.0).clip(0, 1) * 0.2 +  # Elite rebounder
+                (df['AST'] / 10.0).clip(0, 1) * 0.2 +  # Elite playmaker
+                df['TEAM_WIN_PCT'] * 0.2               # Winning team
+            ).fillna(0)
+            
+            # Sort by MVP score
+            df = df.sort_values('mvp_score', ascending=False)
+            
+            # Return top 10 MVP candidates
+            return df.head(10)[['PLAYER_NAME', 'PTS', 'REB', 'AST', 'mvp_score', 'mvp_similarity']]
+            
+        except Exception as e:
+            logger.warning(f"Could not fetch real MVP data: {e}")
+            # Return empty DataFrame on error
+            return pd.DataFrame({
+                'PLAYER_NAME': [],
+                'PTS': [],
+                'REB': [],
+                'AST': [],
+                'mvp_score': [],
+                'mvp_similarity': []
+            })
+    
+    def get_championship_odds(self, team_df: pd.DataFrame = None) -> pd.DataFrame:
+        """Get current championship odds."""
+        if team_df is None:
+            # Use mock data if no real data
+            team_df = pd.DataFrame({
+                "TEAM_ABBREVIATION": ["OKC", "CLE", "BOS", "DEN", "MEM", "HOU", "NYK", "GSW"],
+                "W_PCT": [0.70, 0.68, 0.65, 0.62, 0.60, 0.58, 0.55, 0.52],
+                "NET_RATING": [9.5, 8.2, 7.5, 6.0, 5.5, 4.0, 3.5, 2.0]
+            })
+        
+        return self.champ_model.get_top_contenders(team_df)
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="NBA Prediction Pipeline")
+    parser.add_argument("--test", action="store_true", help="Run test prediction")
+    parser.add_argument("--today", action="store_true", help="Predict today's games")
+    parser.add_argument("--game", nargs=2, help="Predict single game: HOME AWAY")
+    
+    args = parser.parse_args()
+    
+    pipeline = PredictionPipeline()
+    
+    if args.test:
+        print("Testing prediction pipeline...")
+        result = pipeline.predict_game("LAL", "BOS")
+        for k, v in result.items():
+            print(f"  {k}: {v}")
+    
+    elif args.today:
+        print("Today's game predictions:")
+        predictions = pipeline.predict_todays_games()
+        for pred in predictions:
+            print(f"\n{pred['away_team']} @ {pred['home_team']}")
+            print(f"  Predicted winner: {pred['predicted_winner']}")
+            print(f"  Win probability: {pred['home_win_probability']:.1%}")
+    
+    elif args.game:
+        home, away = args.game
+        result = pipeline.predict_game(home.upper(), away.upper())
+        print(f"\n{away.upper()} @ {home.upper()}")
+        for k, v in result.items():
+            print(f"  {k}: {v}")
+    
+    else:
+        print("Use --test, --today, or --game HOME AWAY")

src/prediction_tracker.py

@@ -0,0 +1,507 @@
+"""
+NBA ML Prediction System - Prediction Tracker
+==============================================
+Tracks predictions and measures accuracy using ChromaDB Cloud with local fallback.
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional
+import json
+import hashlib
+from pathlib import Path
+
+from src.config import CHROMADB_CONFIG, PROCESSED_DATA_DIR
+
+logger = logging.getLogger(__name__)
+
+
+class PredictionTracker:
+    """
+    Tracks predictions and measures accuracy over time.
+    
+    Uses ChromaDB Cloud if available, otherwise falls back to local JSON storage.
+    Stores predictions before games and updates with results after completion.
+    Provides accuracy statistics by team, confidence level, and over time.
+    """
+    
+    def __init__(self):
+        """Initialize storage - try ChromaDB Cloud, fallback to local JSON."""
+        self.collection = None
+        self.client = None
+        self._use_local = False
+        self._local_file = PROCESSED_DATA_DIR / "predictions_local.json"
+        self._local_data: List[Dict] = []
+        
+        # Try ChromaDB Cloud first
+        try:
+            import chromadb
+            
+            # Try CloudClient (the official way for Chroma Cloud)
+            self.client = chromadb.CloudClient(
+                tenant=CHROMADB_CONFIG.tenant,
+                database=CHROMADB_CONFIG.database,
+                api_key=CHROMADB_CONFIG.api_key,
+            )
+            
+            # Get or create collection for predictions
+            self.collection = self.client.get_or_create_collection(
+                name=CHROMADB_CONFIG.collection_name,
+                metadata={"description": "NBA game predictions with results"}
+            )
+            
+            logger.info("Connected to ChromaDB Cloud successfully")
+            
+        except Exception as e:
+            logger.warning(f"ChromaDB Cloud unavailable ({e}), using local JSON storage")
+            self._use_local = True
+            self._load_local_data()
+    
+    def _generate_id(self, game_id: str, prediction_date: str) -> str:
+        """Generate unique ID for a prediction."""
+        return hashlib.md5(f"{game_id}_{prediction_date}".encode()).hexdigest()
+    
+    def _load_local_data(self):
+        """Load predictions from local JSON file."""
+        if self._local_file.exists():
+            try:
+                with open(self._local_file, 'r') as f:
+                    self._local_data = json.load(f)
+            except Exception as e:
+                logger.error(f"Failed to load local data: {e}")
+                self._local_data = []
+        else:
+            self._local_data = []
+    
+    def _save_local_data(self):
+        """Save predictions to local JSON file."""
+        try:
+            with open(self._local_file, 'w') as f:
+                json.dump(self._local_data, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save local data: {e}")
+    
+    def _find_local_prediction(self, game_id: str) -> Optional[int]:
+        """Find index of prediction by game_id in local data."""
+        for i, pred in enumerate(self._local_data):
+            if pred.get("game_id") == game_id:
+                return i
+        return None
+    
+    def save_prediction(self, game_id: str, prediction: Dict) -> bool:
+        """
+        Store a prediction before game starts.
+        
+        Args:
+            game_id: NBA game ID
+            prediction: Dict with home_team, away_team, predicted_winner,
+                       home_win_prob, confidence, etc.
+        
+        Returns:
+            True if saved successfully
+        """
+        now = datetime.now().isoformat()
+        doc_id = self._generate_id(game_id, now[:10])
+        
+        # Prepare metadata
+        metadata = {
+            "id": doc_id,
+            "game_id": game_id,
+            "game_date": prediction.get("game_date", now[:10]),
+            "home_team": prediction.get("home_team", ""),
+            "away_team": prediction.get("away_team", ""),
+            "predicted_winner": prediction.get("predicted_winner", ""),
+            "home_win_prob": float(prediction.get("home_win_probability", 0.5)),
+            "away_win_prob": float(prediction.get("away_win_probability", 0.5)),
+            "confidence": prediction.get("confidence", "medium"),
+            "home_elo": float(prediction.get("home_elo", 1500)),
+            "away_elo": float(prediction.get("away_elo", 1500)),
+            "actual_winner": "",  # Empty until game completes
+            "is_correct": -1,  # -1 = pending, 0 = wrong, 1 = correct
+            "created_at": now,
+            "updated_at": now,
+        }
+        
+        # Use local storage if ChromaDB not available
+        if self._use_local:
+            try:
+                # Check if exists and update, otherwise append
+                idx = self._find_local_prediction(game_id)
+                if idx is not None:
+                    self._local_data[idx] = metadata
+                else:
+                    self._local_data.append(metadata)
+                self._save_local_data()
+                logger.info(f"Saved prediction for game {game_id} (local)")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to save prediction locally: {e}")
+                return False
+        
+        # Use ChromaDB Cloud
+        if not self.collection:
+            logger.warning("ChromaDB not available, prediction not saved")
+            return False
+        
+        try:
+            # Document text for semantic search
+            doc_text = (
+                f"NBA Game: {prediction.get('away_team')} @ {prediction.get('home_team')} "
+                f"on {metadata['game_date']}. "
+                f"Predicted winner: {metadata['predicted_winner']} "
+                f"with {metadata['confidence']} confidence "
+                f"({metadata['home_win_prob']:.1%} home win probability)"
+            )
+            
+            # Upsert (update if exists, insert if not)
+            self.collection.upsert(
+                ids=[doc_id],
+                documents=[doc_text],
+                metadatas=[metadata]
+            )
+            
+            logger.info(f"Saved prediction for game {game_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to save prediction: {e}")
+            return False
+    
+    def update_result(self, game_id: str, actual_winner: str, 
+                     home_score: int = 0, away_score: int = 0) -> bool:
+        """
+        Update prediction with actual game result.
+        
+        Args:
+            game_id: NBA game ID
+            actual_winner: Team tricode of actual winner
+            home_score: Final home score
+            away_score: Final away score
+        
+        Returns:
+            True if updated successfully
+        """
+        # Handle local storage
+        if self._use_local:
+            try:
+                idx = self._find_local_prediction(game_id)
+                if idx is None:
+                    logger.warning(f"No prediction found for game {game_id}")
+                    return False
+                
+                pred = self._local_data[idx]
+                predicted_winner = pred.get("predicted_winner", "")
+                is_correct = 1 if predicted_winner == actual_winner else 0
+                
+                pred["actual_winner"] = actual_winner
+                pred["is_correct"] = is_correct
+                pred["home_score"] = home_score
+                pred["away_score"] = away_score
+                pred["updated_at"] = datetime.now().isoformat()
+                
+                self._local_data[idx] = pred
+                self._save_local_data()
+                
+                result_text = "CORRECT ✓" if is_correct else "WRONG ✗"
+                logger.info(f"Updated result for game {game_id}: {result_text} (local)")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Failed to update result locally: {e}")
+                return False
+        
+        # Handle ChromaDB Cloud
+        if not self.collection:
+            return False
+        
+        try:
+            # Find the prediction for this game
+            results = self.collection.get(
+                where={"game_id": game_id},
+                include=["metadatas", "documents"]
+            )
+            
+            if not results["ids"]:
+                logger.warning(f"No prediction found for game {game_id}")
+                return False
+            
+            doc_id = results["ids"][0]
+            metadata = results["metadatas"][0]
+            
+            # Check if prediction was correct
+            predicted_winner = metadata.get("predicted_winner", "")
+            is_correct = 1 if predicted_winner == actual_winner else 0
+            
+            # Update metadata
+            metadata["actual_winner"] = actual_winner
+            metadata["is_correct"] = is_correct
+            metadata["home_score"] = home_score
+            metadata["away_score"] = away_score
+            metadata["updated_at"] = datetime.now().isoformat()
+            
+            # Update document text
+            result_text = "CORRECT ✓" if is_correct else "WRONG ✗"
+            doc_text = (
+                f"NBA Game: {metadata['away_team']} @ {metadata['home_team']}. "
+                f"Predicted: {predicted_winner}, Actual: {actual_winner}. "
+                f"Result: {result_text}"
+            )
+            
+            self.collection.update(
+                ids=[doc_id],
+                documents=[doc_text],
+                metadatas=[metadata]
+            )
+            
+            logger.info(f"Updated result for game {game_id}: {result_text}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to update result: {e}")
+            return False
+    
+    def get_prediction(self, game_id: str) -> Optional[Dict]:
+        """Get prediction for a specific game."""
+        # Handle local storage
+        if self._use_local:
+            idx = self._find_local_prediction(game_id)
+            if idx is not None:
+                return self._local_data[idx]
+            return None
+        
+        # Handle ChromaDB
+        if not self.collection:
+            return None
+        
+        try:
+            results = self.collection.get(
+                where={"game_id": game_id},
+                include=["metadatas"]
+            )
+            
+            if results["ids"]:
+                return results["metadatas"][0]
+            return None
+            
+        except Exception as e:
+            logger.error(f"Failed to get prediction: {e}")
+            return None
+    
+    def get_recent_predictions(self, n: int = 20) -> List[Dict]:
+        """Get N most recent predictions with results."""
+        # Handle local storage
+        if self._use_local:
+            predictions = sorted(
+                self._local_data,
+                key=lambda x: x.get("created_at", ""),
+                reverse=True
+            )
+            return predictions[:n]
+        
+        # Handle ChromaDB
+        if not self.collection:
+            return []
+        
+        try:
+            # Get all predictions and sort by date
+            results = self.collection.get(
+                include=["metadatas"]
+            )
+            
+            if not results["ids"]:
+                return []
+            
+            predictions = results["metadatas"]
+            
+            # Sort by created_at descending
+            predictions.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+            
+            return predictions[:n]
+            
+        except Exception as e:
+            logger.error(f"Failed to get recent predictions: {e}")
+            return []
+    
+    def _calculate_accuracy_from_predictions(self, predictions: List[Dict]) -> Dict:
+        """Calculate accuracy stats from a list of predictions."""
+        if not predictions:
+            return {
+                "total_predictions": 0,
+                "completed_games": 0,
+                "correct_predictions": 0,
+                "overall_accuracy": 0.0,
+                "by_confidence": {},
+                "by_team": {},
+            }
+        
+        # Filter to completed games only
+        completed = [p for p in predictions if p.get("is_correct", -1) >= 0]
+        correct = [p for p in completed if p.get("is_correct") == 1]
+        
+        # By confidence level
+        confidence_stats = {}
+        for conf in ["high", "medium", "low"]:
+            conf_preds = [p for p in completed if p.get("confidence") == conf]
+            conf_correct = [p for p in conf_preds if p.get("is_correct") == 1]
+            if conf_preds:
+                confidence_stats[conf] = {
+                    "total": len(conf_preds),
+                    "correct": len(conf_correct),
+                    "accuracy": len(conf_correct) / len(conf_preds)
+                }
+        
+        # By team predicted
+        team_stats = {}
+        for pred in completed:
+            team = pred.get("predicted_winner", "")
+            if team not in team_stats:
+                team_stats[team] = {"total": 0, "correct": 0}
+            team_stats[team]["total"] += 1
+            if pred.get("is_correct") == 1:
+                team_stats[team]["correct"] += 1
+        
+        for team in team_stats:
+            total = team_stats[team]["total"]
+            team_stats[team]["accuracy"] = team_stats[team]["correct"] / total if total > 0 else 0
+        
+        return {
+            "total_predictions": len(predictions),
+            "completed_games": len(completed),
+            "correct_predictions": len(correct),
+            "overall_accuracy": len(correct) / len(completed) if completed else 0.0,
+            "by_confidence": confidence_stats,
+            "by_team": team_stats,
+        }
+    
+    def get_accuracy_stats(self) -> Dict:
+        """
+        Calculate comprehensive accuracy statistics.
+        
+        Returns:
+            Dict with overall accuracy, by confidence, by team
+        """
+        # Handle local storage
+        if self._use_local:
+            return self._calculate_accuracy_from_predictions(self._local_data)
+        
+        # Handle ChromaDB
+        if not self.collection:
+            return {
+                "total_predictions": 0,
+                "completed_games": 0,
+                "correct_predictions": 0,
+                "overall_accuracy": 0.0,
+                "by_confidence": {},
+                "by_team": {},
+            }
+        
+        try:
+            results = self.collection.get(include=["metadatas"])
+            
+            if not results["ids"]:
+                return {
+                    "total_predictions": 0,
+                    "completed_games": 0,
+                    "correct_predictions": 0,
+                    "overall_accuracy": 0.0,
+                    "by_confidence": {},
+                    "by_team": {},
+                }
+            
+            predictions = results["metadatas"]
+            
+            # Filter to completed games only
+            completed = [p for p in predictions if p.get("is_correct", -1) >= 0]
+            correct = [p for p in completed if p.get("is_correct") == 1]
+            
+            # By confidence level
+            confidence_stats = {}
+            for conf in ["high", "medium", "low"]:
+                conf_preds = [p for p in completed if p.get("confidence") == conf]
+                conf_correct = [p for p in conf_preds if p.get("is_correct") == 1]
+                if conf_preds:
+                    confidence_stats[conf] = {
+                        "total": len(conf_preds),
+                        "correct": len(conf_correct),
+                        "accuracy": len(conf_correct) / len(conf_preds)
+                    }
+            
+            # By team predicted
+            team_stats = {}
+            for pred in completed:
+                team = pred.get("predicted_winner", "")
+                if team not in team_stats:
+                    team_stats[team] = {"total": 0, "correct": 0}
+                team_stats[team]["total"] += 1
+                if pred.get("is_correct") == 1:
+                    team_stats[team]["correct"] += 1
+            
+            for team in team_stats:
+                total = team_stats[team]["total"]
+                team_stats[team]["accuracy"] = team_stats[team]["correct"] / total if total > 0 else 0
+            
+            return {
+                "total_predictions": len(predictions),
+                "completed_games": len(completed),
+                "correct_predictions": len(correct),
+                "overall_accuracy": len(correct) / len(completed) if completed else 0.0,
+                "by_confidence": confidence_stats,
+                "by_team": team_stats,
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get accuracy stats: {e}")
+            return {
+                "total_predictions": 0,
+                "completed_games": 0,
+                "correct_predictions": 0,
+                "overall_accuracy": 0.0,
+                "by_confidence": {},
+                "by_team": {},
+                "error": str(e)
+            }
+    
+    def get_pending_predictions(self) -> List[Dict]:
+        """Get predictions for games not yet completed."""
+        if not self.collection:
+            return []
+        
+        try:
+            results = self.collection.get(
+                where={"is_correct": -1},
+                include=["metadatas"]
+            )
+            
+            return results.get("metadatas", [])
+            
+        except Exception as e:
+            logger.error(f"Failed to get pending predictions: {e}")
+            return []
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    tracker = PredictionTracker()
+    
+    print("\n=== Prediction Tracker Stats ===\n")
+    
+    stats = tracker.get_accuracy_stats()
+    print(f"Total Predictions: {stats['total_predictions']}")
+    print(f"Completed Games: {stats['completed_games']}")
+    print(f"Correct Predictions: {stats['correct_predictions']}")
+    print(f"Overall Accuracy: {stats['overall_accuracy']:.1%}")
+    
+    if stats['by_confidence']:
+        print("\nBy Confidence Level:")
+        for conf, data in stats['by_confidence'].items():
+            print(f"  {conf.upper()}: {data['correct']}/{data['total']} ({data['accuracy']:.1%})")
+    
+    print("\n=== Recent Predictions ===\n")
+    recent = tracker.get_recent_predictions(5)
+    for pred in recent:
+        status = "✓" if pred.get("is_correct") == 1 else "✗" if pred.get("is_correct") == 0 else "⏳"
+        print(f"{status} {pred.get('away_team')} @ {pred.get('home_team')} - Predicted: {pred.get('predicted_winner')}")

src/preprocessing.py

@@ -0,0 +1,292 @@
+"""
+NBA ML Prediction System - Preprocessing
+=========================================
+Data cleaning and transformation with:
+- Time-aware train/val/test splits
+- Dynamic feature detection (uses ALL available features)
+- Missing value handling
+- Feature scaling
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from typing import List, Tuple, Optional, Dict
+from sklearn.preprocessing import StandardScaler
+from sklearn.impute import SimpleImputer
+import joblib
+import logging
+
+from src.config import MODEL_CONFIG, PROCESSED_DATA_DIR, MODELS_DIR
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# COLUMNS TO EXCLUDE FROM FEATURES
+# =============================================================================
+EXCLUDE_COLUMNS = [
+    "GAME_ID", "TEAM_ID", "GAME_DATE", "SEASON_ID", "SEASON", 
+    "WL", "target", "MATCHUP", "TEAM_NAME", "TEAM_ABBREVIATION",
+    "PLAYER_ID", "PLAYER_NAME"
+]
+
+
+# =============================================================================
+# SEASON-BASED SPLITTER (NO DATA LEAKAGE)
+# =============================================================================
+class SeasonBasedSplitter:
+    """Splits data by season to prevent data leakage."""
+    
+    def __init__(self, 
+                 test_seasons: List[str] = None,
+                 val_seasons: List[str] = None):
+        self.test_seasons = test_seasons or MODEL_CONFIG.test_seasons
+        self.val_seasons = val_seasons or MODEL_CONFIG.val_seasons
+    
+    def split(self, df: pd.DataFrame, 
+              season_column: str = "SEASON") -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+        # Extract season from SEASON_ID if needed
+        if season_column not in df.columns and "SEASON_ID" in df.columns:
+            df = df.copy()
+            df[season_column] = df["SEASON_ID"].apply(self._parse_season_id)
+        
+        test_mask = df[season_column].isin(self.test_seasons)
+        val_mask = df[season_column].isin(self.val_seasons)
+        train_mask = ~(test_mask | val_mask)
+        
+        train_df = df[train_mask].copy()
+        val_df = df[val_mask].copy()
+        test_df = df[test_mask].copy()
+        
+        logger.info(f"Split: Train={len(train_df)}, Val={len(val_df)}, Test={len(test_df)}")
+        
+        return train_df, val_df, test_df
+    
+    def _parse_season_id(self, season_id: str) -> str:
+        if isinstance(season_id, str) and len(season_id) == 5:
+            year = int(season_id[1:])
+            return f"{year}-{str(year+1)[-2:]}"
+        return str(season_id)
+
+
+# =============================================================================
+# DATA PREPROCESSOR
+# =============================================================================
+class DataPreprocessor:
+    """Handles missing values, scaling, and data preparation."""
+    
+    def __init__(self, feature_columns: List[str] = None):
+        self.feature_columns = feature_columns
+        self.scaler = StandardScaler()
+        self.imputer = SimpleImputer(strategy="median")
+        self.fitted = False
+    
+    def fit(self, df: pd.DataFrame, feature_columns: List[str] = None):
+        if feature_columns:
+            self.feature_columns = feature_columns
+        
+        X = df[self.feature_columns].values
+        X_imputed = self.imputer.fit_transform(X)
+        self.scaler.fit(X_imputed)
+        
+        self.fitted = True
+        logger.info(f"Preprocessor fitted on {len(self.feature_columns)} features")
+    
+    def transform(self, df: pd.DataFrame) -> np.ndarray:
+        if not self.fitted:
+            raise ValueError("Preprocessor not fitted. Call fit() first.")
+        
+        X = df[self.feature_columns].values
+        X_imputed = self.imputer.transform(X)
+        X_scaled = self.scaler.transform(X_imputed)
+        
+        return X_scaled
+    
+    def fit_transform(self, df: pd.DataFrame, feature_columns: List[str] = None) -> np.ndarray:
+        self.fit(df, feature_columns)
+        return self.transform(df)
+    
+    def save(self, path: Path = None):
+        if path is None:
+            path = MODELS_DIR / "preprocessor.joblib"
+        
+        joblib.dump({
+            "feature_columns": self.feature_columns,
+            "scaler": self.scaler,
+            "imputer": self.imputer
+        }, path)
+        logger.info(f"Saved preprocessor to {path}")
+    
+    def load(self, path: Path = None):
+        if path is None:
+            path = MODELS_DIR / "preprocessor.joblib"
+        
+        data = joblib.load(path)
+        self.feature_columns = data["feature_columns"]
+        self.scaler = data["scaler"]
+        self.imputer = data["imputer"]
+        self.fitted = True
+        logger.info(f"Loaded preprocessor from {path}")
+
+
+# =============================================================================
+# DATASET BUILDER - USES ALL AVAILABLE FEATURES
+# =============================================================================
+class GameDatasetBuilder:
+    """Builds train/val/test datasets using ALL available features."""
+    
+    def __init__(self):
+        self.splitter = SeasonBasedSplitter()
+        self.preprocessor = DataPreprocessor()
+    
+    def _get_feature_columns(self, df: pd.DataFrame) -> List[str]:
+        """
+        Dynamically detect ALL numeric feature columns.
+        Excludes ID columns, target, and non-numeric columns.
+        """
+        feature_columns = []
+        
+        for col in df.columns:
+            # Skip excluded columns
+            if col in EXCLUDE_COLUMNS:
+                continue
+            
+            # Skip non-numeric columns
+            if not pd.api.types.is_numeric_dtype(df[col]):
+                continue
+            
+            # Skip columns with all NaN
+            if df[col].isna().all():
+                continue
+            
+            feature_columns.append(col)
+        
+        return sorted(feature_columns)
+    
+    def build_dataset(self, features_df: pd.DataFrame, 
+                       target_column: str = "WL",
+                       use_all_features: bool = True) -> Dict:
+        """
+        Build complete dataset for training.
+        
+        Args:
+            features_df: DataFrame with features
+            target_column: Column to predict
+            use_all_features: If True, uses ALL available numeric features
+        """
+        # Remove rows without target
+        df = features_df.dropna(subset=[target_column]).copy()
+        
+        # Convert WL to binary
+        df["target"] = (df[target_column] == "W").astype(int)
+        
+        # Split by season
+        train_df, val_df, test_df = self.splitter.split(df)
+        
+        # Get feature columns - USE ALL AVAILABLE
+        if use_all_features:
+            feature_columns = self._get_feature_columns(df)
+            logger.info(f"Detected {len(feature_columns)} numeric feature columns")
+        else:
+            # Fallback to basic features
+            feature_columns = [
+                "team_elo", "opponent_elo", "elo_diff", "elo_win_prob", "is_home",
+                "PTS_last5", "PTS_last10", "AST_last5", "REB_last5",
+                "win_pct_season", "days_rest", "back_to_back"
+            ]
+            feature_columns = [c for c in feature_columns if c in df.columns]
+        
+        logger.info(f"\n=== FEATURES USED FOR TRAINING ({len(feature_columns)} total) ===")
+        for i, col in enumerate(feature_columns):
+            logger.info(f"  {i+1:3}. {col}")
+        
+        # Fit preprocessor on training data
+        self.preprocessor.fit(train_df, feature_columns)
+        
+        # Transform all splits
+        X_train = self.preprocessor.transform(train_df)
+        X_val = self.preprocessor.transform(val_df)
+        X_test = self.preprocessor.transform(test_df)
+        
+        y_train = train_df["target"].values
+        y_val = val_df["target"].values
+        y_test = test_df["target"].values
+        
+        logger.info(f"\n=== DATASET SUMMARY ===")
+        logger.info(f"  Training samples: {len(y_train)}")
+        logger.info(f"  Validation samples: {len(y_val)}")
+        logger.info(f"  Test samples: {len(y_test)}")
+        logger.info(f"  Features: {len(feature_columns)}")
+        
+        return {
+            "X_train": X_train, "y_train": y_train,
+            "X_val": X_val, "y_val": y_val,
+            "X_test": X_test, "y_test": y_test,
+            "feature_columns": feature_columns,
+            "preprocessor": self.preprocessor,
+            "train_df": train_df,
+            "val_df": val_df,
+            "test_df": test_df
+        }
+    
+    def save_dataset(self, dataset: Dict, name: str = "game_dataset"):
+        path = PROCESSED_DATA_DIR / f"{name}.joblib"
+        joblib.dump(dataset, path)
+        logger.info(f"Saved dataset to {path}")
+    
+    def load_dataset(self, name: str = "game_dataset") -> Dict:
+        path = PROCESSED_DATA_DIR / f"{name}.joblib"
+        return joblib.load(path)
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Preprocessing")
+    parser.add_argument("--build", action="store_true", help="Build dataset from features")
+    parser.add_argument("--test", action="store_true", help="Run tests")
+    
+    args = parser.parse_args()
+    
+    logging.basicConfig(level=logging.INFO)
+    
+    if args.build:
+        print("=== Building Dataset from Features ===")
+        
+        features_path = PROCESSED_DATA_DIR / "game_features.parquet"
+        
+        if not features_path.exists():
+            print(f"ERROR: Features not found at {features_path}")
+            print("Run 'python -m src.feature_engineering --process' first.")
+            exit(1)
+        
+        print(f"Loading features from {features_path}...")
+        features_df = pd.read_parquet(features_path)
+        print(f"Loaded {len(features_df)} rows")
+        
+        builder = GameDatasetBuilder()
+        dataset = builder.build_dataset(features_df, use_all_features=True)
+        builder.save_dataset(dataset)
+        
+        print(f"\n✅ Dataset saved!")
+        print(f"   Training samples: {len(dataset['y_train'])}")
+        print(f"   Features used: {len(dataset['feature_columns'])}")
+    
+    elif args.test:
+        print("Testing Season-Based Splitter...")
+        sample_data = pd.DataFrame({
+            "SEASON": ["2022-23"] * 100 + ["2023-24"] * 50 + ["2024-25"] * 25,
+            "feature1": np.random.randn(175),
+            "WL": np.random.choice(["W", "L"], 175)
+        })
+        
+        splitter = SeasonBasedSplitter()
+        train, val, test = splitter.split(sample_data)
+        
+        print(f"Train: {len(train)}, Val: {len(val)}, Test: {len(test)}")
+    
+    else:
+        print("Use --build to build dataset or --test to run tests")

src/visualization.py

@@ -0,0 +1,539 @@
+"""
+NBA ML Prediction System - Data Visualization
+==============================================
+Create and save visualizations for analysis and reporting.
+All graphs are saved to the 'graphs' folder.
+"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+import seaborn as sns
+from pathlib import Path
+from typing import Optional, List, Dict
+from datetime import datetime
+import logging
+
+from src.config import PROJECT_ROOT, RAW_DATA_DIR, PROCESSED_DATA_DIR
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+GRAPHS_DIR = PROJECT_ROOT / "graphs"
+GRAPHS_DIR.mkdir(exist_ok=True)
+
+# Style settings
+plt.style.use('dark_background')
+COLORS = {
+    'primary': '#7c3aed',
+    'secondary': '#00d4ff',
+    'success': '#10b981',
+    'warning': '#f59e0b',
+    'danger': '#ef4444',
+    'gradient': ['#7c3aed', '#00d4ff', '#f472b6']
+}
+
+def save_figure(fig, name: str, dpi: int = 150):
+    """Save figure to graphs folder."""
+    path = GRAPHS_DIR / f"{name}.png"
+    fig.savefig(path, dpi=dpi, bbox_inches='tight', facecolor='#1a1a2e', edgecolor='none')
+    logger.info(f"Saved graph to {path}")
+    plt.close(fig)
+    return path
+
+
+# =============================================================================
+# TEAM PERFORMANCE VISUALIZATIONS
+# =============================================================================
+class TeamVisualizer:
+    """Visualization for team-level statistics."""
+    
+    def plot_elo_history(self, elo_history: pd.DataFrame, team_abbrev: str = None) -> Path:
+        """
+        Plot ELO rating history over time.
+        
+        Args:
+            elo_history: DataFrame with columns [date, team, elo]
+        """
+        fig, ax = plt.subplots(figsize=(14, 7))
+        
+        if team_abbrev:
+            data = elo_history[elo_history['team'] == team_abbrev]
+            ax.plot(data['date'], data['elo'], color=COLORS['primary'], linewidth=2)
+            ax.fill_between(data['date'], 1500, data['elo'], alpha=0.3, color=COLORS['primary'])
+            title = f"{team_abbrev} ELO Rating History"
+        else:
+            # Plot top 5 teams
+            for i, (team, data) in enumerate(elo_history.groupby('team')):
+                if i < 5:
+                    ax.plot(data['date'], data['elo'], label=team, linewidth=2)
+            ax.legend(loc='upper left')
+            title = "ELO Rating History - Top Teams"
+        
+        ax.axhline(y=1500, color='white', linestyle='--', alpha=0.3, label='Average')
+        ax.set_xlabel('Date', fontsize=12)
+        ax.set_ylabel('ELO Rating', fontsize=12)
+        ax.set_title(title, fontsize=16, fontweight='bold')
+        ax.grid(True, alpha=0.2)
+        
+        return save_figure(fig, f"elo_history_{team_abbrev or 'all'}")
+    
+    def plot_team_comparison(self, team_stats: pd.DataFrame, 
+                              metrics: List[str] = None) -> Path:
+        """
+        Radar chart comparing multiple teams.
+        """
+        if metrics is None:
+            metrics = ['PTS', 'AST', 'REB', 'STL', 'BLK', 'FG_PCT']
+        
+        # Normalize metrics to 0-1 scale
+        normalized = team_stats[metrics].copy()
+        for col in metrics:
+            normalized[col] = (normalized[col] - normalized[col].min()) / (normalized[col].max() - normalized[col].min())
+        
+        # Create radar chart
+        fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(polar=True))
+        
+        angles = np.linspace(0, 2 * np.pi, len(metrics), endpoint=False).tolist()
+        angles += angles[:1]
+        
+        for i, (idx, row) in enumerate(team_stats.head(5).iterrows()):
+            values = normalized.loc[idx, metrics].tolist()
+            values += values[:1]
+            ax.plot(angles, values, linewidth=2, label=row.get('TEAM_ABBREVIATION', f'Team {i+1}'))
+            ax.fill(angles, values, alpha=0.1)
+        
+        ax.set_xticks(angles[:-1])
+        ax.set_xticklabels(metrics)
+        ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1))
+        ax.set_title('Team Comparison', fontsize=16, fontweight='bold', pad=20)
+        
+        return save_figure(fig, "team_comparison_radar")
+    
+    def plot_standings(self, standings: pd.DataFrame) -> Path:
+        """
+        Horizontal bar chart of team standings by win percentage.
+        """
+        fig, ax = plt.subplots(figsize=(12, 10))
+        
+        data = standings.sort_values('W_PCT', ascending=True).tail(15)
+        colors = [COLORS['primary'] if i >= 7 else COLORS['secondary'] 
+                  for i in range(len(data))]
+        
+        bars = ax.barh(data['TEAM_ABBREVIATION'], data['W_PCT'], color=colors, edgecolor='white', linewidth=0.5)
+        
+        # Add playoff line
+        ax.axvline(x=0.5, color=COLORS['warning'], linestyle='--', linewidth=2, label='Playoff Cutoff')
+        
+        ax.set_xlabel('Win Percentage', fontsize=12)
+        ax.set_title('Team Standings', fontsize=16, fontweight='bold')
+        ax.set_xlim(0, 1)
+        ax.legend()
+        ax.grid(axis='x', alpha=0.2)
+        
+        # Add value labels
+        for bar, val in zip(bars, data['W_PCT']):
+            ax.text(val + 0.02, bar.get_y() + bar.get_height()/2, 
+                   f'{val:.1%}', va='center', fontsize=10)
+        
+        return save_figure(fig, "standings")
+
+
+# =============================================================================
+# GAME PREDICTION VISUALIZATIONS
+# =============================================================================
+class GameVisualizer:
+    """Visualization for game predictions and analysis."""
+    
+    def plot_prediction_calibration(self, predictions: pd.DataFrame) -> Path:
+        """
+        Calibration curve - how well do probabilities match actual outcomes.
+        """
+        fig, ax = plt.subplots(figsize=(10, 10))
+        
+        # Bin predictions
+        bins = np.linspace(0, 1, 11)
+        bin_centers = (bins[:-1] + bins[1:]) / 2
+        
+        predicted_proba = predictions['predicted_proba']
+        actual = predictions['actual']
+        
+        bin_indices = np.digitize(predicted_proba, bins) - 1
+        bin_indices = np.clip(bin_indices, 0, 9)
+        
+        actual_fractions = []
+        for i in range(10):
+            mask = bin_indices == i
+            if mask.sum() > 0:
+                actual_fractions.append(actual[mask].mean())
+            else:
+                actual_fractions.append(np.nan)
+        
+        # Perfect calibration line
+        ax.plot([0, 1], [0, 1], 'w--', linewidth=2, label='Perfect Calibration')
+        
+        # Actual calibration
+        ax.plot(bin_centers, actual_fractions, 'o-', color=COLORS['primary'], 
+               linewidth=3, markersize=10, label='Model Calibration')
+        
+        ax.set_xlabel('Predicted Probability', fontsize=12)
+        ax.set_ylabel('Actual Win Rate', fontsize=12)
+        ax.set_title('Prediction Calibration Curve', fontsize=16, fontweight='bold')
+        ax.legend()
+        ax.grid(True, alpha=0.2)
+        ax.set_xlim(0, 1)
+        ax.set_ylim(0, 1)
+        
+        return save_figure(fig, "calibration_curve")
+    
+    def plot_accuracy_by_confidence(self, predictions: pd.DataFrame) -> Path:
+        """
+        How does accuracy change with prediction confidence?
+        """
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+        
+        # Calculate confidence as distance from 0.5
+        predictions = predictions.copy()
+        predictions['confidence'] = abs(predictions['predicted_proba'] - 0.5)
+        predictions['correct'] = predictions['predicted'] == predictions['actual']
+        
+        # Bin by confidence
+        bins = np.linspace(0, 0.5, 6)
+        predictions['confidence_bin'] = pd.cut(predictions['confidence'], bins)
+        
+        accuracy_by_conf = predictions.groupby('confidence_bin')['correct'].mean()
+        count_by_conf = predictions.groupby('confidence_bin').size()
+        
+        # Accuracy plot
+        ax1.bar(range(len(accuracy_by_conf)), accuracy_by_conf.values, 
+               color=COLORS['primary'], edgecolor='white')
+        ax1.set_xticks(range(len(accuracy_by_conf)))
+        ax1.set_xticklabels(['Low', 'Med-Low', 'Medium', 'Med-High', 'High'], rotation=45)
+        ax1.set_ylabel('Accuracy', fontsize=12)
+        ax1.set_title('Accuracy by Confidence Level', fontsize=14, fontweight='bold')
+        ax1.set_ylim(0, 1)
+        ax1.axhline(y=0.5, color='white', linestyle='--', alpha=0.3)
+        
+        # Count plot
+        ax2.bar(range(len(count_by_conf)), count_by_conf.values,
+               color=COLORS['secondary'], edgecolor='white')
+        ax2.set_xticks(range(len(count_by_conf)))
+        ax2.set_xticklabels(['Low', 'Med-Low', 'Medium', 'Med-High', 'High'], rotation=45)
+        ax2.set_ylabel('Number of Predictions', fontsize=12)
+        ax2.set_title('Prediction Distribution', fontsize=14, fontweight='bold')
+        
+        plt.tight_layout()
+        return save_figure(fig, "accuracy_by_confidence")
+    
+    def plot_feature_importance(self, importance_df: pd.DataFrame, top_n: int = 15) -> Path:
+        """
+        Bar chart of feature importance.
+        """
+        fig, ax = plt.subplots(figsize=(12, 8))
+        
+        data = importance_df.head(top_n).sort_values('avg_importance', ascending=True)
+        
+        bars = ax.barh(data['feature'], data['avg_importance'], 
+                      color=COLORS['primary'], edgecolor='white', linewidth=0.5)
+        
+        ax.set_xlabel('Importance Score', fontsize=12)
+        ax.set_title('Top Features for Game Prediction', fontsize=16, fontweight='bold')
+        ax.grid(axis='x', alpha=0.2)
+        
+        return save_figure(fig, "feature_importance")
+
+
+# =============================================================================
+# MVP VISUALIZATIONS
+# =============================================================================
+class MVPVisualizer:
+    """Visualization for MVP race analysis."""
+    
+    def plot_mvp_race(self, mvp_df: pd.DataFrame) -> Path:
+        """
+        Horizontal bar chart of MVP race standings.
+        """
+        fig, ax = plt.subplots(figsize=(12, 8))
+        
+        data = mvp_df.head(10).sort_values('mvp_score', ascending=True)
+        colors = plt.cm.Purples(np.linspace(0.3, 0.9, len(data)))
+        
+        bars = ax.barh(data['PLAYER_NAME'], data['mvp_score'], color=colors, edgecolor='white')
+        
+        ax.set_xlabel('MVP Score', fontsize=12)
+        ax.set_title('MVP Race 2024-25', fontsize=16, fontweight='bold')
+        ax.grid(axis='x', alpha=0.2)
+        
+        # Add value labels
+        for bar, val in zip(bars, data['mvp_score']):
+            ax.text(val + 0.5, bar.get_y() + bar.get_height()/2, 
+                   f'{val:.1f}', va='center', fontsize=10)
+        
+        return save_figure(fig, "mvp_race")
+    
+    def plot_mvp_similarity(self, mvp_df: pd.DataFrame) -> Path:
+        """
+        Scatter plot of MVP score vs historical similarity.
+        """
+        fig, ax = plt.subplots(figsize=(10, 8))
+        
+        scatter = ax.scatter(mvp_df['mvp_similarity'], mvp_df['mvp_score'],
+                            s=mvp_df['PTS'] * 10, c=mvp_df['mvp_score'],
+                            cmap='Purples', alpha=0.7, edgecolor='white')
+        
+        # Add labels for top candidates
+        for idx, row in mvp_df.head(5).iterrows():
+            ax.annotate(row['PLAYER_NAME'], 
+                       (row['mvp_similarity'], row['mvp_score']),
+                       xytext=(10, 10), textcoords='offset points',
+                       fontsize=10, color='white')
+        
+        ax.set_xlabel('Similarity to Historical MVPs', fontsize=12)
+        ax.set_ylabel('MVP Score', fontsize=12)
+        ax.set_title('MVP Score vs Historical Similarity', fontsize=16, fontweight='bold')
+        ax.grid(True, alpha=0.2)
+        
+        cbar = plt.colorbar(scatter, ax=ax)
+        cbar.set_label('MVP Score', fontsize=10)
+        
+        return save_figure(fig, "mvp_similarity_scatter")
+    
+    def plot_stat_comparison(self, mvp_df: pd.DataFrame, 
+                              stats: List[str] = None) -> Path:
+        """
+        Bar chart comparing stats of top MVP candidates.
+        """
+        if stats is None:
+            stats = ['PTS', 'REB', 'AST']
+        
+        fig, axes = plt.subplots(1, len(stats), figsize=(5 * len(stats), 6))
+        if len(stats) == 1:
+            axes = [axes]
+        
+        top_players = mvp_df.head(5)
+        
+        for ax, stat in zip(axes, stats):
+            colors = plt.cm.Purples(np.linspace(0.4, 0.9, len(top_players)))
+            bars = ax.bar(top_players['PLAYER_NAME'], top_players[stat], color=colors, edgecolor='white')
+            ax.set_ylabel(stat, fontsize=12)
+            ax.set_title(f'{stat} Comparison', fontsize=14, fontweight='bold')
+            ax.tick_params(axis='x', rotation=45)
+            
+            for bar, val in zip(bars, top_players[stat]):
+                ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5,
+                       f'{val:.1f}', ha='center', fontsize=10)
+        
+        plt.tight_layout()
+        return save_figure(fig, "mvp_stat_comparison")
+
+
+# =============================================================================
+# CHAMPIONSHIP VISUALIZATIONS
+# =============================================================================
+class ChampionshipVisualizer:
+    """Visualization for championship predictions."""
+    
+    def plot_championship_odds(self, champ_df: pd.DataFrame) -> Path:
+        """
+        Pie chart of championship probabilities.
+        """
+        fig, ax = plt.subplots(figsize=(10, 10))
+        
+        data = champ_df.head(8)
+        colors = plt.cm.Purples(np.linspace(0.3, 0.9, len(data)))
+        
+        wedges, texts, autotexts = ax.pie(
+            data['champ_probability'], 
+            labels=data['TEAM_ABBREVIATION'],
+            autopct='%1.1f%%',
+            colors=colors,
+            explode=[0.05] * len(data),
+            shadow=True,
+            startangle=90
+        )
+        
+        for text in texts:
+            text.set_fontsize(12)
+            text.set_color('white')
+        for autotext in autotexts:
+            autotext.set_fontsize(10)
+            autotext.set_color('white')
+        
+        ax.set_title('Championship Probabilities', fontsize=16, fontweight='bold')
+        
+        return save_figure(fig, "championship_odds_pie")
+    
+    def plot_strength_vs_experience(self, champ_df: pd.DataFrame) -> Path:
+        """
+        Scatter plot of team strength vs playoff experience.
+        """
+        fig, ax = plt.subplots(figsize=(12, 8))
+        
+        scatter = ax.scatter(
+            champ_df['playoff_experience'],
+            champ_df['strength_rating'],
+            s=champ_df['champ_probability'] * 3000,
+            c=champ_df['champ_probability'],
+            cmap='Purples',
+            alpha=0.7,
+            edgecolor='white',
+            linewidth=2
+        )
+        
+        # Add labels
+        for idx, row in champ_df.iterrows():
+            ax.annotate(
+                row['TEAM_ABBREVIATION'],
+                (row['playoff_experience'], row['strength_rating']),
+                xytext=(10, 5), textcoords='offset points',
+                fontsize=11, color='white', fontweight='bold'
+            )
+        
+        ax.set_xlabel('Playoff Experience Index', fontsize=12)
+        ax.set_ylabel('Strength Rating', fontsize=12)
+        ax.set_title('Championship Contenders: Strength vs Experience', fontsize=16, fontweight='bold')
+        ax.grid(True, alpha=0.2)
+        
+        cbar = plt.colorbar(scatter, ax=ax)
+        cbar.set_label('Championship Probability', fontsize=10)
+        
+        return save_figure(fig, "strength_vs_experience")
+
+
+# =============================================================================
+# SEASON ANALYSIS VISUALIZATIONS
+# =============================================================================
+class SeasonVisualizer:
+    """Visualization for historical season analysis."""
+    
+    def plot_scoring_trends(self, season_data: pd.DataFrame) -> Path:
+        """
+        Line chart of scoring trends across seasons.
+        """
+        fig, ax = plt.subplots(figsize=(14, 7))
+        
+        ax.plot(season_data['season'], season_data['avg_pts'], 
+               color=COLORS['primary'], linewidth=3, marker='o', markersize=8)
+        ax.fill_between(season_data['season'], season_data['avg_pts'], alpha=0.3, color=COLORS['primary'])
+        
+        ax.set_xlabel('Season', fontsize=12)
+        ax.set_ylabel('Average Points Per Game', fontsize=12)
+        ax.set_title('NBA Scoring Trends Over Time', fontsize=16, fontweight='bold')
+        ax.tick_params(axis='x', rotation=45)
+        ax.grid(True, alpha=0.2)
+        
+        return save_figure(fig, "scoring_trends")
+    
+    def plot_three_point_revolution(self, season_data: pd.DataFrame) -> Path:
+        """
+        Dual-axis chart showing 3PA and 3P% trends.
+        """
+        fig, ax1 = plt.subplots(figsize=(14, 7))
+        ax2 = ax1.twinx()
+        
+        ax1.bar(season_data['season'], season_data['avg_3pa'], 
+               color=COLORS['secondary'], alpha=0.7, label='3-Point Attempts')
+        ax2.plot(season_data['season'], season_data['avg_3pct'], 
+                color=COLORS['primary'], linewidth=3, marker='o', label='3-Point %')
+        
+        ax1.set_xlabel('Season', fontsize=12)
+        ax1.set_ylabel('3-Point Attempts', fontsize=12, color=COLORS['secondary'])
+        ax2.set_ylabel('3-Point Percentage', fontsize=12, color=COLORS['primary'])
+        ax1.set_title('The 3-Point Revolution', fontsize=16, fontweight='bold')
+        ax1.tick_params(axis='x', rotation=45)
+        
+        lines1, labels1 = ax1.get_legend_handles_labels()
+        lines2, labels2 = ax2.get_legend_handles_labels()
+        ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')
+        
+        return save_figure(fig, "three_point_revolution")
+
+
+# =============================================================================
+# MASTER VISUALIZER
+# =============================================================================
+class NBAVisualizer:
+    """Master class combining all visualization capabilities."""
+    
+    def __init__(self):
+        self.team = TeamVisualizer()
+        self.game = GameVisualizer()
+        self.mvp = MVPVisualizer()
+        self.championship = ChampionshipVisualizer()
+        self.season = SeasonVisualizer()
+    
+    def generate_all_visualizations(self, data: Dict[str, pd.DataFrame]) -> List[Path]:
+        """
+        Generate all available visualizations from provided data.
+        
+        Args:
+            data: Dict with keys like 'standings', 'mvp', 'championship', etc.
+        
+        Returns:
+            List of paths to saved graphs
+        """
+        saved_paths = []
+        
+        if 'standings' in data:
+            saved_paths.append(self.team.plot_standings(data['standings']))
+        
+        if 'mvp' in data:
+            saved_paths.append(self.mvp.plot_mvp_race(data['mvp']))
+            saved_paths.append(self.mvp.plot_stat_comparison(data['mvp']))
+        
+        if 'championship' in data:
+            saved_paths.append(self.championship.plot_championship_odds(data['championship']))
+            saved_paths.append(self.championship.plot_strength_vs_experience(data['championship']))
+        
+        if 'predictions' in data:
+            saved_paths.append(self.game.plot_calibration(data['predictions']))
+            saved_paths.append(self.game.plot_accuracy_by_confidence(data['predictions']))
+        
+        logger.info(f"Generated {len(saved_paths)} visualizations")
+        return saved_paths
+
+
+# =============================================================================
+# CLI INTERFACE
+# =============================================================================
+if __name__ == "__main__":
+    print(f"Generating sample visualizations to {GRAPHS_DIR}...")
+    
+    # Create sample data for testing
+    sample_mvp = pd.DataFrame({
+        'PLAYER_NAME': ['Shai Gilgeous-Alexander', 'Nikola Jokic', 'Jayson Tatum', 
+                       'Luka Doncic', 'Giannis Antetokounmpo'],
+        'PTS': [31.5, 26.8, 27.2, 28.5, 30.5],
+        'REB': [5.5, 12.5, 8.2, 8.8, 11.5],
+        'AST': [6.0, 9.2, 4.8, 8.2, 6.5],
+        'mvp_score': [85.2, 82.1, 78.5, 77.2, 76.8],
+        'mvp_similarity': [0.92, 0.95, 0.85, 0.88, 0.90]
+    })
+    
+    sample_champ = pd.DataFrame({
+        'TEAM_ABBREVIATION': ['OKC', 'CLE', 'BOS', 'DEN', 'MEM', 'HOU', 'NYK', 'GSW'],
+        'W_PCT': [0.70, 0.68, 0.65, 0.62, 0.60, 0.58, 0.55, 0.52],
+        'playoff_experience': [0.3, 0.5, 0.8, 0.9, 0.4, 0.2, 0.5, 0.95],
+        'strength_rating': [45, 42, 40, 38, 35, 33, 30, 28],
+        'champ_probability': [0.18, 0.15, 0.14, 0.12, 0.10, 0.09, 0.08, 0.07]
+    })
+    
+    viz = NBAVisualizer()
+    
+    # Generate sample visualizations
+    print("Creating MVP race chart...")
+    viz.mvp.plot_mvp_race(sample_mvp)
+    
+    print("Creating MVP stat comparison...")
+    viz.mvp.plot_stat_comparison(sample_mvp)
+    
+    print("Creating championship odds pie chart...")
+    viz.championship.plot_championship_odds(sample_champ)
+    
+    print("Creating strength vs experience chart...")
+    viz.championship.plot_strength_vs_experience(sample_champ)
+    
+    print(f"\n✅ Visualizations saved to: {GRAPHS_DIR}")

web/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

web/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

web/eslint.config.js

@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])

web/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🏀</text></svg>" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>NBA ML Predictor</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

web/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "web",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "vite": "^7.2.4"
+  }
+}

web/src/App.css

@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}

web/src/App.jsx

@@ -0,0 +1,156 @@
+import { useState, useEffect } from 'react'
+import './index.css'
+
+// Icons
+import {
+  IconLive, IconTarget, IconChart, IconTrophy, IconCrown,
+  IconVs, IconRefresh
+} from './icons'
+
+// Pages
+import LiveGames from './pages/LiveGames'
+import Predictions from './pages/Predictions'
+import Accuracy from './pages/Accuracy'
+import MvpRace from './pages/MvpRace'
+import Championship from './pages/Championship'
+import HeadToHead from './pages/HeadToHead'
+
+// Chevron icon for collapse toggle
+function IconChevron({ className = '', direction = 'left' }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+      {direction === 'left' ? (
+        <polyline points="15 18 9 12 15 6"></polyline>
+      ) : (
+        <polyline points="9 18 15 12 9 6"></polyline>
+      )}
+    </svg>
+  )
+}
+
+function App() {
+  const [activePage, setActivePage] = useState('live')
+  const [isRefreshing, setIsRefreshing] = useState(false)
+  const [sidebarCollapsed, setSidebarCollapsed] = useState(false)
+  const [sidebarHovered, setSidebarHovered] = useState(false)
+
+  const handleRefresh = () => {
+    setIsRefreshing(true)
+    window.location.reload()
+  }
+
+  const navSections = [
+    {
+      title: 'Games',
+      items: [
+        { id: 'live', name: 'Live Games', icon: IconLive },
+        { id: 'predictions', name: 'Predictions', icon: IconTarget },
+      ]
+    },
+    {
+      title: 'Analysis',
+      items: [
+        { id: 'h2h', name: 'Head to Head', icon: IconVs },
+        { id: 'accuracy', name: 'Model Accuracy', icon: IconChart },
+      ]
+    },
+    {
+      title: 'Rankings',
+      items: [
+        { id: 'mvp', name: 'MVP Race', icon: IconTrophy },
+        { id: 'championship', name: 'Championship', icon: IconCrown },
+      ]
+    }
+  ]
+
+  const renderPage = () => {
+    switch (activePage) {
+      case 'live': return <LiveGames />
+      case 'predictions': return <Predictions />
+      case 'accuracy': return <Accuracy />
+      case 'mvp': return <MvpRace />
+      case 'championship': return <Championship />
+      case 'h2h': return <HeadToHead />
+      default: return <LiveGames />
+    }
+  }
+
+  // Determine if sidebar should be expanded (not collapsed OR being hovered)
+  const isExpanded = !sidebarCollapsed || sidebarHovered
+
+  return (
+    <div className={`app-layout ${sidebarCollapsed ? 'sidebar-collapsed' : ''}`}>
+      {/* Sidebar */}
+      <aside
+        className={`sidebar ${sidebarCollapsed ? 'collapsed' : ''} ${sidebarHovered ? 'hovered' : ''}`}
+        onMouseEnter={() => sidebarCollapsed && setSidebarHovered(true)}
+        onMouseLeave={() => setSidebarHovered(false)}
+      >
+        <div className="sidebar-header">
+          <div className="sidebar-logo">
+            <div className="sidebar-logo-icon">
+              <img
+                src="https://cdn.nba.com/logos/leagues/logo-nba.svg"
+                alt="NBA"
+                style={{ width: '32px', height: '32px' }}
+              />
+            </div>
+            <span className="sidebar-logo-text">NBA sage</span>
+          </div>
+          <button
+            className="sidebar-toggle"
+            onClick={() => {
+              setSidebarCollapsed(!sidebarCollapsed)
+              setSidebarHovered(false)
+            }}
+            title={sidebarCollapsed ? 'Expand sidebar' : 'Collapse sidebar'}
+          >
+            <IconChevron direction={sidebarCollapsed ? 'right' : 'left'} />
+          </button>
+        </div>
+
+        <nav className="sidebar-nav">
+          {navSections.map((section) => (
+            <div key={section.title} className="nav-section">
+              <div className="nav-section-title">{section.title}</div>
+              {section.items.map((item) => (
+                <div
+                  key={item.id}
+                  className={`nav-item ${activePage === item.id ? 'active' : ''}`}
+                  onClick={() => setActivePage(item.id)}
+                  title={sidebarCollapsed && !sidebarHovered ? item.name : ''}
+                >
+                  <item.icon className="nav-icon" />
+                  <span className="nav-text">{item.name}</span>
+                </div>
+              ))}
+            </div>
+          ))}
+        </nav>
+
+        <div className="sidebar-footer">
+          <button
+            className="btn btn-ghost btn-block"
+            onClick={handleRefresh}
+            disabled={isRefreshing}
+            title={sidebarCollapsed && !sidebarHovered ? 'Refresh Data' : ''}
+          >
+            <IconRefresh className={`nav-icon ${isRefreshing ? 'spinning' : ''}`} />
+            <span className="nav-text">Refresh Data</span>
+          </button>
+          <div className="sidebar-version">
+            NBA sage
+          </div>
+        </div>
+      </aside>
+
+      {/* Main Content */}
+      <main className="main-content">
+        {renderPage()}
+      </main>
+    </div>
+  )
+}
+
+export default App
+

web/src/api.js

@@ -0,0 +1,87 @@
+/**
+ * API utilities for NBA ML Predictor
+ */
+
+// Use relative URL in production, localhost in development
+const API_BASE = import.meta.env.DEV ? 'http://localhost:8000/api' : '/api';
+
+
+/**
+ * Generic fetch wrapper with error handling
+ */
+async function fetchAPI(endpoint, options = {}) {
+    try {
+        const response = await fetch(`${API_BASE}${endpoint}`, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+
+        if (!response.ok) {
+            throw new Error(`API Error: ${response.status}`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        console.error('API Error:', error);
+        throw error;
+    }
+}
+
+/**
+ * Get live games with predictions
+ */
+export async function getLiveGames() {
+    return fetchAPI('/games/live');
+}
+
+/**
+ * Get upcoming games
+ */
+export async function getUpcomingGames(days = 7) {
+    return fetchAPI(`/games/upcoming?days=${days}`);
+}
+
+/**
+ * Get prediction for a single game
+ */
+export async function predictGame(home, away) {
+    return fetchAPI(`/predict?home=${home}&away=${away}`);
+}
+
+/**
+ * Get model accuracy stats
+ */
+export async function getAccuracy() {
+    return fetchAPI('/accuracy');
+}
+
+/**
+ * Get MVP race standings
+ */
+export async function getMvpRace() {
+    return fetchAPI('/mvp');
+}
+
+/**
+ * Get championship odds
+ */
+export async function getChampionshipOdds() {
+    return fetchAPI('/championship');
+}
+
+/**
+ * Get list of all teams
+ */
+export async function getTeams() {
+    return fetchAPI('/teams');
+}
+
+/**
+ * Health check
+ */
+export async function healthCheck() {
+    return fetchAPI('/health');
+}

web/src/icons.jsx

@@ -0,0 +1,162 @@
+/**
+ * SVG Icons for the application
+ * Professional, minimal icons
+ */
+
+export function IconLive({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="12" cy="12" r="3" fill="currentColor" />
+            <path d="M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14" />
+        </svg>
+    );
+}
+
+export function IconTarget({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="6" />
+            <circle cx="12" cy="12" r="2" fill="currentColor" />
+        </svg>
+    );
+}
+
+export function IconChart({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M3 3v18h18" />
+            <path d="M18 9l-5 5-4-4-3 3" />
+        </svg>
+    );
+}
+
+export function IconTrophy({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6" />
+            <path d="M18 9h1.5a2.5 2.5 0 0 0 0-5H18" />
+            <path d="M4 22h16" />
+            <path d="M10 14.66V17c0 .55-.47.98-.97 1.21C7.85 18.75 7 20.24 7 22" />
+            <path d="M14 14.66V17c0 .55.47.98.97 1.21C16.15 18.75 17 20.24 17 22" />
+            <path d="M18 2H6v7a6 6 0 0 0 12 0V2Z" />
+        </svg>
+    );
+}
+
+export function IconCrown({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M2 4l3 12h14l3-12-6 7-4-7-4 7-6-7z" />
+            <path d="M5 20h14" />
+        </svg>
+    );
+}
+
+export function IconUsers({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <path d="M23 21v-2a4 4 0 0 0-3-3.87" />
+            <path d="M16 3.13a4 4 0 0 1 0 7.75" />
+        </svg>
+    );
+}
+
+export function IconPerson({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="12" cy="8" r="4" />
+            <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" />
+        </svg>
+    );
+}
+
+export function IconVs({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M6 3l6 9-6 9M18 3l-6 9 6 9" />
+        </svg>
+    );
+}
+
+export function IconStandings({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <rect x="3" y="3" width="18" height="18" rx="2" />
+            <path d="M3 9h18" />
+            <path d="M9 3v18" />
+        </svg>
+    );
+}
+
+export function IconRefresh({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" />
+            <path d="M21 3v5h-5" />
+        </svg>
+    );
+}
+
+export function IconSearch({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="11" cy="11" r="8" />
+            <path d="M21 21l-4.35-4.35" />
+        </svg>
+    );
+}
+
+export function IconCheck({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M20 6L9 17l-5-5" />
+        </svg>
+    );
+}
+
+export function IconX({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M18 6L6 18M6 6l12 12" />
+        </svg>
+    );
+}
+
+export function IconBasketball({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="12" cy="12" r="10" />
+            <path d="M2 12h20" />
+            <path d="M12 2a10 10 0 0 1 0 20" />
+            <path d="M12 2a10 10 0 0 0 0 20" />
+            <path d="M12 2v20" />
+        </svg>
+    );
+}
+
+export function IconCalendar({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <rect x="3" y="4" width="18" height="18" rx="2" />
+            <path d="M16 2v4M8 2v4M3 10h18" />
+        </svg>
+    );
+}
+
+export function IconClock({ className = '' }) {
+    return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 6v6l4 2" />
+        </svg>
+    );
+}
+
+export default {
+    IconLive, IconTarget, IconChart, IconTrophy, IconCrown, IconUsers,
+    IconPerson, IconVs, IconStandings, IconRefresh, IconSearch, IconCheck,
+    IconX, IconBasketball, IconCalendar, IconClock
+};

web/src/index.css

@@ -0,0 +1,1378 @@
+/* ===========================================================================
+   NBA ML Predictor - Professional Design System
+   Sleek, Modern, Sports-Premium Aesthetic
+   =========================================================================== */
+
+/* CSS Reset & Box Sizing */
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+/* =========================================================================
+   Design Tokens
+   ========================================================================= */
+:root {
+  /* Colors - Deep Dark Theme */
+  --bg-primary: #000000;
+  --bg-secondary: #0d0d0d;
+  --bg-tertiary: #141414;
+  --bg-card: #0a0a0a;
+  --bg-card-hover: #111111;
+  --bg-elevated: #1a1a1a;
+
+  /* Text Hierarchy */
+  --text-primary: #ffffff;
+  --text-secondary: #b3b3b3;
+  --text-muted: #666666;
+  --text-dim: #444444;
+
+  /* Accent Colors - Sophisticated */
+  --accent-primary: #00c8ff;
+  --accent-secondary: #ff6b35;
+  --accent-success: #00d26a;
+  --accent-warning: #ffb800;
+  --accent-danger: #ff3b3b;
+
+  /* Subtle Gradients */
+  --gradient-primary: linear-gradient(135deg, #00c8ff 0%, #0099cc 100%);
+  --gradient-secondary: linear-gradient(135deg, #ff6b35 0%, #cc5529 100%);
+  --gradient-subtle: linear-gradient(180deg, rgba(255, 255, 255, 0.03) 0%, rgba(255, 255, 255, 0) 100%);
+
+  /* Borders & Surfaces */
+  --border-subtle: 1px solid rgba(255, 255, 255, 0.06);
+  --border-medium: 1px solid rgba(255, 255, 255, 0.1);
+  --border-focus: 1px solid var(--accent-primary);
+
+  /* Shadows */
+  --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.3);
+  --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.4);
+  --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.5);
+  --shadow-glow: 0 0 20px rgba(0, 200, 255, 0.15);
+
+  /* Border Radius */
+  --radius-xs: 4px;
+  --radius-sm: 6px;
+  --radius-md: 8px;
+  --radius-lg: 12px;
+  --radius-xl: 16px;
+
+  /* Spacing Scale */
+  --space-1: 4px;
+  --space-2: 8px;
+  --space-3: 12px;
+  --space-4: 16px;
+  --space-5: 20px;
+  --space-6: 24px;
+  --space-8: 32px;
+  --space-10: 40px;
+  --space-12: 48px;
+
+  /* Typography */
+  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  --font-mono: 'SF Mono', 'Monaco', 'Inconsolata', monospace;
+
+  /* Transitions */
+  --transition-fast: 100ms ease;
+  --transition-base: 200ms ease;
+  --transition-slow: 300ms ease;
+}
+
+/* =========================================================================
+   Base Styles
+   ========================================================================= */
+html {
+  font-size: 14px;
+}
+
+body {
+  font-family: var(--font-sans);
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.5;
+  min-height: 100vh;
+  overflow-x: hidden;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+#root {
+  min-height: 100vh;
+}
+
+/* =========================================================================
+   Typography
+   ========================================================================= */
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-weight: 600;
+  line-height: 1.25;
+  letter-spacing: -0.025em;
+  color: var(--text-primary);
+}
+
+h1 {
+  font-size: 2rem;
+  font-weight: 700;
+}
+
+h2 {
+  font-size: 1.5rem;
+}
+
+h3 {
+  font-size: 1.125rem;
+}
+
+h4 {
+  font-size: 1rem;
+}
+
+.text-gradient {
+  background: var(--gradient-primary);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+.text-muted {
+  color: var(--text-muted);
+}
+
+.text-secondary {
+  color: var(--text-secondary);
+}
+
+/* =========================================================================
+   Layout
+   ========================================================================= */
+.app-layout {
+  display: flex;
+  min-height: 100vh;
+  transition: all var(--transition-slow);
+}
+
+.app-layout.sidebar-collapsed .main-content {
+  margin-left: 72px;
+}
+
+/* Sidebar - Collapsible with Hover Expand */
+.sidebar {
+  width: 240px;
+  background: var(--bg-secondary);
+  border-right: var(--border-subtle);
+  position: fixed;
+  top: 0;
+  left: 0;
+  height: 100vh;
+  z-index: 100;
+  display: flex;
+  flex-direction: column;
+  padding: var(--space-5);
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  overflow: hidden;
+}
+
+/* Collapsed Sidebar */
+.sidebar.collapsed {
+  width: 72px;
+  padding: var(--space-4) var(--space-3);
+}
+
+/* Hover Expansion with Glass Effect */
+.sidebar.collapsed.hovered {
+  width: 240px;
+  padding: var(--space-5);
+  background: rgba(13, 13, 13, 0.95);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5),
+    0 0 0 1px rgba(255, 255, 255, 0.08);
+  border-right: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.sidebar-header {
+  padding-bottom: var(--space-6);
+  border-bottom: var(--border-subtle);
+  margin-bottom: var(--space-4);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-2);
+}
+
+.sidebar-logo {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  min-width: 0;
+  flex: 1;
+}
+
+.sidebar-logo-icon {
+  width: 32px;
+  height: 32px;
+  min-width: 32px;
+  background: var(--gradient-primary);
+  border-radius: var(--radius-sm);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: transform 0.3s ease, box-shadow 0.3s ease;
+}
+
+.sidebar:hover .sidebar-logo-icon {
+  transform: scale(1.05);
+  box-shadow: 0 0 20px rgba(0, 200, 255, 0.3);
+}
+
+.sidebar-logo-text {
+  font-size: 1.125rem;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+  white-space: nowrap;
+  opacity: 1;
+  transition: opacity 0.2s ease 0.1s, transform 0.2s ease;
+}
+
+.sidebar.collapsed .sidebar-logo-text {
+  opacity: 0;
+  transform: translateX(-10px);
+  transition: opacity 0.1s ease, transform 0.1s ease;
+}
+
+.sidebar.collapsed.hovered .sidebar-logo-text {
+  opacity: 1;
+  transform: translateX(0);
+  transition: opacity 0.2s ease 0.1s, transform 0.2s ease 0.1s;
+}
+
+/* Sidebar Toggle Button */
+.sidebar-toggle {
+  width: 28px;
+  height: 28px;
+  min-width: 28px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-tertiary);
+  border: var(--border-subtle);
+  color: var(--text-secondary);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all 0.2s ease;
+  opacity: 0;
+  transform: scale(0.8);
+}
+
+.sidebar:hover .sidebar-toggle {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.sidebar-toggle:hover {
+  background: var(--bg-elevated);
+  color: var(--accent-primary);
+  border-color: var(--accent-primary);
+  box-shadow: 0 0 12px rgba(0, 200, 255, 0.2);
+}
+
+.sidebar-toggle svg {
+  width: 16px;
+  height: 16px;
+  transition: transform 0.3s ease;
+}
+
+.sidebar-toggle:hover svg {
+  transform: scale(1.1);
+}
+
+.sidebar-nav {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-1);
+  overflow-y: auto;
+  overflow-x: hidden;
+}
+
+.nav-section {
+  margin-bottom: var(--space-4);
+}
+
+.nav-section-title {
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-dim);
+  padding: var(--space-2) var(--space-3);
+  margin-bottom: var(--space-1);
+  white-space: nowrap;
+  opacity: 1;
+  transition: opacity 0.2s ease;
+}
+
+.sidebar.collapsed .nav-section-title {
+  opacity: 0;
+  height: 0;
+  padding: 0;
+  margin: 0;
+  overflow: hidden;
+}
+
+.sidebar.collapsed.hovered .nav-section-title {
+  opacity: 1;
+  height: auto;
+  padding: var(--space-2) var(--space-3);
+  margin-bottom: var(--space-1);
+}
+
+.nav-item {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  padding: var(--space-3);
+  border-radius: var(--radius-md);
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+  font-weight: 500;
+  font-size: 0.875rem;
+  position: relative;
+  overflow: hidden;
+}
+
+/* Hover glow effect */
+.nav-item::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: radial-gradient(circle at left center, rgba(0, 200, 255, 0.1) 0%, transparent 70%);
+  opacity: 0;
+  transition: opacity 0.3s ease;
+}
+
+.nav-item:hover::before {
+  opacity: 1;
+}
+
+.nav-item:hover {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+  transform: translateX(4px);
+}
+
+.nav-item.active {
+  background: rgba(0, 200, 255, 0.12);
+  color: var(--accent-primary);
+}
+
+.nav-item.active::after {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 3px;
+  height: 20px;
+  background: var(--accent-primary);
+  border-radius: 0 2px 2px 0;
+  box-shadow: 0 0 10px rgba(0, 200, 255, 0.5);
+}
+
+.nav-icon {
+  width: 20px;
+  height: 20px;
+  min-width: 20px;
+  opacity: 0.7;
+  transition: all 0.2s ease;
+}
+
+.nav-item:hover .nav-icon,
+.nav-item.active .nav-icon {
+  opacity: 1;
+  transform: scale(1.1);
+}
+
+.nav-item.active .nav-icon {
+  filter: drop-shadow(0 0 4px rgba(0, 200, 255, 0.5));
+}
+
+.nav-text {
+  white-space: nowrap;
+  opacity: 1;
+  transition: opacity 0.2s ease 0.1s;
+}
+
+.sidebar.collapsed .nav-text {
+  opacity: 0;
+  width: 0;
+  overflow: hidden;
+  transition: opacity 0.1s ease;
+}
+
+.sidebar.collapsed.hovered .nav-text {
+  opacity: 1;
+  width: auto;
+  transition: opacity 0.2s ease 0.15s;
+}
+
+/* Center icons when collapsed */
+.sidebar.collapsed .nav-item {
+  justify-content: center;
+  padding: var(--space-3);
+}
+
+.sidebar.collapsed.hovered .nav-item {
+  justify-content: flex-start;
+}
+
+/* Sidebar Footer */
+.sidebar-footer {
+  margin-top: auto;
+  padding-top: var(--space-4);
+  border-top: var(--border-subtle);
+}
+
+.sidebar-footer .btn {
+  justify-content: flex-start;
+}
+
+.sidebar.collapsed .sidebar-footer .btn {
+  justify-content: center;
+  padding: var(--space-3);
+}
+
+.sidebar.collapsed.hovered .sidebar-footer .btn {
+  justify-content: flex-start;
+  padding: var(--space-3) var(--space-5);
+}
+
+.sidebar-version {
+  margin-top: var(--space-3);
+  font-size: 0.6875rem;
+  color: var(--text-dim);
+  text-align: center;
+  opacity: 1;
+  transition: opacity 0.2s ease;
+}
+
+.sidebar.collapsed .sidebar-version {
+  opacity: 0;
+}
+
+.sidebar.collapsed.hovered .sidebar-version {
+  opacity: 1;
+}
+
+/* Spinning animation for refresh */
+@keyframes spin {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.spinning {
+  animation: spin 1s linear infinite;
+}
+
+/* Main Content */
+.main-content {
+  flex: 1;
+  margin-left: 240px;
+  padding: var(--space-8);
+  min-height: 100vh;
+  background: var(--bg-primary);
+  transition: margin-left 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.sidebar-collapsed .main-content {
+  margin-left: 72px;
+}
+
+/* =========================================================================
+   Cards
+   ========================================================================= */
+.card {
+  background: var(--bg-card);
+  border: var(--border-subtle);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  transition: all var(--transition-base);
+}
+
+.card:hover {
+  background: var(--bg-card-hover);
+  border-color: rgba(255, 255, 255, 0.1);
+}
+
+.card-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: var(--space-4);
+}
+
+.card-title {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+
+/* =========================================================================
+   Team Logo
+   ========================================================================= */
+.team-logo {
+  width: 48px;
+  height: 48px;
+  object-fit: contain;
+}
+
+.team-logo-sm {
+  width: 32px;
+  height: 32px;
+}
+
+.team-logo-lg {
+  width: 64px;
+  height: 64px;
+}
+
+.team-logo-xl {
+  width: 80px;
+  height: 80px;
+}
+
+/* =========================================================================
+   Game Card - Professional Style
+   ========================================================================= */
+.game-card {
+  background: var(--bg-card);
+  border: var(--border-subtle);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  margin-bottom: var(--space-4);
+  transition: all var(--transition-base);
+}
+
+.game-card:hover {
+  border-color: rgba(255, 255, 255, 0.12);
+  box-shadow: var(--shadow-sm);
+}
+
+.game-card.live {
+  border-color: var(--accent-danger);
+  box-shadow: 0 0 0 1px var(--accent-danger);
+}
+
+.game-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: var(--space-4);
+  padding-bottom: var(--space-3);
+  border-bottom: var(--border-subtle);
+}
+
+.game-status {
+  font-size: 0.75rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.game-status.live {
+  color: var(--accent-danger);
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+}
+
+.live-dot {
+  width: 6px;
+  height: 6px;
+  background: var(--accent-danger);
+  border-radius: 50%;
+  animation: pulse-dot 2s infinite;
+}
+
+@keyframes pulse-dot {
+
+  0%,
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+
+  50% {
+    opacity: 0.5;
+    transform: scale(0.8);
+  }
+}
+
+.game-time {
+  color: var(--text-muted);
+  font-size: 0.75rem;
+}
+
+.game-matchup {
+  display: grid;
+  grid-template-columns: 1fr auto 1fr;
+  align-items: center;
+  gap: var(--space-6);
+}
+
+.team-block {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+}
+
+.team-block.away {
+  align-items: flex-start;
+  text-align: left;
+}
+
+.team-block.home {
+  align-items: flex-end;
+  text-align: right;
+}
+
+.team-info {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+}
+
+.team-block.home .team-info {
+  flex-direction: row-reverse;
+}
+
+.team-details {
+  display: flex;
+  flex-direction: column;
+}
+
+.team-name {
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.team-record {
+  font-size: 0.75rem;
+  color: var(--text-muted);
+}
+
+.team-score {
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-top: var(--space-2);
+}
+
+.team-probability {
+  font-size: 1.5rem;
+  font-weight: 700;
+  color: var(--accent-primary);
+  margin-top: var(--space-2);
+}
+
+/* Score/Prediction Divider */
+.game-center {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: var(--space-2);
+}
+
+.vs-divider {
+  font-size: 0.875rem;
+  color: var(--text-dim);
+  font-weight: 500;
+}
+
+.prediction-indicator {
+  background: var(--bg-elevated);
+  border: var(--border-subtle);
+  border-radius: var(--radius-md);
+  padding: var(--space-3) var(--space-4);
+  text-align: center;
+}
+
+.prediction-label {
+  font-size: 0.625rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--text-muted);
+  margin-bottom: var(--space-1);
+}
+
+.prediction-pick {
+  font-size: 1rem;
+  font-weight: 700;
+  color: var(--accent-primary);
+}
+
+/* =========================================================================
+   Stats Grid
+   ========================================================================= */
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: var(--space-4);
+  margin-bottom: var(--space-6);
+}
+
+.stat-card {
+  background: var(--bg-card);
+  border: var(--border-subtle);
+  border-radius: var(--radius-lg);
+  padding: var(--space-5);
+  display: flex;
+  flex-direction: column;
+}
+
+.stat-label {
+  font-size: 0.75rem;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+  margin-bottom: var(--space-2);
+}
+
+.stat-value {
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  line-height: 1;
+}
+
+.stat-value.accent {
+  color: var(--accent-primary);
+}
+
+.stat-change {
+  font-size: 0.75rem;
+  margin-top: var(--space-2);
+  display: flex;
+  align-items: center;
+  gap: var(--space-1);
+}
+
+.stat-change.positive {
+  color: var(--accent-success);
+}
+
+.stat-change.negative {
+  color: var(--accent-danger);
+}
+
+/* =========================================================================
+   Form Controls
+   ========================================================================= */
+.form-group {
+  margin-bottom: var(--space-4);
+}
+
+.form-label {
+  display: block;
+  font-size: 0.75rem;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+  margin-bottom: var(--space-2);
+}
+
+.form-select {
+  width: 100%;
+  padding: var(--space-3) var(--space-4);
+  background: var(--bg-elevated);
+  border: var(--border-subtle);
+  border-radius: var(--radius-md);
+  color: var(--text-primary);
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  appearance: none;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23666' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: right var(--space-3) center;
+  transition: all var(--transition-fast);
+}
+
+.form-select:hover {
+  border-color: rgba(255, 255, 255, 0.15);
+}
+
+.form-select:focus {
+  outline: none;
+  border-color: var(--accent-primary);
+  box-shadow: 0 0 0 2px rgba(0, 200, 255, 0.1);
+}
+
+.form-input {
+  width: 100%;
+  padding: var(--space-3) var(--space-4);
+  background: var(--bg-elevated);
+  border: var(--border-subtle);
+  border-radius: var(--radius-md);
+  color: var(--text-primary);
+  font-size: 0.875rem;
+  transition: all var(--transition-fast);
+}
+
+.form-input:focus {
+  outline: none;
+  border-color: var(--accent-primary);
+  box-shadow: 0 0 0 2px rgba(0, 200, 255, 0.1);
+}
+
+.form-input::placeholder {
+  color: var(--text-dim);
+}
+
+/* =========================================================================
+   Buttons
+   ========================================================================= */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--space-2);
+  padding: var(--space-3) var(--space-5);
+  border-radius: var(--radius-md);
+  font-size: 0.875rem;
+  font-weight: 600;
+  cursor: pointer;
+  border: none;
+  transition: all var(--transition-fast);
+}
+
+.btn-primary {
+  background: var(--gradient-primary);
+  color: #000;
+}
+
+.btn-primary:hover {
+  opacity: 0.9;
+  box-shadow: var(--shadow-glow);
+}
+
+.btn-secondary {
+  background: var(--bg-elevated);
+  border: var(--border-subtle);
+  color: var(--text-primary);
+}
+
+.btn-secondary:hover {
+  background: var(--bg-tertiary);
+  border-color: rgba(255, 255, 255, 0.15);
+}
+
+.btn-ghost {
+  background: transparent;
+  color: var(--text-secondary);
+}
+
+.btn-ghost:hover {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+}
+
+.btn-icon {
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border-radius: var(--radius-md);
+}
+
+.btn-lg {
+  padding: var(--space-4) var(--space-6);
+  font-size: 1rem;
+}
+
+.btn-block {
+  width: 100%;
+}
+
+/* =========================================================================
+   Badges & Tags
+   ========================================================================= */
+.badge {
+  display: inline-flex;
+  align-items: center;
+  padding: var(--space-1) var(--space-2);
+  border-radius: var(--radius-xs);
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.badge-success {
+  background: rgba(0, 210, 106, 0.15);
+  color: var(--accent-success);
+}
+
+.badge-warning {
+  background: rgba(255, 184, 0, 0.15);
+  color: var(--accent-warning);
+}
+
+.badge-danger {
+  background: rgba(255, 59, 59, 0.15);
+  color: var(--accent-danger);
+}
+
+.badge-neutral {
+  background: rgba(255, 255, 255, 0.08);
+  color: var(--text-secondary);
+}
+
+.confidence-high {
+  background: rgba(0, 210, 106, 0.15);
+  color: var(--accent-success);
+}
+
+.confidence-medium {
+  background: rgba(255, 184, 0, 0.15);
+  color: var(--accent-warning);
+}
+
+.confidence-low {
+  background: rgba(255, 59, 59, 0.15);
+  color: var(--accent-danger);
+}
+
+/* =========================================================================
+   Tables
+   ========================================================================= */
+.table-container {
+  background: var(--bg-card);
+  border: var(--border-subtle);
+  border-radius: var(--radius-lg);
+  overflow: hidden;
+}
+
+.data-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.data-table th {
+  padding: var(--space-3) var(--space-4);
+  text-align: left;
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-muted);
+  background: var(--bg-secondary);
+  border-bottom: var(--border-subtle);
+}
+
+.data-table td {
+  padding: var(--space-4);
+  border-bottom: var(--border-subtle);
+  font-size: 0.875rem;
+}
+
+.data-table tr:last-child td {
+  border-bottom: none;
+}
+
+.data-table tr:hover {
+  background: var(--bg-card-hover);
+}
+
+.table-team {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+}
+
+/* =========================================================================
+   Loading States
+   ========================================================================= */
+.loading {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: var(--space-12);
+}
+
+.spinner {
+  width: 32px;
+  height: 32px;
+  border: 2px solid var(--bg-tertiary);
+  border-top-color: var(--accent-primary);
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+
+.loading-text {
+  margin-top: var(--space-4);
+  color: var(--text-muted);
+  font-size: 0.875rem;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* Skeleton */
+.skeleton {
+  background: linear-gradient(90deg,
+      var(--bg-tertiary) 25%,
+      var(--bg-elevated) 50%,
+      var(--bg-tertiary) 75%);
+  background-size: 200% 100%;
+  animation: shimmer 1.5s infinite;
+  border-radius: var(--radius-sm);
+}
+
+@keyframes shimmer {
+  0% {
+    background-position: 200% 0;
+  }
+
+  100% {
+    background-position: -200% 0;
+  }
+}
+
+/* =========================================================================
+   Empty States
+   ========================================================================= */
+.empty-state {
+  text-align: center;
+  padding: var(--space-12);
+  color: var(--text-muted);
+}
+
+.empty-state-icon {
+  width: 48px;
+  height: 48px;
+  margin: 0 auto var(--space-4);
+  opacity: 0.3;
+}
+
+.empty-state-title {
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--text-secondary);
+  margin-bottom: var(--space-2);
+}
+
+.empty-state-text {
+  font-size: 0.875rem;
+  color: var(--text-muted);
+}
+
+/* =========================================================================
+   Page Header
+   ========================================================================= */
+.page-header {
+  margin-bottom: var(--space-8);
+}
+
+.page-title {
+  font-size: 1.75rem;
+  font-weight: 700;
+  margin-bottom: var(--space-2);
+}
+
+.page-description {
+  color: var(--text-secondary);
+  font-size: 0.875rem;
+}
+
+/* =========================================================================
+   Probability Bar
+   ========================================================================= */
+.probability-bar-container {
+  margin-top: var(--space-4);
+}
+
+.probability-bar {
+  height: 4px;
+  background: var(--bg-tertiary);
+  border-radius: 2px;
+  overflow: hidden;
+  display: flex;
+}
+
+.probability-fill-away {
+  height: 100%;
+  background: var(--accent-secondary);
+  transition: width var(--transition-slow);
+}
+
+.probability-fill-home {
+  height: 100%;
+  background: var(--accent-primary);
+  transition: width var(--transition-slow);
+}
+
+.probability-labels {
+  display: flex;
+  justify-content: space-between;
+  margin-top: var(--space-2);
+  font-size: 0.75rem;
+  color: var(--text-muted);
+}
+
+/* =========================================================================
+   Section Dividers
+   ========================================================================= */
+.section {
+  margin-bottom: var(--space-8);
+}
+
+.section-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: var(--space-4);
+}
+
+.section-title {
+  font-size: 0.875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-secondary);
+}
+
+/* =========================================================================
+   Animations
+   ========================================================================= */
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes slideUp {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.animate-fadeIn {
+  animation: fadeIn 0.3s ease;
+}
+
+.animate-slideUp {
+  animation: slideUp 0.3s ease;
+}
+
+/* Staggered animations */
+.stagger>*:nth-child(1) {
+  animation-delay: 0.05s;
+}
+
+.stagger>*:nth-child(2) {
+  animation-delay: 0.1s;
+}
+
+.stagger>*:nth-child(3) {
+  animation-delay: 0.15s;
+}
+
+.stagger>*:nth-child(4) {
+  animation-delay: 0.2s;
+}
+
+.stagger>*:nth-child(5) {
+  animation-delay: 0.25s;
+}
+
+/* =========================================================================
+   Responsive
+   ========================================================================= */
+@media (max-width: 1024px) {
+  .sidebar {
+    width: 64px;
+    padding: var(--space-3);
+  }
+
+  .sidebar-logo-text,
+  .nav-section-title,
+  .nav-item span:not(.nav-icon) {
+    display: none;
+  }
+
+  .main-content {
+    margin-left: 64px;
+    padding: var(--space-5);
+  }
+}
+
+@media (max-width: 768px) {
+  .sidebar {
+    position: fixed;
+    bottom: 0;
+    top: auto;
+    left: 0;
+    right: 0;
+    width: 100%;
+    height: 64px;
+    flex-direction: row;
+    padding: var(--space-2);
+    border-right: none;
+    border-top: var(--border-subtle);
+  }
+
+  .sidebar-header {
+    display: none;
+  }
+
+  .sidebar-nav {
+    flex-direction: row;
+    justify-content: space-around;
+    gap: 0;
+    width: 100%;
+  }
+
+  .nav-section {
+    display: flex;
+    margin: 0;
+  }
+
+  .nav-section-title {
+    display: none;
+  }
+
+  .main-content {
+    margin-left: 0;
+    margin-bottom: 64px;
+    padding: var(--space-4);
+  }
+
+  .game-matchup {
+    grid-template-columns: 1fr;
+    gap: var(--space-4);
+  }
+
+  .team-block.away,
+  .team-block.home {
+    align-items: center;
+    text-align: center;
+  }
+
+  .team-block.home .team-info {
+    flex-direction: row;
+  }
+}
+
+/* =========================================================================
+   Scrollbar
+   ========================================================================= */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--bg-tertiary);
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--text-dim);
+}
+
+/* =========================================================================
+   Utility Classes
+   ========================================================================= */
+.flex {
+  display: flex;
+}
+
+.flex-col {
+  flex-direction: column;
+}
+
+.items-center {
+  align-items: center;
+}
+
+.justify-between {
+  justify-content: space-between;
+}
+
+.gap-2 {
+  gap: var(--space-2);
+}
+
+.gap-3 {
+  gap: var(--space-3);
+}
+
+.gap-4 {
+  gap: var(--space-4);
+}
+
+.mt-4 {
+  margin-top: var(--space-4);
+}
+
+.mb-4 {
+  margin-bottom: var(--space-4);
+}
+
+.text-right {
+  text-align: right;
+}
+
+.text-center {
+  text-align: center;
+}
+
+.font-mono {
+  font-family: var(--font-mono);
+}
+
+.truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}

web/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

web/src/pages/Accuracy.jsx

@@ -0,0 +1,297 @@
+import { useState, useEffect } from 'react'
+import { getAccuracy } from '../api'
+import { IconRefresh } from '../icons'
+
+function Accuracy() {
+    const [data, setData] = useState({ stats: {}, recent_predictions: [] })
+    const [loading, setLoading] = useState(true)
+
+    const fetchData = async () => {
+        setLoading(true)
+        try {
+            const result = await getAccuracy()
+            setData(result)
+        } catch (err) {
+            console.error('Failed to load accuracy:', err)
+        } finally {
+            setLoading(false)
+        }
+    }
+
+    useEffect(() => {
+        fetchData()
+        // Auto-refresh every 60 seconds
+        const interval = setInterval(fetchData, 60000)
+        return () => clearInterval(interval)
+    }, [])
+
+    if (loading) {
+        return (
+            <div className="loading">
+                <div className="spinner"></div>
+                <p className="loading-text">Loading accuracy stats...</p>
+            </div>
+        )
+    }
+
+    const { stats, recent_predictions } = data
+    const overallAccuracy = stats.overall_accuracy || 0
+    const byConfidence = stats.by_confidence || {}
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <div className="flex items-center justify-between">
+                    <div>
+                        <h1 className="page-title">Model Accuracy</h1>
+                        <p className="page-description">Track prediction performance and model reliability</p>
+                    </div>
+                    <button className="btn btn-secondary" onClick={fetchData}>
+                        <IconRefresh className="nav-icon" />
+                        Refresh
+                    </button>
+                </div>
+            </div>
+
+            {/* Primary Stats Grid */}
+            <div className="stats-grid" style={{ marginBottom: 'var(--space-6)' }}>
+                <div className="stat-card">
+                    <div className="stat-label">Total Predictions</div>
+                    <div className="stat-value">{stats.total_predictions || 0}</div>
+                </div>
+                <div className="stat-card">
+                    <div className="stat-label">Completed Games</div>
+                    <div className="stat-value">{stats.completed_games || 0}</div>
+                </div>
+                <div className="stat-card">
+                    <div className="stat-label">Correct Predictions</div>
+                    <div className="stat-value accent">{stats.correct_predictions || 0}</div>
+                </div>
+                <div className="stat-card">
+                    <div className="stat-label">Overall Accuracy</div>
+                    <div className="stat-value accent" style={{ fontSize: '2.5rem' }}>
+                        {(overallAccuracy * 100).toFixed(1)}%
+                    </div>
+                </div>
+            </div>
+
+            {/* Detailed Metrics */}
+            <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-6)', marginBottom: 'var(--space-8)' }}>
+                {/* Performance Metrics */}
+                <div className="card">
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Performance Metrics</h3>
+                    <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-4)' }}>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Current Streak</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700', color: stats.streak_type === 'W' ? 'var(--accent-success)' : 'var(--accent-danger)' }}>
+                                {stats.current_streak || 0}{stats.streak_type || ''}
+                            </div>
+                        </div>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Last 10 Games</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700' }}>
+                                {stats.last_10_record || '0-0'}
+                                <span style={{ fontSize: '0.875rem', color: 'var(--text-muted)', marginLeft: 'var(--space-2)' }}>
+                                    ({((stats.last_10_accuracy || 0) * 100).toFixed(0)}%)
+                                </span>
+                            </div>
+                        </div>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Pending Predictions</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-warning)' }}>
+                                {stats.pending_predictions || 0}
+                            </div>
+                        </div>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Avg Probability</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700' }}>
+                                {((stats.avg_probability_correct || 0) * 100).toFixed(1)}%
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                {/* Home vs Away */}
+                <div className="card">
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Home vs Away Picks</h3>
+                    <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-4)' }}>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Home Team Picks</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-primary)' }}>
+                                {((stats.home_pick_accuracy || 0) * 100).toFixed(1)}%
+                            </div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)' }}>
+                                {stats.home_picks_total || 0} picks
+                            </div>
+                        </div>
+                        <div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Away Team Picks</div>
+                            <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-secondary)' }}>
+                                {((stats.away_pick_accuracy || 0) * 100).toFixed(1)}%
+                            </div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)' }}>
+                                {stats.away_picks_total || 0} picks
+                            </div>
+                        </div>
+                    </div>
+
+                    {/* Visual bar */}
+                    <div style={{ marginTop: 'var(--space-4)' }}>
+                        <div style={{ display: 'flex', height: '8px', borderRadius: '4px', overflow: 'hidden' }}>
+                            <div style={{
+                                flex: stats.home_picks_total || 1,
+                                background: 'var(--accent-primary)',
+                                opacity: stats.home_pick_accuracy > stats.away_pick_accuracy ? 1 : 0.5
+                            }}></div>
+                            <div style={{
+                                flex: stats.away_picks_total || 1,
+                                background: 'var(--accent-secondary)',
+                                opacity: stats.away_pick_accuracy > stats.home_pick_accuracy ? 1 : 0.5
+                            }}></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            {/* Accuracy by Confidence */}
+            {Object.keys(byConfidence).length > 0 && (
+                <div style={{ marginBottom: 'var(--space-8)' }}>
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Accuracy by Confidence Level</h3>
+                    <div className="stats-grid" style={{ gridTemplateColumns: 'repeat(3, 1fr)' }}>
+                        {['high', 'medium', 'low'].map((conf) => {
+                            const confData = byConfidence[conf] || { accuracy: 0, correct: 0, total: 0 }
+                            const accuracyPercent = (confData.accuracy * 100).toFixed(1)
+                            return (
+                                <div key={conf} className="stat-card" style={{ textAlign: 'center' }}>
+                                    <span className={`badge confidence-${conf}`} style={{ marginBottom: 'var(--space-3)' }}>
+                                        {conf.toUpperCase()}
+                                    </span>
+                                    <div className="stat-value" style={{ fontSize: '2rem' }}>{accuracyPercent}%</div>
+                                    <div className="stat-label" style={{ marginTop: 'var(--space-2)' }}>
+                                        {confData.correct}/{confData.total} correct
+                                    </div>
+                                    {/* Progress ring visual */}
+                                    <div style={{
+                                        marginTop: 'var(--space-3)',
+                                        height: '4px',
+                                        background: 'var(--bg-tertiary)',
+                                        borderRadius: '2px',
+                                        overflow: 'hidden'
+                                    }}>
+                                        <div style={{
+                                            height: '100%',
+                                            width: `${accuracyPercent}%`,
+                                            background: conf === 'high' ? 'var(--accent-success)' : conf === 'medium' ? 'var(--accent-warning)' : 'var(--accent-danger)',
+                                            transition: 'width 0.3s ease'
+                                        }}></div>
+                                    </div>
+                                </div>
+                            )
+                        })}
+                    </div>
+                </div>
+            )}
+
+            {/* Accuracy by Team */}
+            {stats.by_team && Object.keys(stats.by_team).length > 0 && (
+                <div style={{ marginBottom: 'var(--space-8)' }}>
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Accuracy by Team Predicted</h3>
+                    <div className="table-container">
+                        <table className="data-table">
+                            <thead>
+                                <tr>
+                                    <th>Team</th>
+                                    <th style={{ textAlign: 'center' }}>Correct</th>
+                                    <th style={{ textAlign: 'center' }}>Total</th>
+                                    <th style={{ textAlign: 'right' }}>Accuracy</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {Object.entries(stats.by_team)
+                                    .sort((a, b) => b[1].accuracy - a[1].accuracy)
+                                    .map(([team, data]) => (
+                                        <tr key={team}>
+                                            <td style={{ fontWeight: '500' }}>{team}</td>
+                                            <td style={{ textAlign: 'center' }}>{data.correct}</td>
+                                            <td style={{ textAlign: 'center', color: 'var(--text-muted)' }}>{data.total}</td>
+                                            <td style={{ textAlign: 'right', color: 'var(--accent-primary)', fontWeight: '600', fontFamily: 'var(--font-mono)' }}>
+                                                {(data.accuracy * 100).toFixed(1)}%
+                                            </td>
+                                        </tr>
+                                    ))
+                                }
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            )}
+
+            {/* Recent Predictions */}
+            <div className="table-container">
+                <div style={{ padding: 'var(--space-4) var(--space-4) 0', borderBottom: 'var(--border-subtle)' }}>
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Recent Predictions</h3>
+                </div>
+
+                {recent_predictions.length === 0 ? (
+                    <div className="empty-state">
+                        <p className="empty-state-title">No Predictions Yet</p>
+                        <p className="empty-state-text">Visit the Live Games page to start tracking predictions.</p>
+                    </div>
+                ) : (
+                    <table className="data-table">
+                        <thead>
+                            <tr>
+                                <th>Date</th>
+                                <th>Matchup</th>
+                                <th>Prediction</th>
+                                <th style={{ textAlign: 'center' }}>Confidence</th>
+                                <th style={{ textAlign: 'center' }}>Result</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {recent_predictions.map((pred, idx) => {
+                                const isPending = pred.is_correct === -1
+                                const isCorrect = pred.is_correct === 1
+
+                                return (
+                                    <tr key={idx}>
+                                        <td style={{ color: 'var(--text-muted)', fontSize: '0.8125rem' }}>
+                                            {pred.game_date || 'N/A'}
+                                        </td>
+                                        <td>
+                                            <span style={{ fontWeight: '500' }}>{pred.away_team || 'N/A'}</span>
+                                            <span style={{ color: 'var(--text-muted)' }}> @ </span>
+                                            <span style={{ fontWeight: '500' }}>{pred.home_team || 'N/A'}</span>
+                                        </td>
+                                        <td style={{ color: 'var(--accent-primary)', fontWeight: '500' }}>
+                                            {pred.predicted_winner || 'N/A'}
+                                            <span style={{ color: 'var(--text-muted)', fontSize: '0.75rem', marginLeft: 'var(--space-2)' }}>
+                                                ({((pred.home_win_prob > 0.5 ? pred.home_win_prob : pred.away_win_prob) * 100 || 50).toFixed(0)}%)
+                                            </span>
+                                        </td>
+                                        <td style={{ textAlign: 'center' }}>
+                                            <span className={`badge confidence-${pred.confidence || 'medium'}`}>
+                                                {(pred.confidence || 'medium').toUpperCase()}
+                                            </span>
+                                        </td>
+                                        <td style={{ textAlign: 'center' }}>
+                                            {isPending ? (
+                                                <span className="badge badge-neutral">PENDING</span>
+                                            ) : isCorrect ? (
+                                                <span className="badge badge-success">CORRECT</span>
+                                            ) : (
+                                                <span className="badge badge-danger">WRONG</span>
+                                            )}
+                                        </td>
+                                    </tr>
+                                )
+                            })}
+                        </tbody>
+                    </table>
+                )}
+            </div>
+        </div>
+    )
+}
+
+export default Accuracy

web/src/pages/Championship.jsx

@@ -0,0 +1,120 @@
+import { useState, useEffect } from 'react'
+import { getChampionshipOdds } from '../api'
+import { TeamLogo } from '../teamLogos'
+
+function Championship() {
+    const [teams, setTeams] = useState([])
+    const [loading, setLoading] = useState(true)
+
+    useEffect(() => {
+        getChampionshipOdds()
+            .then(data => {
+                setTeams(data.teams || [])
+                setLoading(false)
+            })
+            .catch(err => {
+                console.error('Failed to load championship odds:', err)
+                setLoading(false)
+            })
+    }, [])
+
+    if (loading) {
+        return (
+            <div className="loading">
+                <div className="spinner"></div>
+                <p className="loading-text">Loading championship odds...</p>
+            </div>
+        )
+    }
+
+    const top4 = teams.slice(0, 4)
+    const rest = teams.slice(4)
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">Championship Odds</h1>
+                <p className="page-description">2025-26 NBA Championship probability rankings</p>
+            </div>
+
+            {/* Top 4 Contenders */}
+            {top4.length > 0 && (
+                <div className="stats-grid" style={{ gridTemplateColumns: 'repeat(4, 1fr)', marginBottom: 'var(--space-8)' }}>
+                    {top4.map((team, idx) => (
+                        <div
+                            key={team.team}
+                            className="stat-card animate-slideUp"
+                            style={{
+                                textAlign: 'center',
+                                animationDelay: `${idx * 0.1}s`,
+                                border: idx === 0 ? '1px solid var(--accent-primary)' : 'var(--border-subtle)'
+                            }}
+                        >
+                            <div style={{
+                                fontSize: '0.6875rem',
+                                fontWeight: '600',
+                                color: 'var(--text-muted)',
+                                marginBottom: 'var(--space-3)'
+                            }}>
+                                #{idx + 1} CONTENDER
+                            </div>
+                            <TeamLogo abbrev={team.team} size="lg" style={{ margin: '0 auto var(--space-3)' }} />
+                            <div style={{ fontSize: '1.125rem', fontWeight: '600', marginBottom: 'var(--space-2)' }}>
+                                {team.team}
+                            </div>
+                            <div className="stat-value accent" style={{ fontSize: '2.5rem' }}>
+                                {team.odds}%
+                            </div>
+                            <div className="stat-label">Championship Odds</div>
+                            <div style={{
+                                marginTop: 'var(--space-3)',
+                                fontSize: '0.75rem',
+                                color: 'var(--text-muted)',
+                                fontFamily: 'var(--font-mono)'
+                            }}>
+                                Win Rate: {team.win_pct}%
+                            </div>
+                        </div>
+                    ))}
+                </div>
+            )}
+
+            {/* Full Rankings */}
+            {rest.length > 0 && (
+                <div className="table-container">
+                    <table className="data-table">
+                        <thead>
+                            <tr>
+                                <th style={{ width: '60px' }}>Rank</th>
+                                <th>Team</th>
+                                <th style={{ textAlign: 'right' }}>Championship Odds</th>
+                                <th style={{ textAlign: 'right' }}>Win Rate</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {rest.map((team) => (
+                                <tr key={team.team}>
+                                    <td style={{ fontWeight: '600', color: 'var(--text-muted)' }}>#{team.rank}</td>
+                                    <td>
+                                        <div className="table-team">
+                                            <TeamLogo abbrev={team.team} size="sm" />
+                                            <span style={{ fontWeight: '500' }}>{team.team}</span>
+                                        </div>
+                                    </td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)', color: 'var(--accent-primary)', fontWeight: '600' }}>
+                                        {team.odds}%
+                                    </td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)', color: 'var(--text-muted)' }}>
+                                        {team.win_pct}%
+                                    </td>
+                                </tr>
+                            ))}
+                        </tbody>
+                    </table>
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default Championship

web/src/pages/HeadToHead.jsx

@@ -0,0 +1,196 @@
+import { useState, useEffect } from 'react'
+import { getTeams, predictGame } from '../api'
+import { TeamLogo, getTeamName } from '../teamLogos'
+
+function HeadToHead() {
+    const [teams, setTeams] = useState([])
+    const [team1, setTeam1] = useState('LAL')
+    const [team2, setTeam2] = useState('BOS')
+    const [comparison, setComparison] = useState(null)
+    const [loading, setLoading] = useState(false)
+
+    useEffect(() => {
+        getTeams().then(data => {
+            setTeams(data.teams || [])
+        }).catch(console.error)
+    }, [])
+
+    const handleCompare = async () => {
+        if (!team1 || !team2 || team1 === team2) return
+
+        setLoading(true)
+        try {
+            // Get predictions for both scenarios
+            const [homeGame, awayGame] = await Promise.all([
+                predictGame(team1, team2), // Team1 at home
+                predictGame(team2, team1), // Team2 at home
+            ])
+
+            setComparison({
+                team1,
+                team2,
+                homeGame,  // Team1 hosting Team2
+                awayGame,  // Team2 hosting Team1
+            })
+        } catch (err) {
+            console.error('Comparison failed:', err)
+        } finally {
+            setLoading(false)
+        }
+    }
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">Head to Head</h1>
+                <p className="page-description">Compare two teams across different scenarios</p>
+            </div>
+
+            {/* Team Selector */}
+            <div className="card" style={{ marginBottom: 'var(--space-6)' }}>
+                <div style={{ display: 'grid', gridTemplateColumns: '1fr auto 1fr', gap: 'var(--space-6)', alignItems: 'end' }}>
+                    {/* Team 1 */}
+                    <div className="form-group" style={{ marginBottom: 0 }}>
+                        <label className="form-label">Team 1</label>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: 'var(--space-3)' }}>
+                            <TeamLogo abbrev={team1} size="md" />
+                            <select
+                                className="form-select"
+                                value={team1}
+                                onChange={(e) => setTeam1(e.target.value)}
+                            >
+                                {teams.map(team => (
+                                    <option key={team.id} value={team.abbrev}>{team.abbrev} - {getTeamName(team.abbrev)}</option>
+                                ))}
+                            </select>
+                        </div>
+                    </div>
+
+                    <div style={{ color: 'var(--text-dim)', fontWeight: '600', paddingBottom: 'var(--space-3)' }}>VS</div>
+
+                    {/* Team 2 */}
+                    <div className="form-group" style={{ marginBottom: 0 }}>
+                        <label className="form-label">Team 2</label>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: 'var(--space-3)' }}>
+                            <TeamLogo abbrev={team2} size="md" />
+                            <select
+                                className="form-select"
+                                value={team2}
+                                onChange={(e) => setTeam2(e.target.value)}
+                            >
+                                {teams.map(team => (
+                                    <option key={team.id} value={team.abbrev}>{team.abbrev} - {getTeamName(team.abbrev)}</option>
+                                ))}
+                            </select>
+                        </div>
+                    </div>
+                </div>
+
+                <button
+                    className="btn btn-primary btn-lg btn-block"
+                    onClick={handleCompare}
+                    disabled={loading || team1 === team2}
+                    style={{ marginTop: 'var(--space-6)' }}
+                >
+                    {loading ? 'Analyzing...' : 'Compare Teams'}
+                </button>
+            </div>
+
+            {/* Comparison Results */}
+            {comparison && (
+                <div className="animate-slideUp">
+                    {/* ELO Comparison */}
+                    <div className="stats-grid" style={{ marginBottom: 'var(--space-6)' }}>
+                        <div className="stat-card" style={{ textAlign: 'center' }}>
+                            <TeamLogo abbrev={comparison.team1} size="lg" style={{ margin: '0 auto var(--space-3)' }} />
+                            <div style={{ fontSize: '1.125rem', fontWeight: '600', marginBottom: 'var(--space-2)' }}>
+                                {comparison.team1}
+                            </div>
+                            <div className="stat-value accent">
+                                {comparison.homeGame?.home_elo?.toFixed(0) || 'N/A'}
+                            </div>
+                            <div className="stat-label">ELO Rating</div>
+                        </div>
+
+                        <div className="stat-card" style={{ textAlign: 'center', display: 'flex', flexDirection: 'column', justifyContent: 'center' }}>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', marginBottom: 'var(--space-2)' }}>ELO DIFFERENCE</div>
+                            <div style={{ fontSize: '2rem', fontWeight: '700', color: comparison.homeGame?.elo_diff > 0 ? 'var(--accent-success)' : 'var(--accent-danger)' }}>
+                                {comparison.homeGame?.elo_diff > 0 ? '+' : ''}{comparison.homeGame?.elo_diff?.toFixed(0) || 0}
+                            </div>
+                            <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)', marginTop: 'var(--space-2)' }}>
+                                {comparison.homeGame?.elo_diff > 0 ? `${comparison.team1} favored` : `${comparison.team2} favored`}
+                            </div>
+                        </div>
+
+                        <div className="stat-card" style={{ textAlign: 'center' }}>
+                            <TeamLogo abbrev={comparison.team2} size="lg" style={{ margin: '0 auto var(--space-3)' }} />
+                            <div style={{ fontSize: '1.125rem', fontWeight: '600', marginBottom: 'var(--space-2)' }}>
+                                {comparison.team2}
+                            </div>
+                            <div className="stat-value accent">
+                                {comparison.homeGame?.away_elo?.toFixed(0) || 'N/A'}
+                            </div>
+                            <div className="stat-label">ELO Rating</div>
+                        </div>
+                    </div>
+
+                    {/* Scenario Cards */}
+                    <h3 style={{ marginBottom: 'var(--space-4)' }}>Win Probabilities by Venue</h3>
+                    <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-4)' }}>
+                        {/* Scenario 1: Team1 at Home */}
+                        <div className="card">
+                            <div className="card-header">
+                                <span className="card-title">{comparison.team1} Home Game</span>
+                            </div>
+                            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 'var(--space-4)' }}>
+                                <div style={{ textAlign: 'center' }}>
+                                    <TeamLogo abbrev={comparison.team1} size="md" />
+                                    <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-primary)', marginTop: 'var(--space-2)' }}>
+                                        {(comparison.homeGame?.home_win_probability * 100).toFixed(1)}%
+                                    </div>
+                                </div>
+                                <div style={{ color: 'var(--text-dim)' }}>vs</div>
+                                <div style={{ textAlign: 'center' }}>
+                                    <TeamLogo abbrev={comparison.team2} size="md" />
+                                    <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-secondary)', marginTop: 'var(--space-2)' }}>
+                                        {(comparison.homeGame?.away_win_probability * 100).toFixed(1)}%
+                                    </div>
+                                </div>
+                            </div>
+                            <div style={{ fontSize: '0.875rem', color: 'var(--text-muted)', textAlign: 'center' }}>
+                                Prediction: <span style={{ color: 'var(--accent-primary)', fontWeight: '600' }}>{comparison.homeGame?.predicted_winner}</span>
+                            </div>
+                        </div>
+
+                        {/* Scenario 2: Team2 at Home */}
+                        <div className="card">
+                            <div className="card-header">
+                                <span className="card-title">{comparison.team2} Home Game</span>
+                            </div>
+                            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 'var(--space-4)' }}>
+                                <div style={{ textAlign: 'center' }}>
+                                    <TeamLogo abbrev={comparison.team2} size="md" />
+                                    <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-primary)', marginTop: 'var(--space-2)' }}>
+                                        {(comparison.awayGame?.home_win_probability * 100).toFixed(1)}%
+                                    </div>
+                                </div>
+                                <div style={{ color: 'var(--text-dim)' }}>vs</div>
+                                <div style={{ textAlign: 'center' }}>
+                                    <TeamLogo abbrev={comparison.team1} size="md" />
+                                    <div style={{ fontSize: '1.5rem', fontWeight: '700', color: 'var(--accent-secondary)', marginTop: 'var(--space-2)' }}>
+                                        {(comparison.awayGame?.away_win_probability * 100).toFixed(1)}%
+                                    </div>
+                                </div>
+                            </div>
+                            <div style={{ fontSize: '0.875rem', color: 'var(--text-muted)', textAlign: 'center' }}>
+                                Prediction: <span style={{ color: 'var(--accent-primary)', fontWeight: '600' }}>{comparison.awayGame?.predicted_winner}</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default HeadToHead

web/src/pages/LiveGames.jsx

@@ -0,0 +1,320 @@
+import { useState, useEffect } from 'react'
+import { getLiveGames } from '../api'
+import { TeamLogo } from '../teamLogos'
+import { IconRefresh } from '../icons'
+
+// Fetch roster for a team - use relative URL in production
+const API_BASE = import.meta.env.DEV ? 'http://localhost:8000' : '';
+async function getTeamRoster(teamAbbrev) {
+    const response = await fetch(`${API_BASE}/api/roster/${teamAbbrev}`)
+    return response.json()
+}
+
+function LiveGames() {
+    const [data, setData] = useState({ live: [], final: [], upcoming: [] })
+    const [loading, setLoading] = useState(true)
+    const [error, setError] = useState(null)
+    const [lastRefresh, setLastRefresh] = useState(new Date())
+
+    const fetchGames = async () => {
+        try {
+            const result = await getLiveGames()
+            setData(result)
+            setLastRefresh(new Date())
+            setError(null)
+        } catch (err) {
+            setError('Failed to connect to API. Make sure the server is running.')
+        } finally {
+            setLoading(false)
+        }
+    }
+
+    useEffect(() => {
+        fetchGames()
+        const interval = setInterval(fetchGames, 15000)
+        return () => clearInterval(interval)
+    }, [])
+
+    if (loading) {
+        return (
+            <div className="loading">
+                <div className="spinner"></div>
+                <p className="loading-text">Loading games...</p>
+            </div>
+        )
+    }
+
+    if (error) {
+        return (
+            <div className="empty-state">
+                <p className="empty-state-title">Connection Error</p>
+                <p className="empty-state-text">{error}</p>
+                <button className="btn btn-primary" onClick={fetchGames} style={{ marginTop: 'var(--space-4)' }}>
+                    Retry
+                </button>
+            </div>
+        )
+    }
+
+    const hasGames = data.live?.length > 0 || data.final?.length > 0 || data.upcoming?.length > 0
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <div className="flex items-center justify-between">
+                    <div>
+                        <h1 className="page-title">Live Games</h1>
+                        <p className="page-description">
+                            Last updated: {lastRefresh.toLocaleTimeString()} • Auto-refreshes every 15s
+                        </p>
+                    </div>
+                    <button className="btn btn-secondary" onClick={fetchGames}>
+                        <IconRefresh className="nav-icon" />
+                        Refresh
+                    </button>
+                </div>
+            </div>
+
+            {!hasGames ? (
+                <div className="empty-state">
+                    <p className="empty-state-title">No Games Today</p>
+                    <p className="empty-state-text">Check back later for scheduled NBA games.</p>
+                </div>
+            ) : (
+                <>
+                    {/* Live Games */}
+                    {data.live?.length > 0 && (
+                        <section className="section">
+                            <div className="section-header">
+                                <span className="section-title flex items-center gap-2">
+                                    <span className="live-dot"></span>
+                                    In Progress
+                                </span>
+                            </div>
+                            <div className="stagger">
+                                {data.live.map((game) => (
+                                    <GameCard key={game.game_id} game={game} isLive={true} />
+                                ))}
+                            </div>
+                        </section>
+                    )}
+
+                    {/* Final Games */}
+                    {data.final?.length > 0 && (
+                        <section className="section">
+                            <div className="section-header">
+                                <span className="section-title">Completed</span>
+                            </div>
+                            <div className="stagger">
+                                {data.final.map((game) => (
+                                    <GameCard key={game.game_id} game={game} isFinal={true} />
+                                ))}
+                            </div>
+                        </section>
+                    )}
+
+                    {/* Upcoming Games */}
+                    {data.upcoming?.length > 0 && (
+                        <section className="section">
+                            <div className="section-header">
+                                <span className="section-title">Upcoming Today</span>
+                            </div>
+                            <div className="stagger">
+                                {data.upcoming.map((game) => (
+                                    <GameCard key={game.game_id} game={game} showLineups={true} />
+                                ))}
+                            </div>
+                        </section>
+                    )}
+                </>
+            )}
+        </div>
+    )
+}
+
+function GameCard({ game, isLive, isFinal, showLineups }) {
+    const prediction = game.prediction || {}
+    const homeProb = (prediction.home_win_probability || 0.5) * 100
+    const awayProb = (prediction.away_win_probability || 0.5) * 100
+
+    const [showRosters, setShowRosters] = useState(false)
+    const [homeRoster, setHomeRoster] = useState([])
+    const [awayRoster, setAwayRoster] = useState([])
+    const [loadingRosters, setLoadingRosters] = useState(false)
+
+    const fetchRosters = async () => {
+        if (homeRoster.length > 0 && awayRoster.length > 0) {
+            setShowRosters(!showRosters)
+            return
+        }
+
+        setLoadingRosters(true)
+        try {
+            const [homeData, awayData] = await Promise.all([
+                getTeamRoster(game.home_team),
+                getTeamRoster(game.away_team)
+            ])
+            setHomeRoster(homeData.starters || [])
+            setAwayRoster(awayData.starters || [])
+            setShowRosters(true)
+        } catch (err) {
+            console.error('Failed to fetch rosters:', err)
+        } finally {
+            setLoadingRosters(false)
+        }
+    }
+
+    return (
+        <div className={`game-card animate-slideUp ${isLive ? 'live' : ''}`}>
+            {/* Header */}
+            <div className="game-header">
+                <div className="game-status" style={{ color: isLive ? 'var(--accent-danger)' : isFinal ? 'var(--text-muted)' : 'var(--text-secondary)' }}>
+                    {isLive && (
+                        <span className="flex items-center gap-2">
+                            <span className="live-dot"></span>
+                            {game.period && `Q${game.period}`} {game.clock || 'LIVE'}
+                        </span>
+                    )}
+                    {isFinal && 'FINAL'}
+                    {!isLive && !isFinal && (game.status_text || 'Scheduled')}
+                </div>
+                <span className="game-time">{game.game_date}</span>
+            </div>
+
+            {/* Matchup */}
+            <div className="game-matchup">
+                {/* Away Team */}
+                <div className="team-block away">
+                    <div className="team-info">
+                        <TeamLogo abbrev={game.away_team} size="lg" />
+                        <div className="team-details">
+                            <span className="team-name">{game.away_team}</span>
+                            <span className="team-record">{game.away_record || '0-0'}</span>
+                        </div>
+                    </div>
+                    {(isLive || isFinal) ? (
+                        <div className="team-score">{game.away_score}</div>
+                    ) : (
+                        <div className="team-probability">{awayProb.toFixed(0)}%</div>
+                    )}
+                </div>
+
+                {/* Center */}
+                <div className="game-center">
+                    {!isFinal && prediction.predicted_winner && (
+                        <div className="prediction-indicator">
+                            <div className="prediction-label">Prediction</div>
+                            <div className="prediction-pick">{prediction.predicted_winner}</div>
+                            <span className={`badge confidence-${prediction.confidence || 'medium'}`} style={{ marginTop: 'var(--space-2)' }}>
+                                {(prediction.confidence || 'medium').toUpperCase()}
+                            </span>
+                        </div>
+                    )}
+                    {isFinal && (
+                        <div className="prediction-indicator">
+                            <div className="prediction-label">Predicted</div>
+                            <div className="prediction-pick">{prediction.predicted_winner || 'N/A'}</div>
+                            <span className={`badge ${game.prediction_correct ? 'badge-success' : 'badge-danger'}`} style={{ marginTop: 'var(--space-2)' }}>
+                                {game.prediction_correct ? 'CORRECT' : 'WRONG'}
+                            </span>
+                        </div>
+                    )}
+                </div>
+
+                {/* Home Team */}
+                <div className="team-block home">
+                    <div className="team-info">
+                        <TeamLogo abbrev={game.home_team} size="lg" />
+                        <div className="team-details">
+                            <span className="team-name">{game.home_team}</span>
+                            <span className="team-record">{game.home_record || '0-0'}</span>
+                        </div>
+                    </div>
+                    {(isLive || isFinal) ? (
+                        <div className="team-score">{game.home_score}</div>
+                    ) : (
+                        <div className="team-probability">{homeProb.toFixed(0)}%</div>
+                    )}
+                </div>
+            </div>
+
+            {/* Probability Bar */}
+            {!isFinal && (
+                <div className="probability-bar-container">
+                    <div className="probability-bar">
+                        <div className="probability-fill-away" style={{ width: `${awayProb}%` }}></div>
+                        <div className="probability-fill-home" style={{ width: `${homeProb}%` }}></div>
+                    </div>
+                    <div className="probability-labels">
+                        <span>{game.away_team}: {awayProb.toFixed(1)}%</span>
+                        <span>{game.home_team}: {homeProb.toFixed(1)}%</span>
+                    </div>
+                </div>
+            )}
+
+            {/* Starting Lineups Toggle */}
+            {!isFinal && (
+                <div style={{ marginTop: 'var(--space-4)', borderTop: 'var(--border-subtle)', paddingTop: 'var(--space-4)' }}>
+                    <button
+                        className="btn btn-ghost btn-block"
+                        onClick={fetchRosters}
+                        disabled={loadingRosters}
+                    >
+                        {loadingRosters ? 'Loading...' : showRosters ? 'Hide Starting Lineups' : 'Show Projected Starting 5'}
+                    </button>
+
+                    {/* Rosters Display */}
+                    {showRosters && (
+                        <div style={{ marginTop: 'var(--space-4)', display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-6)' }}>
+                            {/* Away Team Roster */}
+                            <div>
+                                <div style={{ fontSize: '0.75rem', fontWeight: '600', textTransform: 'uppercase', letterSpacing: '0.05em', color: 'var(--text-muted)', marginBottom: 'var(--space-3)' }}>
+                                    {game.away_team} Starters
+                                </div>
+                                <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-2)' }}>
+                                    {awayRoster.length > 0 ? awayRoster.map((player, idx) => (
+                                        <div key={idx} style={{
+                                            display: 'flex',
+                                            justifyContent: 'space-between',
+                                            padding: 'var(--space-2) var(--space-3)',
+                                            background: 'var(--bg-elevated)',
+                                            borderRadius: 'var(--radius-sm)',
+                                            fontSize: '0.8125rem'
+                                        }}>
+                                            <span style={{ fontWeight: '500' }}>{idx + 1}. {player.name}</span>
+                                            <span style={{ color: 'var(--accent-primary)', fontFamily: 'var(--font-mono)' }}>{player.pts || 0} PPG</span>
+                                        </div>
+                                    )) : <span style={{ color: 'var(--text-muted)', fontSize: '0.8125rem' }}>Lineup unavailable</span>}
+                                </div>
+                            </div>
+
+                            {/* Home Team Roster */}
+                            <div>
+                                <div style={{ fontSize: '0.75rem', fontWeight: '600', textTransform: 'uppercase', letterSpacing: '0.05em', color: 'var(--text-muted)', marginBottom: 'var(--space-3)' }}>
+                                    {game.home_team} Starters
+                                </div>
+                                <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-2)' }}>
+                                    {homeRoster.length > 0 ? homeRoster.map((player, idx) => (
+                                        <div key={idx} style={{
+                                            display: 'flex',
+                                            justifyContent: 'space-between',
+                                            padding: 'var(--space-2) var(--space-3)',
+                                            background: 'var(--bg-elevated)',
+                                            borderRadius: 'var(--radius-sm)',
+                                            fontSize: '0.8125rem'
+                                        }}>
+                                            <span style={{ fontWeight: '500' }}>{idx + 1}. {player.name}</span>
+                                            <span style={{ color: 'var(--accent-primary)', fontFamily: 'var(--font-mono)' }}>{player.pts || 0} PPG</span>
+                                        </div>
+                                    )) : <span style={{ color: 'var(--text-muted)', fontSize: '0.8125rem' }}>Lineup unavailable</span>}
+                                </div>
+                            </div>
+                        </div>
+                    )}
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default LiveGames

web/src/pages/MvpRace.jsx

@@ -0,0 +1,144 @@
+import { useState, useEffect } from 'react'
+import { getMvpRace } from '../api'
+import { TeamLogo } from '../teamLogos'
+
+function MvpRace() {
+    const [candidates, setCandidates] = useState([])
+    const [loading, setLoading] = useState(true)
+
+    useEffect(() => {
+        getMvpRace()
+            .then(data => {
+                setCandidates(data.candidates || [])
+                setLoading(false)
+            })
+            .catch(err => {
+                console.error('Failed to load MVP race:', err)
+                setLoading(false)
+            })
+    }, [])
+
+    if (loading) {
+        return (
+            <div className="loading">
+                <div className="spinner"></div>
+                <p className="loading-text">Loading MVP race...</p>
+            </div>
+        )
+    }
+
+    const top3 = candidates.slice(0, 3)
+    const rest = candidates.slice(3)
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">MVP Race</h1>
+                <p className="page-description">2025-26 MVP candidates ranked by performance metrics</p>
+            </div>
+
+            {/* Top 3 Podium */}
+            {top3.length > 0 && (
+                <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: 'var(--space-4)', marginBottom: 'var(--space-8)' }}>
+                    {top3.map((player, idx) => {
+                        const rankStyles = [
+                            { border: '1px solid #FFD700', boxShadow: '0 0 20px rgba(255, 215, 0, 0.1)' },
+                            { border: '1px solid #C0C0C0' },
+                            { border: '1px solid #CD7F32' },
+                        ]
+                        const rankLabels = ['1ST', '2ND', '3RD']
+
+                        return (
+                            <div
+                                key={player.name}
+                                className="card animate-slideUp"
+                                style={{
+                                    ...rankStyles[idx],
+                                    textAlign: 'center',
+                                    animationDelay: `${idx * 0.1}s`
+                                }}
+                            >
+                                <div style={{
+                                    fontSize: '0.6875rem',
+                                    fontWeight: '700',
+                                    letterSpacing: '0.1em',
+                                    color: idx === 0 ? '#FFD700' : idx === 1 ? '#C0C0C0' : '#CD7F32',
+                                    marginBottom: 'var(--space-4)'
+                                }}>
+                                    {rankLabels[idx]}
+                                </div>
+
+                                <div style={{
+                                    width: '64px',
+                                    height: '64px',
+                                    borderRadius: '50%',
+                                    background: 'var(--bg-elevated)',
+                                    margin: '0 auto var(--space-3)',
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    justifyContent: 'center',
+                                    fontSize: '1.5rem',
+                                    fontWeight: '700',
+                                    color: 'var(--accent-primary)'
+                                }}>
+                                    {player.name.split(' ').map(n => n[0]).join('')}
+                                </div>
+
+                                <h3 style={{ marginBottom: 'var(--space-2)' }}>{player.name}</h3>
+                                <p style={{ color: 'var(--text-muted)', fontSize: '0.875rem', marginBottom: 'var(--space-4)' }}>
+                                    {player.ppg} PPG / {player.rpg} RPG / {player.apg} APG
+                                </p>
+
+                                <div style={{
+                                    fontSize: '2rem',
+                                    fontWeight: '700',
+                                    color: 'var(--accent-primary)',
+                                    marginBottom: 'var(--space-1)'
+                                }}>
+                                    {player.mvp_score}
+                                </div>
+                                <div style={{ fontSize: '0.6875rem', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>
+                                    MVP Score
+                                </div>
+                            </div>
+                        )
+                    })}
+                </div>
+            )}
+
+            {/* Full Rankings */}
+            {rest.length > 0 && (
+                <div className="table-container">
+                    <table className="data-table">
+                        <thead>
+                            <tr>
+                                <th style={{ width: '60px' }}>Rank</th>
+                                <th>Player</th>
+                                <th style={{ textAlign: 'right' }}>PPG</th>
+                                <th style={{ textAlign: 'right' }}>RPG</th>
+                                <th style={{ textAlign: 'right' }}>APG</th>
+                                <th style={{ textAlign: 'right' }}>MVP Score</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {rest.map((player) => (
+                                <tr key={player.name}>
+                                    <td style={{ fontWeight: '600', color: 'var(--text-muted)' }}>#{player.rank}</td>
+                                    <td style={{ fontWeight: '500' }}>{player.name}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)' }}>{player.ppg}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)' }}>{player.rpg}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)' }}>{player.apg}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)', color: 'var(--accent-primary)', fontWeight: '600' }}>
+                                        {player.mvp_score}
+                                    </td>
+                                </tr>
+                            ))}
+                        </tbody>
+                    </table>
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default MvpRace

web/src/pages/PlayerStats.jsx

@@ -0,0 +1,142 @@
+import { useState } from 'react'
+import { IconSearch } from '../icons'
+
+// Simulated player data - in production this would come from API
+const MOCK_PLAYERS = [
+    { id: 1, name: 'LeBron James', team: 'LAL', ppg: 25.4, rpg: 7.2, apg: 8.1, fg_pct: 54.2, position: 'SF' },
+    { id: 2, name: 'Stephen Curry', team: 'GSW', ppg: 26.8, rpg: 4.5, apg: 5.2, fg_pct: 45.1, position: 'PG' },
+    { id: 3, name: 'Giannis Antetokounmpo', team: 'MIL', ppg: 31.2, rpg: 11.5, apg: 5.8, fg_pct: 61.2, position: 'PF' },
+    { id: 4, name: 'Nikola Jokic', team: 'DEN', ppg: 26.5, rpg: 12.2, apg: 9.1, fg_pct: 58.3, position: 'C' },
+    { id: 5, name: 'Jayson Tatum', team: 'BOS', ppg: 27.0, rpg: 8.1, apg: 4.6, fg_pct: 47.1, position: 'SF' },
+    { id: 6, name: 'Luka Doncic', team: 'DAL', ppg: 33.2, rpg: 9.1, apg: 9.5, fg_pct: 48.7, position: 'PG' },
+    { id: 7, name: 'Kevin Durant', team: 'PHX', ppg: 27.5, rpg: 6.5, apg: 5.2, fg_pct: 52.4, position: 'SF' },
+    { id: 8, name: 'Joel Embiid', team: 'PHI', ppg: 34.1, rpg: 11.0, apg: 5.7, fg_pct: 54.8, position: 'C' },
+    { id: 9, name: 'Shai Gilgeous-Alexander', team: 'OKC', ppg: 31.5, rpg: 5.5, apg: 6.2, fg_pct: 53.5, position: 'SG' },
+    { id: 10, name: 'Anthony Edwards', team: 'MIN', ppg: 26.0, rpg: 5.8, apg: 5.0, fg_pct: 46.2, position: 'SG' },
+];
+
+function PlayerStats() {
+    const [searchQuery, setSearchQuery] = useState('')
+    const [selectedPlayer, setSelectedPlayer] = useState(null)
+
+    const filteredPlayers = MOCK_PLAYERS.filter(player =>
+        player.name.toLowerCase().includes(searchQuery.toLowerCase()) ||
+        player.team.toLowerCase().includes(searchQuery.toLowerCase())
+    )
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">Player Stats</h1>
+                <p className="page-description">Search and compare NBA player statistics</p>
+            </div>
+
+            {/* Search */}
+            <div className="card" style={{ marginBottom: 'var(--space-6)' }}>
+                <div style={{ position: 'relative' }}>
+                    <IconSearch className="nav-icon" style={{
+                        position: 'absolute',
+                        left: 'var(--space-4)',
+                        top: '50%',
+                        transform: 'translateY(-50%)',
+                        color: 'var(--text-muted)'
+                    }} />
+                    <input
+                        type="text"
+                        className="form-input"
+                        placeholder="Search players or teams..."
+                        value={searchQuery}
+                        onChange={(e) => setSearchQuery(e.target.value)}
+                        style={{ paddingLeft: 'var(--space-10)' }}
+                    />
+                </div>
+            </div>
+
+            <div style={{ display: 'grid', gridTemplateColumns: selectedPlayer ? '1fr 1fr' : '1fr', gap: 'var(--space-6)' }}>
+                {/* Player List */}
+                <div className="table-container">
+                    <table className="data-table">
+                        <thead>
+                            <tr>
+                                <th>Player</th>
+                                <th>Team</th>
+                                <th>Pos</th>
+                                <th style={{ textAlign: 'right' }}>PPG</th>
+                                <th style={{ textAlign: 'right' }}>RPG</th>
+                                <th style={{ textAlign: 'right' }}>APG</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {filteredPlayers.map((player) => (
+                                <tr
+                                    key={player.id}
+                                    onClick={() => setSelectedPlayer(player)}
+                                    style={{ cursor: 'pointer', background: selectedPlayer?.id === player.id ? 'var(--bg-elevated)' : undefined }}
+                                >
+                                    <td style={{ fontWeight: '500' }}>{player.name}</td>
+                                    <td style={{ color: 'var(--text-muted)' }}>{player.team}</td>
+                                    <td style={{ color: 'var(--text-muted)' }}>{player.position}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)', color: 'var(--accent-primary)' }}>{player.ppg}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)' }}>{player.rpg}</td>
+                                    <td style={{ textAlign: 'right', fontFamily: 'var(--font-mono)' }}>{player.apg}</td>
+                                </tr>
+                            ))}
+                        </tbody>
+                    </table>
+                </div>
+
+                {/* Player Detail Card */}
+                {selectedPlayer && (
+                    <div className="card animate-slideUp">
+                        <div style={{ textAlign: 'center', marginBottom: 'var(--space-6)' }}>
+                            <div style={{
+                                width: '80px',
+                                height: '80px',
+                                borderRadius: '50%',
+                                background: 'var(--bg-elevated)',
+                                margin: '0 auto var(--space-4)',
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                fontSize: '2rem',
+                                fontWeight: '700',
+                                color: 'var(--accent-primary)'
+                            }}>
+                                {selectedPlayer.name.split(' ').map(n => n[0]).join('')}
+                            </div>
+                            <h2 style={{ marginBottom: 'var(--space-2)' }}>{selectedPlayer.name}</h2>
+                            <p style={{ color: 'var(--text-muted)' }}>
+                                {selectedPlayer.team} • {selectedPlayer.position}
+                            </p>
+                        </div>
+
+                        <div className="stats-grid" style={{ gridTemplateColumns: '1fr 1fr' }}>
+                            <div className="stat-card">
+                                <div className="stat-value accent">{selectedPlayer.ppg}</div>
+                                <div className="stat-label">Points Per Game</div>
+                            </div>
+                            <div className="stat-card">
+                                <div className="stat-value">{selectedPlayer.rpg}</div>
+                                <div className="stat-label">Rebounds Per Game</div>
+                            </div>
+                            <div className="stat-card">
+                                <div className="stat-value">{selectedPlayer.apg}</div>
+                                <div className="stat-label">Assists Per Game</div>
+                            </div>
+                            <div className="stat-card">
+                                <div className="stat-value">{selectedPlayer.fg_pct}%</div>
+                                <div className="stat-label">Field Goal %</div>
+                            </div>
+                        </div>
+
+                        <div style={{ marginTop: 'var(--space-4)', fontSize: '0.75rem', color: 'var(--text-muted)', textAlign: 'center' }}>
+                            Note: Player stats are currently mock data. Connect to NBA API for live stats.
+                        </div>
+                    </div>
+                )}
+            </div>
+        </div>
+    )
+}
+
+export default PlayerStats

web/src/pages/Predictions.jsx

@@ -0,0 +1,176 @@
+import { useState, useEffect } from 'react'
+import { predictGame, getTeams } from '../api'
+import { TeamLogo, getTeamName } from '../teamLogos'
+
+function Predictions() {
+    const [teams, setTeams] = useState([])
+    const [homeTeam, setHomeTeam] = useState('LAL')
+    const [awayTeam, setAwayTeam] = useState('BOS')
+    const [prediction, setPrediction] = useState(null)
+    const [loading, setLoading] = useState(false)
+
+    useEffect(() => {
+        getTeams().then(data => {
+            setTeams(data.teams || [])
+        }).catch(console.error)
+    }, [])
+
+    const handlePredict = async () => {
+        if (!homeTeam || !awayTeam || homeTeam === awayTeam) return
+
+        setLoading(true)
+        try {
+            const result = await predictGame(homeTeam, awayTeam)
+            setPrediction(result)
+        } catch (err) {
+            console.error('Prediction failed:', err)
+        } finally {
+            setLoading(false)
+        }
+    }
+
+    const homeProb = prediction ? (prediction.home_win_probability * 100) : 50
+    const awayProb = prediction ? (prediction.away_win_probability * 100) : 50
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">Game Predictions</h1>
+                <p className="page-description">Select teams to get AI-powered win probabilities</p>
+            </div>
+
+            {/* Team Selector */}
+            <div className="card" style={{ marginBottom: 'var(--space-6)' }}>
+                <div style={{ display: 'grid', gridTemplateColumns: '1fr auto 1fr', gap: 'var(--space-6)', alignItems: 'end' }}>
+                    {/* Away Team */}
+                    <div className="form-group" style={{ marginBottom: 0 }}>
+                        <label className="form-label">Away Team</label>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: 'var(--space-3)' }}>
+                            <TeamLogo abbrev={awayTeam} size="md" />
+                            <select
+                                className="form-select"
+                                value={awayTeam}
+                                onChange={(e) => setAwayTeam(e.target.value)}
+                            >
+                                {teams.map(team => (
+                                    <option key={team.id} value={team.abbrev}>{team.abbrev} - {getTeamName(team.abbrev)}</option>
+                                ))}
+                            </select>
+                        </div>
+                    </div>
+
+                    <div style={{ color: 'var(--text-dim)', fontWeight: '600', paddingBottom: 'var(--space-3)' }}>@</div>
+
+                    {/* Home Team */}
+                    <div className="form-group" style={{ marginBottom: 0 }}>
+                        <label className="form-label">Home Team</label>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: 'var(--space-3)' }}>
+                            <TeamLogo abbrev={homeTeam} size="md" />
+                            <select
+                                className="form-select"
+                                value={homeTeam}
+                                onChange={(e) => setHomeTeam(e.target.value)}
+                            >
+                                {teams.map(team => (
+                                    <option key={team.id} value={team.abbrev}>{team.abbrev} - {getTeamName(team.abbrev)}</option>
+                                ))}
+                            </select>
+                        </div>
+                    </div>
+                </div>
+
+                <button
+                    className="btn btn-primary btn-lg btn-block"
+                    onClick={handlePredict}
+                    disabled={loading || homeTeam === awayTeam}
+                    style={{ marginTop: 'var(--space-6)' }}
+                >
+                    {loading ? 'Analyzing...' : 'Generate Prediction'}
+                </button>
+            </div>
+
+            {/* Prediction Result */}
+            {prediction && (
+                <div className="card animate-slideUp">
+                    <div style={{ display: 'grid', gridTemplateColumns: '1fr auto 1fr', gap: 'var(--space-8)', alignItems: 'center' }}>
+                        {/* Away Team */}
+                        <div style={{ textAlign: 'center' }}>
+                            <TeamLogo abbrev={prediction.away_team} size="xl" />
+                            <div style={{ marginTop: 'var(--space-3)' }}>
+                                <div style={{ fontSize: '1.25rem', fontWeight: '600' }}>{prediction.away_team}</div>
+                                <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)' }}>
+                                    ELO: {prediction.away_elo?.toFixed(0) || 'N/A'}
+                                </div>
+                            </div>
+                            <div style={{ fontSize: '2.5rem', fontWeight: '700', color: 'var(--accent-secondary)', marginTop: 'var(--space-4)' }}>
+                                {awayProb.toFixed(1)}%
+                            </div>
+                        </div>
+
+                        {/* Prediction Center */}
+                        <div style={{ textAlign: 'center' }}>
+                            <div style={{ fontSize: '0.6875rem', fontWeight: '600', textTransform: 'uppercase', letterSpacing: '0.1em', color: 'var(--text-muted)', marginBottom: 'var(--space-2)' }}>
+                                Predicted Winner
+                            </div>
+                            <div style={{ fontSize: '1.75rem', fontWeight: '700', color: 'var(--accent-primary)' }}>
+                                {prediction.predicted_winner}
+                            </div>
+                            <span className={`badge confidence-${prediction.confidence}`} style={{ marginTop: 'var(--space-3)' }}>
+                                {prediction.confidence?.toUpperCase()} CONFIDENCE
+                            </span>
+                            <div style={{ marginTop: 'var(--space-4)', fontSize: '0.75rem', color: 'var(--text-muted)' }}>
+                                ELO Difference: {prediction.elo_diff > 0 ? '+' : ''}{prediction.elo_diff?.toFixed(0)}
+                            </div>
+                        </div>
+
+                        {/* Home Team */}
+                        <div style={{ textAlign: 'center' }}>
+                            <TeamLogo abbrev={prediction.home_team} size="xl" />
+                            <div style={{ marginTop: 'var(--space-3)' }}>
+                                <div style={{ fontSize: '1.25rem', fontWeight: '600' }}>{prediction.home_team}</div>
+                                <div style={{ fontSize: '0.75rem', color: 'var(--text-muted)' }}>
+                                    ELO: {prediction.home_elo?.toFixed(0) || 'N/A'}
+                                </div>
+                            </div>
+                            <div style={{ fontSize: '2.5rem', fontWeight: '700', color: 'var(--accent-primary)', marginTop: 'var(--space-4)' }}>
+                                {homeProb.toFixed(1)}%
+                            </div>
+                        </div>
+                    </div>
+
+                    {/* Probability Bar */}
+                    <div className="probability-bar-container" style={{ marginTop: 'var(--space-8)' }}>
+                        <div className="probability-bar" style={{ height: '8px' }}>
+                            <div className="probability-fill-away" style={{ width: `${awayProb}%` }}></div>
+                            <div className="probability-fill-home" style={{ width: `${homeProb}%` }}></div>
+                        </div>
+                        <div className="probability-labels" style={{ marginTop: 'var(--space-3)' }}>
+                            <span>{prediction.away_team}: {awayProb.toFixed(1)}%</span>
+                            <span>{prediction.home_team}: {homeProb.toFixed(1)}%</span>
+                        </div>
+                    </div>
+
+                    {/* Factors */}
+                    {prediction.factors && prediction.factors.length > 0 && (
+                        <div style={{ marginTop: 'var(--space-6)', paddingTop: 'var(--space-6)', borderTop: 'var(--border-subtle)' }}>
+                            <h4 style={{ marginBottom: 'var(--space-4)', color: 'var(--text-secondary)' }}>Key Factors</h4>
+                            <ul style={{ listStyle: 'none' }}>
+                                {prediction.factors.map((factor, idx) => (
+                                    <li key={idx} style={{
+                                        padding: 'var(--space-2) 0',
+                                        color: 'var(--text-muted)',
+                                        fontSize: '0.875rem'
+                                    }}>
+                                        • {factor}
+                                    </li>
+                                ))}
+                            </ul>
+                        </div>
+                    )}
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default Predictions

web/src/pages/Standings.jsx

@@ -0,0 +1,115 @@
+import { useState, useEffect } from 'react'
+import { TeamLogo, getTeamName } from '../teamLogos'
+
+// API call for standings
+async function getStandings() {
+    const response = await fetch('http://localhost:8000/api/standings')
+    return response.json()
+}
+
+function Standings() {
+    const [standings, setStandings] = useState({ east: [], west: [] })
+    const [loading, setLoading] = useState(true)
+    const [activeConference, setActiveConference] = useState('east')
+
+    useEffect(() => {
+        getStandings()
+            .then(data => {
+                setStandings(data)
+                setLoading(false)
+            })
+            .catch(err => {
+                console.error('Failed to load standings:', err)
+                setLoading(false)
+            })
+    }, [])
+
+    if (loading) {
+        return (
+            <div className="loading">
+                <div className="spinner"></div>
+                <p className="loading-text">Loading standings...</p>
+            </div>
+        )
+    }
+
+    const currentStandings = activeConference === 'east' ? standings.east : standings.west
+
+    return (
+        <div className="animate-fadeIn">
+            <div className="page-header">
+                <h1 className="page-title">Season Standings</h1>
+                <p className="page-description">2025-26 NBA Conference standings</p>
+            </div>
+
+            {/* Conference Tabs */}
+            <div style={{ display: 'flex', gap: 'var(--space-2)', marginBottom: 'var(--space-6)' }}>
+                <button
+                    className={`btn ${activeConference === 'east' ? 'btn-primary' : 'btn-secondary'}`}
+                    onClick={() => setActiveConference('east')}
+                >
+                    Eastern Conference
+                </button>
+                <button
+                    className={`btn ${activeConference === 'west' ? 'btn-primary' : 'btn-secondary'}`}
+                    onClick={() => setActiveConference('west')}
+                >
+                    Western Conference
+                </button>
+            </div>
+
+            {/* Standings Table */}
+            <div className="table-container">
+                <table className="data-table">
+                    <thead>
+                        <tr>
+                            <th style={{ width: '50px' }}>Rank</th>
+                            <th>Team</th>
+                            <th style={{ textAlign: 'center' }}>W</th>
+                            <th style={{ textAlign: 'center' }}>L</th>
+                            <th style={{ textAlign: 'center' }}>PCT</th>
+                            <th style={{ textAlign: 'center' }}>GB</th>
+                            <th style={{ textAlign: 'center' }}>Streak</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {currentStandings?.length > 0 ? currentStandings.map((team, idx) => (
+                            <tr key={team.team || idx}>
+                                <td style={{ fontWeight: '600', color: idx < 6 ? 'var(--accent-success)' : idx < 10 ? 'var(--text-secondary)' : 'var(--text-muted)' }}>
+                                    {idx + 1}
+                                </td>
+                                <td>
+                                    <div className="table-team">
+                                        <TeamLogo abbrev={team.team_abbrev || team.team} size="sm" />
+                                        <span style={{ fontWeight: '500' }}>{team.team_name || getTeamName(team.team_abbrev || team.team)}</span>
+                                    </div>
+                                </td>
+                                <td style={{ textAlign: 'center', fontFamily: 'var(--font-mono)' }}>{team.wins || 0}</td>
+                                <td style={{ textAlign: 'center', fontFamily: 'var(--font-mono)' }}>{team.losses || 0}</td>
+                                <td style={{ textAlign: 'center', fontFamily: 'var(--font-mono)', color: 'var(--accent-primary)' }}>
+                                    {((team.win_pct || 0) * 100).toFixed(1)}%
+                                </td>
+                                <td style={{ textAlign: 'center', fontFamily: 'var(--font-mono)', color: 'var(--text-muted)' }}>
+                                    {team.gb || '-'}
+                                </td>
+                                <td style={{ textAlign: 'center' }}>
+                                    <span className={`badge ${team.streak?.includes('W') ? 'badge-success' : 'badge-danger'}`}>
+                                        {team.streak || '-'}
+                                    </span>
+                                </td>
+                            </tr>
+                        )) : (
+                            <tr>
+                                <td colSpan="7" style={{ textAlign: 'center', padding: 'var(--space-8)', color: 'var(--text-muted)' }}>
+                                    No standings data available. API endpoint may need to be added.
+                                </td>
+                            </tr>
+                        )}
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    )
+}
+
+export default Standings