2521833afb
21 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Cal Corum
|
2521833afb |
CLAUDE: Add configurable regulation_innings and outs_per_inning
Issue #8 from code review - hardcoded inning limit (9) and outs (3) prevented custom game modes like 7-inning doubleheaders. Changes: - Added regulation_innings: int = 9 to GameState (default standard) - Added outs_per_inning: int = 3 to GameState (default standard) - Updated validators.py: is_game_over(), can_continue_inning(), shallow outfield - Updated game_models.py: is_game_over() uses state.regulation_innings - Updated game_engine.py: _finalize_play() uses state.outs_per_inning Now supports custom game modes: - 7-inning doubleheaders - 6-inning youth/minor league games - Alternative out rules (2-out innings, etc.) All 739 unit tests passing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
b95c5837b0 |
CLAUDE: Extract common resolution logic to _finalize_play method
Issue #5 from code review - resolve_play and resolve_manual_play shared ~70% of their code causing maintenance burden and divergent behavior risk. Changes: - Extracted common finalization logic to new _finalize_play() method - resolve_play reduced from ~150 lines to ~60 lines - resolve_manual_play reduced from ~135 lines to ~60 lines - Single source of truth for: roll tracking, state capture, transaction handling, inning advance, cleanup, and state updates Benefits: - Changes to play finalization only need to be made in one place - Reduced risk of divergent behavior between resolution modes - Better testability and maintainability All 739 unit tests passing (1 flaky probabilistic test occasionally fails). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
72a3b94ce7 |
CLAUDE: Add transaction handling for multi-step DB operations
Issue #4 from code review - multi-step database operations were not wrapped in transactions, risking partial state on failure. Changes: - Modified save_play() and update_game_state() in DatabaseOperations to accept optional session parameter for transaction grouping - Wrapped resolve_play() DB operations in single atomic transaction - Wrapped resolve_manual_play() DB operations in single atomic transaction - Transaction commits atomically or rolls back entirely on failure Pattern: When session provided, use flush() for IDs without committing; caller controls transaction. When no session, create internal transaction. All 739 unit tests passing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
cbdd8cf903 |
CLAUDE: Fix critical game engine issues and refactor CLAUDE.md docs
Critical fixes in game_engine.py: - Fix silent error swallowing in _batch_save_inning_rolls (re-raise) - Add per-game asyncio.Lock for race condition prevention - Add _cleanup_game_resources() for memory leak prevention - All 739 tests passing Documentation refactoring: - Created CODE_REVIEW_GAME_ENGINE.md documenting 24 identified issues - Trimmed backend/app/core/CLAUDE.md from 1371 to 143 lines - Trimmed frontend-sba/CLAUDE.md from 696 to 110 lines - Created focused subdirectory CLAUDE.md files: - frontend-sba/components/CLAUDE.md (105 lines) - frontend-sba/composables/CLAUDE.md (79 lines) - frontend-sba/store/CLAUDE.md (116 lines) - frontend-sba/types/CLAUDE.md (95 lines) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
b15f80310b |
CLAUDE: Add LineupService and SBA API client for player data integration
Created centralized services for SBA player data fetching at lineup creation: Backend - New Services: - app/services/sba_api_client.py: REST client for SBA API (api.sba.manticorum.com) with batch player fetching and caching support - app/services/lineup_service.py: High-level service combining DB operations with API calls for complete lineup entries with player data Backend - Refactored Components: - app/core/game_engine.py: Replaced raw API calls with LineupService, reduced _prepare_next_play() from ~50 lines to ~15 lines - app/core/substitution_manager.py: Updated pinch_hit(), defensive_replace(), change_pitcher() to use lineup_service.get_sba_player_data() - app/models/game_models.py: Added player_name/player_image to LineupPlayerState - app/services/__init__.py: Exported new LineupService components - app/websocket/handlers.py: Enhanced lineup state handling Frontend - SBA League: - components/Game/CurrentSituation.vue: Restored player images with fallback badges (P/B letters) for both mobile and desktop layouts - components/Game/GameBoard.vue: Enhanced game board visualization - composables/useGameActions.ts: Updated game action handling - composables/useWebSocket.ts: Improved WebSocket state management - pages/games/[id].vue: Enhanced game page with better state handling - types/game.ts: Updated type definitions - types/websocket.ts: Added WebSocket type support Architecture Improvement: All SBA player data fetching now goes through LineupService: - Lineup creation: add_sba_player_to_lineup() - Lineup loading: load_team_lineup_with_player_data() - Substitutions: get_sba_player_data() All 739 unit tests pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
4cadb6566c |
CLAUDE: Clean up stale TODO comments from Phase 3E completion
Removed outdated TODO comments and updated documentation to reflect work completed in Phase 3E (Position Ratings and WebSocket Handlers). Changes: - Removed 2 stale WebSocket emission TODOs in game_engine.py (lines 319, 387) These referenced Phase 3E-Final work completed on 2025-01-10 - Updated backend/CLAUDE.md Phase 3E status section Marked defender retrieval as COMPLETE (Phase 3E-Main) Clarified SPD test still pending (needs batter speed rating) Marked runner advancement as COMPLETE (Phase 3D) - Updated TODO_RESOLUTION_SUMMARY.md Marked defender lookup TODO as resolved with implementation details Documentation: - Created TODO_AUDIT_2025-01-14.md - Complete TODO audit (53 items) - Created TODO_VERIFICATION_RESULTS.md - Verification of resolved items - Created TODO_SUMMARY.md - Quick reference priority matrix - Created TODO_CLEANUP_COMPLETE.md - Cleanup work summary Test Status: - Backend: 9/9 PlayResolver tests passing - No regressions introduced Remaining Work: - 41 legitimate TODOs properly categorized for future phases - 8 Phase F6 TODOs (game page integration) - 5 Quick win TODOs (optional polish) - 28 Future phase TODOs (auth, AI, advanced features) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
beb939b32a |
CLAUDE: Fix all unit test failures and implement 100% test requirement
Test Fixes (609/609 passing): - Fixed DiceSystem API to accept team_id/player_id parameters for audit trails - Fixed dice roll history timing issue in test - Fixed terminal client mock to match resolve_play signature (X-Check params) - Fixed result chart test mocks with missing pitching fields - Fixed flaky test by using groundball_a (exists in both batting/pitching) Documentation Updates: - Added Testing Policy section to backend/CLAUDE.md - Added Testing Policy section to tests/CLAUDE.md - Documented 100% unit test requirement before commits - Added git hook setup instructions Git Hook System: - Created .git-hooks/pre-commit script (enforces 100% test pass) - Created .git-hooks/install-hooks.sh (easy installation) - Created .git-hooks/README.md (hook documentation) - Hook automatically runs all unit tests before each commit - Blocks commits if any test fails All 609 unit tests now passing (100%) Integration tests have known asyncpg connection issues (documented) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
bb78de2b84 |
CLAUDE: Add X-Check testing to resolve_with command
Added ability to test X-Check defensive plays directly in the terminal client using the resolve_with command. This allows testing the complete X-Check resolution system (defense tables, error charts, runner advancement) with actual player ratings. Changes: - repl.py: Updated do_resolve_with() to parse "x-check <position>" syntax - Accepts "x-check", "xcheck", or "x_check" followed by position - Validates position (P, C, 1B, 2B, 3B, SS, LF, CF, RF) - Passes xcheck_position parameter through to commands - commands.py: Updated resolve_play() to accept xcheck_position parameter - Passes xcheck_position to game_engine.resolve_play() - Shows "🎯 Forcing X-Check to: <position>" message - game_engine.py: Updated resolve_play() to accept xcheck_position parameter - For X_CHECK outcomes, uses xcheck_position as hit_location - Enables full X-Check resolution with defense tables and error charts - help_text.py: Updated resolve_with help documentation - Added x-check usage syntax and examples - Documented position parameter requirement - Added note about using actual player ratings Usage: ⚾ > defensive ⚾ > offensive ⚾ > resolve_with x-check SS # Test X-Check to shortstop ⚾ > resolve_with x-check LF # Test X-Check to left field This integrates the existing play_resolver._resolve_x_check() logic, providing a way to test the complete X-Check system including defense range adjustments, table lookups, SPD tests, G2#/G3# conversion, error charts, and runner advancement. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
02e816a57f |
CLAUDE: Phase 3E-Main - Position Ratings Integration for X-Check Resolution
Complete integration of position ratings system enabling X-Check defensive plays to use actual player ratings from PD API with intelligent fallbacks for SBA. **Live API Testing Verified**: ✅ - Endpoint: GET https://pd.manticorum.com/api/v2/cardpositions?player_id=8807 - Response: 200 OK, 7 positions retrieved successfully - Cache performance: 16,601x faster (API: 0.214s, Cache: 0.000s) - Data quality: Real defensive ratings (range 1-5, error 0-88) **Architecture Overview**: - League-aware: PD league fetches ratings from API, SBA uses defaults - StateManager integration: Defenders retrieved from lineup cache - Self-contained GameState: All data needed for X-Check in memory - Graceful degradation: Falls back to league averages if ratings unavailable **Files Created**: 1. app/services/pd_api_client.py (NEW) - PdApiClient class for PD API integration - Endpoint: GET /api/v2/cardpositions?player_id={id}&position={pos} - Async HTTP client using httpx (already in requirements.txt) - Optional position filtering: get_position_ratings(8807, ['SS', '2B']) - Returns List[PositionRating] for all positions player can play - Handles both list and dict response formats - Comprehensive error handling with logging 2. app/services/position_rating_service.py (NEW) - PositionRatingService with in-memory caching - get_ratings_for_card(card_id, league_id) - All positions - get_rating_for_position(card_id, position, league_id) - Specific position - Cache performance: >16,000x faster on hits - Singleton pattern: position_rating_service instance - TODO Phase 3E-Final: Upgrade to Redis 3. app/services/__init__.py (NEW) - Package exports for clean imports 4. test_pd_api_live.py (NEW) - Live API integration test script - Tests with real PD player 8807 (7 positions) - Verifies caching, filtering, GameState integration - Run: `python test_pd_api_live.py` 5. test_pd_api_mock.py (NEW) - Mock integration test for CI/CD - Demonstrates flow without API dependency 6. tests/integration/test_position_ratings_api.py (NEW) - Pytest integration test suite - Real API tests with player 8807 - Cache verification, SBA skip logic - Full end-to-end GameState flow **Files Modified**: 1. app/models/game_models.py - LineupPlayerState: Added position_rating field (Optional[PositionRating]) - GameState: Added get_defender_for_position(position, state_manager) - Uses StateManager's lineup cache to find active defender by position - Iterates through lineup.players to match position + is_active 2. app/config/league_configs.py - SbaConfig: Added supports_position_ratings() → False - PdConfig: Added supports_position_ratings() → True - Enables league-specific behavior without hardcoded conditionals 3. app/core/play_resolver.py - __init__: Added state_manager parameter for X-Check defender lookup - _resolve_x_check(): Replaced placeholder defender ratings with actual lookup - Uses league config to check if ratings supported - Fetches defender via state.get_defender_for_position() - Falls back to defaults (range=3, error=15) if ratings unavailable - Detailed logging for debugging rating lookups 4. app/core/game_engine.py - Added _load_position_ratings_for_lineup() method - Loads all position ratings at game start for PD league - Skips loading for SBA (league config check) - start_game(): Calls rating loader for both teams before marking active - PlayResolver instantiation: Now passes state_manager parameter - Logs: "Loaded X/9 position ratings for team Y" **X-Check Resolution Flow**: 1. League check: config.supports_position_ratings()? 2. Get defender: state.get_defender_for_position(pos, state_manager) 3. If PD + defender.position_rating exists: Use actual range/error 4. Else if defender found: Use defaults (range=3, error=15) 5. Else: Log warning, use defaults **Position Rating Loading (Game Start)**: 1. Check if league supports ratings (PD only) 2. Get lineup from StateManager cache 3. For each player: - Fetch rating from position_rating_service (with caching) - Set player.position_rating field 4. Cache API responses (16,000x faster on subsequent access) 5. Log success: "Loaded X/9 position ratings for team Y" **Live Test Results (Player 8807)**: ``` Position Range Error Innings CF 3 2 372 2B 3 8 212 SS 4 12 159 RF 2 2 74 LF 3 2 62 1B 4 0 46 3B 3 65 34 ``` **Testing**: - ✅ Live API: Player 8807 → 7 positions retrieved successfully - ✅ Caching: 16,601x performance improvement - ✅ League config: SBA=False, PD=True - ✅ GameState integration: Defender lookup working - ✅ Existing tests: 27/28 config tests passing (1 pre-existing URL failure) - ✅ Syntax validation: All files compile successfully **Benefits**: - ✅ X-Check now uses real defensive ratings in PD league - ✅ SBA league continues working with manual entry (uses defaults) - ✅ No breaking changes to existing functionality - ✅ Graceful degradation if API unavailable - ✅ In-memory caching reduces API calls by >99% - ✅ League-agnostic design via config system - ✅ Production-ready with live API verification **Phase 3E Status**: Main complete (85% → 90%) **Next**: Phase 3E-Final (WebSocket events, Redis upgrade, full defensive lineup) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
d560844704 |
CLAUDE: Phase 3E-Prep - Refactor GameState to use full LineupPlayerState objects
**Architectural Improvement**: Unified player references in GameState **Changed**: Make all player references consistent - BEFORE: current_batter/pitcher/catcher were IDs (int) - AFTER: current_batter/pitcher/catcher are full LineupPlayerState objects - Matches pattern of on_first/on_second/on_third (already objects) **Benefits**: 1. Consistent API - all player references use same type 2. Self-contained GameState - everything needed for resolution 3. No lookups needed - direct access to player data 4. Sets foundation for Phase 3E-Main (adding position ratings) **Files Modified**: - app/models/game_models.py: Changed current_batter/pitcher/catcher to objects - app/core/game_engine.py: Updated _prepare_next_play() to populate full objects - app/core/state_manager.py: Create placeholder batter on game creation - tests/unit/models/test_game_models.py: Updated all 27 GameState tests **Database Operations**: - No schema changes needed - Play table still stores IDs (for referential integrity) - IDs extracted from objects when saving: state.current_batter.lineup_id **Testing**: - All 27 GameState tests passing - No regressions in existing functionality - Type checking passes **Next**: Phase 3E-Main - Add PositionRating dataclass and load ratings at game start 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
e2f1d6079f |
CLAUDE: Implement Week 7 Task 6 - PlayResolver Integration with RunnerAdvancement
Major Refactor: Outcome-First Architecture - PlayResolver now accepts league_id and auto_mode in constructor - Added core resolve_outcome() method - all resolution logic in one place - Added resolve_manual_play() wrapper for manual submissions (primary) - Added resolve_auto_play() wrapper for PD auto mode (rare) - Removed SimplifiedResultChart (obsolete with new architecture) - Removed play_resolver singleton RunnerAdvancement Integration: - All groundball outcomes (GROUNDBALL_A/B/C) now use RunnerAdvancement - Proper DP probability calculation with positioning modifiers - Hit location tracked for all relevant outcomes - 13 result types fully integrated from advancement charts Game State Updates: - Added auto_mode field to GameState (stored per-game) - Updated state_manager.create_game() to accept auto_mode parameter - GameEngine now uses state.auto_mode to create appropriate resolver League Configuration: - Added supports_auto_mode() to BaseGameConfig - SbaConfig: returns False (no digitized cards) - PdConfig: returns True (has digitized ratings) - PlayResolver validates auto mode support and raises error for SBA Play Results: - Added hit_location field to PlayResult - Groundballs include location from RunnerAdvancement - Flyouts track hit_location for tag-up logic (future) - Other outcomes have hit_location=None Testing: - Completely rewrote test_play_resolver.py for new architecture - 9 new tests covering initialization, strikeouts, walks, groundballs, home runs - All 9 tests passing - All 180 core tests still passing (1 pre-existing failure unrelated) Terminal Client: - No changes needed - defaults to manual mode (auto_mode=False) - Perfect for human testing of manual submissions This completes Week 7 Task 6 - the final task of Week 7! Week 7 is now 100% complete with all 8 tasks done. 🎯 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
9cae63ac43 |
CLAUDE: Implement Week 7 Task 7 - WebSocket manual outcome handlers
Complete manual outcome workflow for SBA and PD manual mode gameplay: **WebSocket Event Handlers** (app/websocket/handlers.py): - roll_dice: Server rolls dice, stores in state, broadcasts to players - submit_manual_outcome: Validates and processes player submissions - Events: dice_rolled, outcome_accepted, outcome_rejected, play_resolved **Game Engine Integration** (app/core/game_engine.py): - resolve_manual_play(): Processes manual outcomes with server dice - Uses ab_roll for audit trail, player outcome for resolution - Same orchestration as resolve_play() (save, update, advance inning) **Data Model** (app/models/game_models.py): - pending_manual_roll: Stores server dice between roll and submission **Terminal Client** (terminal_client/): - roll_dice command: Roll dice and display results - manual_outcome command: Submit outcomes from physical cards - Both integrated into REPL for testing **Tests** (tests/unit/websocket/test_manual_outcome_handlers.py): - 12 comprehensive tests covering all validation paths - All tests passing (roll_dice: 4, submit_manual_outcome: 8) **Key Decisions**: - Server rolls dice for fairness (not players!) - One-time roll usage (cleared after submission) - Early validation (check pending roll before accepting) - Field-level error messages for clear feedback **Impact**: - Complete manual mode workflow ready - Frontend WebSocket integration supported - Terminal testing commands available - Audit trail with server-rolled dice maintained 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
9b03fb555b |
CLAUDE: Implement play rollback functionality for error recovery
Add ability to roll back the last N plays, useful for correcting mistakes or recovering from corrupted plays. Deletes plays from database and reconstructs game state by replaying remaining plays. Database Operations (app/database/operations.py): - delete_plays_after(): Delete plays with play_number > target - delete_substitutions_after(): Delete lineup entries with after_play >= target - delete_rolls_after(): Delete dice rolls (kept for reference, not used) Game Engine (app/core/game_engine.py): - rollback_plays(): Main rollback orchestration - Validates: num_plays > 0, enough plays exist, game not completed - Deletes plays and substitutions from database - Clears in-memory roll tracking - Calls state_manager.recover_game() to rebuild state - Returns updated GameState Terminal Client (terminal_client/commands.py, terminal_client/repl.py): - rollback_plays(): Command wrapper with user-friendly output - do_rollback(): REPL command with argument parsing Usage: ⚾ > rollback 3 Validations: - Cannot roll back more plays than exist - Cannot roll back completed games - Rolling back across innings is allowed - Substitutions after rolled-back plays are undone Testing: - ✅ Successfully rolls back 2 plays from 5-play game - ✅ Correctly validates rollback of 10 plays when only 2 exist - ✅ Game state properly reconstructed via replay Note: Dice rolls kept in database for auditing (don't affect state). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
8ecce0f5ad |
CLAUDE: Implement forced outcome feature for terminal client testing
Add ability to force specific play outcomes instead of random dice rolls, enabling targeted testing of specific game scenarios. Changes: - play_resolver.resolve_play(): Add forced_outcome parameter, bypass dice rolls when provided, create dummy AbRoll with placeholder values - game_engine.resolve_play(): Accept and pass through forced_outcome param - terminal_client/commands.py: Pass forced_outcome to game engine Testing: - Verified TRIPLE, HOMERUN, and STRIKEOUT outcomes work correctly - Dummy AbRoll properly constructed with all required fields - Game state updates correctly with forced outcomes Example usage in REPL: resolve_with triple resolve_with homerun Fixes terminal client testing workflow to allow controlled scenarios. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
95d8703f56 |
CLAUDE: Implement Week 7 Task 1 - Strategic Decision Integration
Enhanced game engine with async decision workflow and AI opponent integration: GameState Model Enhancements: - Added pending_defensive_decision and pending_offensive_decision fields - Added decision_phase tracking (idle, awaiting_defensive, awaiting_offensive, resolving, completed) - Added decision_deadline field for timeout handling - Added is_batting_team_ai() and is_fielding_team_ai() helper methods - Added validator for decision_phase StateManager Enhancements: - Added _pending_decisions dict for asyncio.Future-based decision queue - Added set_pending_decision() to create decision futures - Added await_decision() to wait for decision submission - Added submit_decision() to resolve pending futures - Added cancel_pending_decision() for cleanup GameEngine Enhancements: - Added await_defensive_decision() with AI/human branching and timeout - Added await_offensive_decision() with AI/human branching and timeout - Enhanced submit_defensive_decision() to resolve pending futures - Enhanced submit_offensive_decision() to resolve pending futures - Added DECISION_TIMEOUT constant (30 seconds) AI Opponent (Stub): - Created ai_opponent.py with stub implementations - generate_defensive_decision() returns default "normal" positioning - generate_offensive_decision() returns default "normal" approach - TODO markers for Week 9 full AI logic implementation Integration: - Backward compatible with existing terminal client workflow - New async methods ready for WebSocket integration (Week 7 Task 4) - AI teams get instant decisions, human teams wait with timeout - Default decisions applied on timeout (no game blocking) Testing: - Config tests: 58/58 passing ✅ - Terminal client: Working perfectly ✅ - Existing workflows: Fully compatible ✅ Week 7 Task 1: Complete Next: Task 2 - Decision Validators 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
6880b6d5ad |
CLAUDE: Complete Week 6 - granular PlayOutcome integration and metadata support
- Renamed check_d20 → chaos_d20 throughout dice system - Expanded PlayOutcome enum with granular variants (SINGLE_1/2, DOUBLE_2/3, GROUNDBALL_A/B/C, etc.) - Integrated PlayOutcome from app.config into PlayResolver - Added play_metadata support for uncapped hit tracking - Updated all tests (139/140 passing) Week 6: 100% Complete - Ready for Phase 3 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
aabb90feb5 |
CLAUDE: Implement player models and optimize database queries
This commit includes Week 6 player models implementation and critical performance optimizations discovered during testing. ## Player Models (Week 6 - 50% Complete) **New Files:** - app/models/player_models.py (516 lines) - BasePlayer abstract class with polymorphic interface - SbaPlayer with API parsing factory method - PdPlayer with batting/pitching scouting data support - Supporting models: PdCardset, PdRarity, PdBattingCard, PdPitchingCard - tests/unit/models/test_player_models.py (692 lines) - 32 comprehensive unit tests, all passing - Tests for BasePlayer, SbaPlayer, PdPlayer, polymorphism **Architecture:** - Simplified single-layer approach vs planned two-layer - Factory methods handle API → Game transformation directly - SbaPlayer.from_api_response(data) - parses SBA API inline - PdPlayer.from_api_response(player_data, batting_data, pitching_data) - Full Pydantic validation, type safety, and polymorphism ## Performance Optimizations **Database Query Reduction (60% fewer queries per play):** - Before: 5 queries per play (INSERT play, SELECT play with JOINs, SELECT games, 2x SELECT lineups) - After: 2 queries per play (INSERT play, UPDATE games conditionally) Changes: 1. Lineup caching (game_engine.py:384-425) - Check state_manager.get_lineup() cache before DB fetch - Eliminates 2 SELECT queries per play 2. Remove unnecessary refresh (operations.py:281-302) - Removed session.refresh(play) after INSERT - Eliminates 1 SELECT with 3 expensive LEFT JOINs 3. Direct UPDATE statement (operations.py:109-165) - Changed update_game_state() to use direct UPDATE - No longer does SELECT + modify + commit 4. Conditional game state updates (game_engine.py:200-217) - Only UPDATE games table when score/inning/status changes - Captures state before/after and compares - ~40-60% fewer updates (many plays don't score) ## Bug Fixes 1. Fixed outs_before tracking (game_engine.py:551) - Was incorrectly calculating: state.outs - result.outs_recorded - Now correctly captures: state.outs (before applying result) - All play records now have accurate out counts 2. Fixed game recovery (state_manager.py:312-314) - AttributeError when recovering: 'GameState' has no attribute 'runners' - Changed to use state.get_all_runners() method - Games can now be properly recovered from database ## Enhanced Terminal Client **Status Display Improvements (terminal_client/display.py:75-97):** - Added "⚠️ WAITING FOR ACTION" section when play is pending - Shows specific guidance: - "The defense needs to submit their decision" → Run defensive [OPTIONS] - "The offense needs to submit their decision" → Run offensive [OPTIONS] - "Ready to resolve play" → Run resolve - Color-coded command hints for better UX ## Documentation Updates **backend/CLAUDE.md:** - Added comprehensive Player Models section (204 lines) - Updated Current Phase status to Week 6 (~50% complete) - Documented all optimizations and bug fixes - Added integration examples and usage patterns **New Files:** - .claude/implementation/week6-status-assessment.md - Comprehensive Week 6 progress review - Architecture decision rationale (single-layer vs two-layer) - Completion status and next priorities - Updated roadmap for remaining Week 6 work ## Test Results - Player models: 32/32 tests passing - All existing tests continue to pass - Performance improvements verified with terminal client ## Next Steps (Week 6 Remaining) 1. Configuration system (BaseConfig, SbaConfig, PdConfig) 2. Result charts & PD play resolution with ratings 3. API client for live roster data (deferred) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
05fc037f2b |
CLAUDE: Fix game recovery and add required field validation for plays
Fixed critical bugs in game recovery and play persistence: 1. Terminal REPL Auto-Recovery: - Added _ensure_game_loaded() helper to auto-recover games from database - Calls state_manager.recover_game() when game not in memory - Calls _prepare_next_play() after recovery to populate snapshot fields - Enables seamless continuation of games across REPL sessions 2. Play Validation: - Added verification in _save_play_to_db() for required fields - Ensures batter_id, pitcher_id, catcher_id are never NULL - Raises ValueError with clear error message if fields missing - Prevents database constraint violations 3. Updated Commands: - All REPL commands now call _ensure_game_loaded() - Commands: defensive, offensive, resolve, status, quick_play, box_score - Fixes "Game state not found" errors on recovered games Root Cause: - state_manager.recover_game() rebuilds GameState from database - But didn't populate snapshot fields (current_batter_lineup_id, etc.) - _save_play_to_db() requires these fields to save plays - Solution: Call _prepare_next_play() after recovery Files Modified: - app/core/game_engine.py - Added verification in _save_play_to_db() - terminal_client/repl.py - Added _ensure_game_loaded() and integrated Testing: Successfully recovered game, submitted decisions, and resolved plays 🚀 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
13e924a87c |
CLAUDE: Refactor GameEngine to forward-looking play tracking pattern
Replaced awkward "lookback" pattern with clean "prepare → execute → save" orchestration that captures state snapshots BEFORE each play. Key improvements: - Added per-team batter indices (away_team_batter_idx, home_team_batter_idx) - Added play snapshot fields (current_batter/pitcher/catcher_lineup_id) - Added on_base_code bit field for efficient base situation queries - Created _prepare_next_play() method for snapshot preparation - Refactored start_game() with hard lineup validation requirement - Refactored resolve_play() with explicit 6-step orchestration - Updated _save_play_to_db() to use snapshots (no DB lookbacks) - Enhanced state recovery to rebuild from last play (single query) - Added defensive lineup position validator Benefits: - No special cases for first play - Single source of truth in GameState - Saves 18+ database queries per game - Fast state recovery without replay - Complete runner tracking (before/after positions) - Explicit orchestration (easy to debug) Testing: - Added 3 new test functions (lineup validation, snapshot tracking, batting order) - All 5 test suites passing (100%) - Type checking cleaned up with targeted suppressions for SQLAlchemy Documentation: - Added comprehensive "Type Checking & Common False Positives" section to CLAUDE.md - Created type-checking-guide.md and type-checking-summary.md - Added mypy.ini configuration for SQLAlchemy/Pydantic 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
0542723d6b |
CLAUDE: Fix GameEngine lineup integration and add test script
Fixes: ✅ Updated GameEngine._save_play_to_db() to fetch real lineup IDs - Gets active batting/fielding lineups from database - Extracts batter, pitcher, catcher IDs by position - No more hardcoded placeholder IDs ✅ Shortened AbRoll.__str__() to fit VARCHAR(50) - "WP 1/10" instead of "AB Roll: Wild Pitch Check..." - "AB 6,9(4+5) d20=12/10" for normal rolls - Prevents database truncation errors ✅ Created comprehensive test script (scripts/test_game_flow.py) - Tests single at-bat flow - Tests full half-inning (50+ plays) - Creates dummy lineups for both teams - Verifies complete game lifecycle Test Results: ✅ Successfully ran 50 at-bats across 6 innings ✅ Score tracking: Away 5 - Home 2 ✅ Inning advancement working ✅ Play persistence to database ✅ Roll batch saving at inning boundaries ✅ State synchronization (memory + DB) GameEngine Verified Working: ✅ Game lifecycle management (create → start → play → complete) ✅ Decision submission (defensive + offensive) ✅ Play resolution with AbRoll system ✅ State management and persistence ✅ Inning advancement logic ✅ Score tracking ✅ Lineup integration ✅ Database persistence Ready for: - WebSocket integration - Frontend connectivity - Full game simulations - AI opponent integration 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cal Corum
|
0d7ddbe408 |
CLAUDE: Implement GameEngine, PlayResolver, and GameValidator
Core Components: ✅ GameValidator (validators.py) - Validates game state and decisions - Rule enforcement for baseball gameplay - Game-over and inning continuation logic ✅ PlayResolver (play_resolver.py) - Resolves play outcomes using AbRoll system - Simplified result charts for MVP - Handles wild pitch/passed ball checks - Runner advancement logic for all hit types - PlayOutcome enum with 12 outcome types ✅ GameEngine (game_engine.py) - Orchestrates complete game flow - Start game, submit decisions, resolve plays - Integrates DiceSystem with roll context - Batch saves rolls at end of each half-inning - Persists plays and game state to database - Manages inning advancement and game completion Integration Features: - Uses advanced AbRoll system (not simplified d20) - Roll context tracking per inning - Batch persistence at inning boundaries - Full audit trail with roll history - State synchronization between memory and database Architecture: GameEngine → PlayResolver → DiceSystem ↓ ↓ GameValidator StateManager ↓ ↓ Database In-Memory Cache Ready For: ✅ End-to-end at-bat testing ✅ WebSocket integration ✅ Result chart configuration ✅ Advanced decision logic (Phase 3) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> |