Upload stratego\web\app.py with huggingface_hub

stratego//web//app.py

@@ -0,0 +1,341 @@
+"""Main Streamlit application for Stratego Human vs AI"""
+
+import streamlit as st
+from stratego.web.config import session_manager, agent_builder, game_config
+from stratego.web.game_controller import GameController
+from stratego.web.components import game_history, status_panel
+from stratego.web.components.interactive_board import render_interactive_board
+from stratego.web.utils.validators import normalize_move
+
+
+def screen_welcome():
+    """Screen 0: Welcome and game mode selection"""
+    st.title("⚔️ STRATEGO - Human vs AI")
+    st.markdown("*Challenge an intelligent AI opponent in the classic strategy game!*")
+
+    st.divider()
+
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.subheader("🎮 How to Play")
+        st.write("""
+        **Objective:** Capture the enemy flag or eliminate all movable pieces
+
+        **Your Setup:**
+        - 🔵 Your army positioned at the **BOTTOM** of the board
+        - Arrange your pieces strategically before the game starts
+        - Each piece has a rank that determines its strength
+
+        **Your Turn:**
+        1. **Click on one of your pieces** (blue area at bottom)
+        2. **Available destination squares will be highlighted** in green with a dot (●)
+        3. **Click the destination** to move your piece there
+        4. **Battles resolve automatically** when pieces meet
+
+        **AI Opponent:**
+        - 🔴 Enemy forces at the **TOP** of the board
+        - Uses Mistral 7B LLM to make strategic decisions
+        - Plays immediately after your move
+        """)
+
+        st.markdown("---")
+        st.markdown("### ⚙️ Setup Requirements")
+        with st.expander("📦 Ollama Installation", expanded=False):
+            st.code(
+                """# Make sure you have Ollama running locally:
+ollama serve
+
+# In a new terminal, pull Mistral:
+ollama pull mistral:7b
+
+# Verify it's installed:
+ollama list""",
+                language="bash"
+            )
+            st.caption(
+                "💡 Ollama provides local LLM inference. "
+                "Download: https://ollama.ai"
+            )
+
+    with col2:
+        st.subheader("📊 Game Info")
+        selected_config = game_config.get_game_config(
+            "Standard (10x10)"
+        )
+        st.metric("Board Size", "10 × 10")
+        st.metric("Players", "2 (You vs AI)")
+        st.metric("AI Model", "Mistral 7B")
+        st.metric("Time/Move", "~2-5 sec")
+
+        st.divider()
+
+        st.subheader("🎯 Piece Legend")
+        legend_data = {
+            "🚩": "Flag (0★) - Must protect!",
+            "💣": "Bomb (0★) - Immovable",
+            "👑": "Marshal (10★) - Strongest",
+            "⭐": "General (9★) - Second strongest",
+            "🏃": "Scout (2★) - Can move multi-square",
+            "🕵️": "Spy (1★) - Defeats Marshal",
+            "🪖": "Sergeant (3★)",
+            "📍": "Lieutenant (4★)",
+            "🎖️": "Captain (6★)",
+        }
+        for emoji, desc in legend_data.items():
+            st.caption(f"{emoji} {desc}")
+
+    st.divider()
+
+    # Game mode selection
+    st.markdown("### 🕹️ Start Your Battle")
+
+    col1, col2 = st.columns([3, 1])
+
+    with col1:
+        st.markdown(
+            "**Standard 10×10 with lakes**\n"
+            "Classic Stratego rules. Your pieces at bottom, AI at top."
+        )
+
+    with col2:
+        if st.button("Start Game →", type="primary", use_container_width=True, key="start_game_btn"):
+            session_manager.SessionManager.set_game_mode("Standard (10x10)")
+            session_manager.SessionManager.set_screen(1)
+            st.rerun()
+
+
+def screen_ai_config():
+    """Screen 1: AI agent configuration - Real Ollama setup"""
+    st.title("⚙️ Configure AI Opponent")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("🚀 Ollama AI Model")
+
+        # Ollama configuration
+        backend = "ollama"
+        st.success("✅ Using Ollama Backend")
+
+        available_models = game_config.get_available_models(backend)
+        model = st.selectbox(
+            "Select Model:",
+            available_models,
+            index=0,
+            help="Choose from available Ollama models (make sure it's pulled: ollama pull mistral:7b)"
+        )
+
+        ollama_url = st.text_input(
+            "🔗 Ollama Server URL:",
+            value="http://localhost:11434",
+            help="Local: http://localhost:11434 | Remote: your_server_ip:11434"
+        )
+
+        # Test connection button
+        if st.button("🧪 Test Connection", help="Check if Ollama is running"):
+            try:
+                import requests
+                response = requests.get(f"{ollama_url}/api/tags", timeout=3)
+                if response.status_code == 200:
+                    st.success("✅ Connected to Ollama!")
+                    st.caption(f"(Available models: {len(response.json().get('models', []))})")
+                else:
+                    st.error(f"❌ Ollama responded with status {response.status_code}")
+            except Exception as e:
+                st.error(f"❌ Cannot connect to Ollama: {str(e)}")
+                st.caption(f"Make sure Ollama is running at {ollama_url}")
+
+    with col2:
+        st.subheader("📖 Strategy & Settings")
+
+        prompt = st.selectbox(
+            "Prompt Style:",
+            game_config.PROMPT_PRESETS,
+            index=0,
+            help="base=minimal | concise=focused on winning | adaptive=strategic analysis"
+        )
+
+        st.info("💡 Tip: Start with Mistral 7B for good balance of speed and quality")
+
+    st.divider()
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("< Back", use_container_width=True):
+            session_manager.SessionManager.set_screen(0)
+            st.rerun()
+
+    with col3:
+        if st.button("🎮 Start Game", type="primary", use_container_width=True):
+            # Build real OllamaAgent
+            try:
+                from stratego.models.ollama_model import OllamaAgent
+
+                st.session_state.ollama_url = ollama_url
+                agent = OllamaAgent(
+                    model_name=model,
+                    prompt_pack=prompt,
+                    host=ollama_url
+                )
+
+                # Initialize game
+                mode = session_manager.SessionManager.get_game_mode()
+                env_id = game_config.get_env_id(mode)
+                size = game_config.get_board_size(mode)
+
+                game_ctrl = GameController(env_id, size, agent, prompt)
+                game_ctrl.reset()
+
+                session_manager.SessionManager.set_game_controller(game_ctrl)
+                session_manager.SessionManager.set_ai_config(backend, model, prompt)
+                session_manager.SessionManager.set_screen(2)
+                st.rerun()
+
+            except Exception as e:
+                st.error(f"❌ Failed to create AI: {str(e)}")
+                st.code(f"Error details:\n{str(e)}")
+                st.warning(
+                    f"Make sure:\n"
+                    f"1. Ollama is running: `ollama serve`\n"
+                    f"2. Model is pulled: `ollama pull {model}`\n"
+                    f"3. Server URL is correct: {ollama_url}"
+                )
+
+
+def screen_active_game():
+    """Screen 2: Active game with interactive chess-like board"""
+    game_ctrl = session_manager.SessionManager.get_game_controller()
+
+    if not game_ctrl:
+        st.error("Game not initialized!")
+        return
+
+    st.title("⚔️ STRATEGO - Battle Arena")
+
+    # Top controls
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col1:
+        if st.button("🔄 Reset", help="Start a new game"):
+            session_manager.SessionManager.reset_all()
+            st.rerun()
+
+    with col2:
+        # Game stats in header
+        col2a, col2b, col2c = st.columns(3)
+        with col2a:
+            st.metric("Moves", game_ctrl.get_turn_count())
+        with col2b:
+            current = "👤 You" if game_ctrl.is_human_turn() else "🤖 AI"
+            st.metric("Current", current)
+        with col2c:
+            st.metric("Status", "🎮 Active" if not game_ctrl.game_done else "🏁 Ended")
+
+    with col3:
+        if st.button("📋 Menu", help="Return to main menu"):
+            session_manager.SessionManager.reset_all()
+            st.rerun()
+
+    st.divider()
+
+    # Main game area
+    left, right = st.columns([2.5, 1.5])
+
+    with left:
+        # Interactive board
+        player_move = render_interactive_board(game_ctrl)
+
+        if player_move:
+            # Execute human move
+            done, info = game_ctrl.execute_move(player_move)
+
+            if done:
+                st.session_state.game_ended = True
+                st.rerun()
+
+            # Trigger AI turn
+            player_id, obs = game_ctrl.get_current_player()
+            st.rerun()
+
+        # AI's turn
+        if game_ctrl.is_ai_turn():
+            st.divider()
+            st.markdown("## 🤖 AI is thinking...")
+
+            with st.spinner("AI calculating move..."):
+                try:
+                    move, error = game_ctrl.get_ai_move()
+
+                    if error:
+                        st.warning(f"⚠️ {error}")
+
+                    done, info = game_ctrl.execute_move(move)
+                    st.success(f"✅ AI played: {move}")
+
+                    if done:
+                        st.session_state.game_ended = True
+                    else:
+                        # Update to human turn
+                        player_id, obs = game_ctrl.get_current_player()
+
+                    st.rerun()
+
+                except Exception as e:
+                    st.error(f"❌ AI Error: {str(e)}")
+                    st.code(str(e))
+
+    with right:
+        st.subheader("📊 Game Info")
+
+        # Status panel with beautiful styling
+        status_panel.render_status_panel(game_ctrl)
+
+        st.divider()
+
+        # Move history
+        st.subheader("📜 Move History")
+        game_history.render_game_history(game_ctrl)
+
+        # Game end screen
+        if game_ctrl.game_done:
+            st.divider()
+            st.error("🏁 GAME ENDED!")
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("🔄 Play Again", use_container_width=True):
+                    session_manager.SessionManager.reset_all()
+                    st.rerun()
+            with col2:
+                if st.button("🏠 Main Menu", use_container_width=True):
+                    session_manager.SessionManager.reset_all()
+                    st.rerun()
+
+
+def main():
+    """Main application entry point"""
+    # Configure page
+    st.set_page_config(
+        page_title="Stratego - Human vs AI",
+        page_icon="chess",
+        layout="wide",
+        initial_sidebar_state="collapsed"
+    )
+    
+    # Initialize session
+    session_manager.SessionManager.init()
+    
+    # Route to correct screen
+    screen = session_manager.SessionManager.get_screen()
+    
+    if screen == 0:
+        screen_welcome()
+    elif screen == 1:
+        screen_ai_config()
+    elif screen == 2:
+        screen_active_game()
+    else:
+        st.error(f"Unknown screen: {screen}")
+
+
+if __name__ == "__main__":
+    main()