Spaces:
Running on Zero
Running on Zero
| """ | |
| cli.py — Command-Line Interface for the Scoreboard Agent Framework. | |
| Usage: | |
| python dev/agent/scoreboard/cli.py --latest | |
| python dev/agent/scoreboard/cli.py --date 2026-10-13 | |
| python dev/agent/scoreboard/cli.py --game-id 2026020090 | |
| """ | |
| import argparse | |
| import logging | |
| import os | |
| import sys | |
| from pathlib import Path | |
| # Add current directory and repo root to Python path | |
| current_dir = Path(__file__).parent | |
| if str(current_dir) not in sys.path: | |
| sys.path.insert(0, str(current_dir)) | |
| repo_root = current_dir.parent.parent.parent | |
| if str(repo_root) not in sys.path: | |
| sys.path.insert(0, str(repo_root)) | |
| try: | |
| from dev.agent.scoreboard.agent import ScoreboardAgent | |
| except (ImportError, ValueError): | |
| from agent import ScoreboardAgent | |
| def main(): | |
| parser = argparse.ArgumentParser( | |
| description="NHL Scoreboard Agent — Automated game recaps, player standouts, and slate analytics." | |
| ) | |
| parser.add_argument("--date", type=str, default=None, help="Slate date to analyze (YYYY-MM-DD).") | |
| parser.add_argument("--latest", action="store_true", help="Automatically analyze the most recent completed slate.") | |
| parser.add_argument("--game-id", type=int, default=None, help="Analyze a specific single game ID (e.g., 2026020090).") | |
| parser.add_argument("--output-dir", type=str, default=None, help="Directory to save generated markdown recaps.") | |
| parser.add_argument("--no-save", action="store_true", help="Do not write markdown reports to disk.") | |
| parser.add_argument("--print-recap", action="store_true", help="Print the generated narrative directly to stdout.") | |
| parser.add_argument("--llm-prompt", action="store_true", help="Generate and print an LLM synthesis prompt.") | |
| parser.add_argument("--record-hf", action="store_true", help="Record and sync recaps directly to Hugging Face dataset (jjerlee/nhl-analytics).") | |
| parser.add_argument("--mode", type=str, choices=["auto", "lm-studio", "local-llm", "llm", "router-llm", "algorithmic"], default="auto", help="Narrative generator mode: 'lm-studio' (Local LM Studio at http://127.0.0.1:1234), 'router-llm' (Meta-Llama-3.2-3B via router), 'algorithmic' (deterministic guardrails), or 'auto' (LM Studio with fallback).") | |
| parser.add_argument("--lm-studio-url", type=str, default="http://127.0.0.1:1234/v1", help="Base URL for local LM Studio API (default: http://127.0.0.1:1234/v1).") | |
| parser.add_argument("--lm-model", type=str, default=None, help="Explicit model ID in LM Studio (default: auto-detect from /v1/models).") | |
| parser.add_argument("--all-games-llm", action="store_true", help="Generate full LLM narratives for every individual game on the slate (default: generates executive slate review with LLM and individual game recaps with Algorithmic Engine for fast batch performance).") | |
| parser.add_argument("--model-id", type=str, default="meta-llama/Llama-3.2-3B-Instruct", help="Hugging Face model ID for router LLM generation.") | |
| parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose debug logging.") | |
| args = parser.parse_args() | |
| # Configure logging | |
| log_level = logging.DEBUG if args.verbose else logging.INFO | |
| logging.basicConfig( | |
| level=log_level, | |
| format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", | |
| datefmt="%H:%M:%S", | |
| ) | |
| agent = ScoreboardAgent( | |
| output_dir=args.output_dir, | |
| model_mode=args.mode, | |
| lm_studio_url=args.lm_studio_url, | |
| lm_model_id=args.lm_model, | |
| llm_model_id=args.model_id, | |
| ) | |
| # 1. Single Game Analysis | |
| if args.game_id: | |
| print(f"\n🏒 Running Scoreboard Agent for Game ID: {args.game_id}...") | |
| game = agent.analyze_game(args.game_id, save_report=not args.no_save) | |
| print(f"\n✅ Analysis Complete: {game.headline}") | |
| print(f"Final Score: {game.away_team.team_abbrev} {game.away_team.score} @ {game.home_team.team_abbrev} {game.home_team.score} ({game.period_type})") | |
| print("\nThree Stars:") | |
| for s in game.three_stars: | |
| print(f" ⭐ {s.star}. {s.name} ({s.team_abbrev} - {s.position}): {s.stat_summary}") | |
| if game.notables: | |
| print("\nKey Notables:") | |
| for n in game.notables: | |
| print(f" 🔥 [{n.category.upper()}] {n.title} -> {n.description}") | |
| if args.print_recap: | |
| print("\n" + "=" * 70) | |
| print(agent.narrator.generate_single_game_markdown(game)) | |
| print("=" * 70) | |
| return | |
| # 2. Slate-wide Analysis | |
| target_date = args.date | |
| if args.latest or not target_date: | |
| target_date = agent.get_latest_date() | |
| print(f"\n🏒 Running Scoreboard Agent for Slate Date: {target_date}...") | |
| game_mode = "algorithmic" if args.mode == "algorithmic" else None | |
| slate = agent.analyze_slate(target_date, save_report=not args.no_save, game_narrative_mode=game_mode) | |
| print(f"\n✅ Slate Analysis Complete for {slate.date}:") | |
| print(f" • Total Games: {slate.total_games} | Total Goals: {slate.total_goals} (Avg {slate.avg_goals_per_game:.1f})") | |
| print(f" • Home Wins: {slate.home_wins} | Away Wins: {slate.away_wins} | OT/SO Games: {slate.ot_so_games}") | |
| if slate.slate_three_stars: | |
| print("\n🏆 League-Wide Three Stars of the Night:") | |
| for s in slate.slate_three_stars: | |
| print(f" ⭐ {s.star}. {s.name} ({s.team_abbrev} - {s.position}): {s.stat_summary}") | |
| if slate.slate_notables: | |
| print(f"\n🔥 Top Milestones & Highlights ({len(slate.slate_notables)} detected):") | |
| for n in slate.slate_notables[:5]: | |
| print(f" • {n.title} ({n.entity}): {n.description}") | |
| print(f"\n📁 Reports directory: {agent.output_dir}") | |
| if args.record_hf: | |
| print("\n☁️ Recording and syncing recaps directly to Hugging Face dataset (jjerlee/nhl-analytics)...") | |
| try: | |
| from dev.agent.scoreboard.dataset_store import HFScoreboardStore | |
| except ImportError: | |
| from dataset_store import HFScoreboardStore | |
| store = HFScoreboardStore() | |
| store._load_tables(refresh_remote=True) | |
| slate_model = getattr(slate, "generator_model", "algorithmic-guardrails-v1") | |
| game_model = ( | |
| getattr(slate.games[0], "generator_model", "algorithmic-guardrails-v1") | |
| if slate.games | |
| else slate_model | |
| ) | |
| store.record_slate(slate, generator_model=slate_model) | |
| store.record_games(slate.games, generator_model=game_model) | |
| print("✅ Finished recording to Hugging Face dataset store!") | |
| # If running in a headless CI environment that only produced Tier-1 algorithmic recaps, | |
| # wake/restart the Hugging Face Space so its ZeroGPU worker upgrades the date to Tier-2 LLM recaps. | |
| if not store.is_slate_llm_generated(target_date): | |
| try: | |
| import requests | |
| from huggingface_hub import HfApi | |
| if store.token: | |
| HfApi(token=store.token).restart_space("jjerlee/rinklytics") | |
| print("⚡ Triggered Hugging Face Space (jjerlee/rinklytics) ZeroGPU worker to upgrade recaps to LLM.") | |
| else: | |
| requests.get("https://jjerlee-rinklytics.hf.space", timeout=10) | |
| except Exception as e: | |
| print(f"ℹ️ Note waking Hugging Face Space: {e}") | |
| if args.llm_prompt: | |
| print("\n" + "-" * 70) | |
| print("🤖 Generated LLM Synthesis Prompt:") | |
| print(agent.generate_llm_synthesis_prompt(slate)) | |
| print("-" * 70) | |
| if args.print_recap: | |
| print("\n" + "=" * 70) | |
| print(agent.narrator.generate_slate_markdown(slate)) | |
| print("=" * 70) | |
| if __name__ == "__main__": | |
| main() | |