Update app.py

app.py

@@ -13,28 +13,38 @@ OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 openai_client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- DONNÉES ---
-def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
+# --- MCP TOOL: OPENING DATABASE ---
+def tool_get_opening(board):
+    """Tool to retrieve opening name from Lichess DB."""
+    path_prefix = "/app/data/lichess_openings/dist/"
     try:
-        files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
-        dfs = []
-        for fn in files:
-            if os.path.exists(fn):
-                df = pd.read_csv(fn, sep="\t", usecols=["eco", "name", "pgn", "uci", "epd"])
-                dfs.append(df)
-        if not dfs: return pd.DataFrame()
-        return pd.concat(dfs, ignore_index=True)
+        # Lazy loading to avoid global scope issues
+        if not hasattr(tool_get_opening, "db"):
+            files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
+            dfs = []
+            for fn in files:
+                if os.path.exists(fn):
+                    df = pd.read_csv(fn, sep="\t", usecols=["eco", "name", "pgn", "uci", "epd"])
+                    dfs.append(df)
+            tool_get_opening.db = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
+        
+        if tool_get_opening.db.empty: return "Unknown Opening"
+        
+        match = tool_get_opening.db[tool_get_opening.db["epd"] == board.epd()]
+        if not match.empty: 
+            return f"{match.iloc[0]['eco']} - {match.iloc[0]['name']}"
+        return "Unknown / Middle Game"
     except:
-        return pd.DataFrame()
-
-OPENINGS_DB = _load_lichess_openings()
+        return "Database Error"
 
-# --- ANALYSE ---
-
-def get_engine_analysis(board, time_limit=0.5):
-    """Analyse sécurisée."""
-    if board.is_game_over(): return "N/A", "PARTIE TERMINÉE", ""
-    if not os.path.exists(STOCKFISH_PATH): return "0", "Engine missing", ""
+# --- MCP TOOL: STOCKFISH ENGINE ---
+def tool_engine_analysis(board, time_limit=0.5):
+    """
+    Tool that uses Stockfish to calculate score and best move.
+    Returns: Score string, Best move (Coordinate format).
+    """
+    if board.is_game_over(): return "GAME OVER", "NONE", "NONE"
+    if not os.path.exists(STOCKFISH_PATH): return "0", "Engine Missing", ""
     
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
@@ -42,31 +52,33 @@ def get_engine_analysis(board, time_limit=0.5):
             score = info["score"].white()
             
             if score.is_mate():
-                score_val = f"MAT ({abs(score.mate())})"
+                score_val = f"MATE IN {abs(score.mate())}"
             else:
                 score_val = str(score.score())
 
             best_move = info.get("pv", [None])[0]
             if best_move:
-                dest = chess.square_name(best_move.to_square)
+                # ROBOTIC PRECISION: Use coordinates only (e.g., e2e4)
+                # This avoids any hallucination about piece names.
                 origin = chess.square_name(best_move.from_square)
-                desc = f"{origin} ➔ {dest}"
-                full_desc = f"Bouger en {dest}"
+                dest = chess.square_name(best_move.to_square)
+                move_uci = f"{origin} -> {dest}" # e.g. "e2 -> e4"
             else:
-                desc, full_desc = "Aucun", "Aucun"
+                move_uci = "NO MOVE FOUND"
 
-            return score_val, full_desc, desc
+            return score_val, move_uci, move_uci
     except:
-        return "N/A", "Erreur Analyse", ""
+        return "N/A", "ANALYSIS ERROR", ""
 
-def get_ai_move(board, level):
+def tool_ai_play(board, level):
+    """Tool to generate the Opponent's move."""
     levels = {
-        "Débutant": {"time": 0.01, "skill": 1, "depth": 1},
-        "Intermédiaire": {"time": 0.1, "skill": 8, "depth": 6},
-        "Avancé": {"time": 0.5, "skill": 15, "depth": 12},
-        "Grand Maître": {"time": 1.0, "skill": 20, "depth": 18}
+        "Beginner": {"time": 0.01, "skill": 1, "depth": 1},
+        "Intermediate": {"time": 0.1, "skill": 8, "depth": 6},
+        "Advanced": {"time": 0.5, "skill": 15, "depth": 12},
+        "Grandmaster": {"time": 1.0, "skill": 20, "depth": 18}
     }
-    config = levels.get(level, levels["Débutant"])
+    config = levels.get(level, levels["Beginner"])
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
             engine.configure({"Skill Level": config["skill"]})
@@ -75,86 +87,82 @@ def get_ai_move(board, level):
     except:
         return None
 
-# --- AUDIO & CHAT (CORRECTIF IMPORTANT) ---
+# --- AUDIO & TRANSCRIPTION ---
 
 def generate_voice(text):
-    """Génération audio robuste avec écriture binaire directe."""
     if not openai_client or not text: return None
     try:
         response = openai_client.audio.speech.create(
             model="tts-1",
-            voice="onyx",
+            voice="onyx", # Deep, robotic male voice
             input=text,
             speed=1.15
         )
         unique = f"deepblue_{uuid.uuid4()}.mp3"
         path = os.path.join("/tmp", unique)
-        
-        # CORRECTIF: Utilisation de iter_bytes() au lieu de stream_to_file (déprécié)
         with open(path, "wb") as f:
             for chunk in response.iter_bytes():
                 f.write(chunk)
-                
         return path
     except Exception as e:
-        print(f"Audio Error: {e}")
+        print(f"Audio Gen Error: {e}")
         return None
 
 def transcribe(audio_path):
     if not openai_client or not audio_path: return None
     try:
         with open(audio_path, "rb") as f:
-            t = openai_client.audio.transcriptions.create(model="whisper-1", file=f, language="fr")
+            t = openai_client.audio.transcriptions.create(model="whisper-1", file=f, language="en") # English Transcription
         return t.text
     except:
         return None
 
-# --- PERSONA DEEP BLUE ---
+# --- AGENT BRAIN (DEEP BLUE) ---
 
 SYSTEM_PROMPT = """
-Tu es DEEP BLUE, supercalculateur d'échecs.
-Tu parles au Joueur Blanc.
+You are DEEP BLUE, a chess supercomputer.
+You are communicating with the Human Player (White pieces).
 
-RÈGLE ABSOLUE DE FORMAT :
-1. Dis le COUP à jouer. (ex: "Joue Cavalier f3.", "Prends le pion e5.").
-2. Dis la RAISON stratégique. (ex: "Ceci contrôle le centre.", "Cela ouvre la ligne pour la Tour.").
+PROTOCOL:
+1. **IDENTIFY MOVE**: State the optimal move using coordinates (e.g., "Move e2 to e4"). Do not use piece names to avoid errors.
+2. **STRATEGIC LOGIC**: Explain *why* in one concise sentence (e.g., "Controls center," "Threatens Queen," "Safe position").
 
-Ton : Froid, direct, efficace. Pas de "Bonjour".
-Si le joueur gagne : "MAT CONFIRMÉ. FIN DE SESSION."
+TONE: Robotic, High-Tech, Concise. No polite filler.
+IF PLAYER WINS: "CHECKMATE CONFIRMED. HUMAN INTELLECT EXCEEDS PARAMETERS."
 """
 
-def consult_deepblue(fen, mode="auto", user_audio=None):
+def agent_reasoning(fen, mode="auto", user_audio=None):
     board = chess.Board(fen)
     
+    # 1. Check Game State
     if board.is_game_over():
         if board.is_checkmate():
-            msg = "ÉCHEC ET MAT. PARTIE TERMINÉE."
-            if board.turn == chess.BLACK: msg += " VICTOIRE HUMAINE."
-            else: msg += " VICTOIRE SYSTÈME."
-            return msg, generate_voice(msg), "FIN"
-        return "PARTIE NULLE.", None, "FIN"
+            msg = "CHECKMATE. GAME OVER."
+            msg += " HUMAN VICTORY." if board.turn == chess.BLACK else " SYSTEM VICTORY."
+            return msg, generate_voice(msg), "END"
+        return "DRAW / STALEMATE.", None, "END"
 
-    score, best_move_text, arrow_simple = get_engine_analysis(board)
-    
-    opening = "N/A"
-    if not OPENINGS_DB.empty:
-        match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
-        if not match.empty: opening = match.iloc[0]['name']
+    # 2. Use Tools (MCP Pattern)
+    score, best_move_uci, arrow_visual = tool_engine_analysis(board)
+    opening = tool_get_opening(board)
 
+    # 3. Construct Context
     context = f"""
-    [DATA]
-    Trait : {'Blancs' if board.turn == chess.WHITE else 'Noirs'}.
-    Score : {score}.
-    COUP OPTIMAL : {best_move_text} ({arrow_simple}).
+    [SYSTEM DATA]
+    Turn: {'White' if board.turn == chess.WHITE else 'Black'}.
+    Score (Centipawns): {score}.
+    Opening DB: {opening}.
+    OPTIMAL MOVE CALCULATED: {best_move_uci}.
     """
     
     if mode == "question" and user_audio:
         q = transcribe(user_audio)
-        context += f"\n[INPUT JOUEUR] : {q}"
+        context += f"\n[HUMAN QUERY]: {q}"
     else:
-        context += "\nInstruction : Dis le coup et la stratégie."
+        context += "\nINSTRUCTION: Output the optimal move and the strategic reason."
 
-    reply = "Calcul..."
+    # 4. LLM Synthesis
+    reply = "Computing..."
     if openai_client:
         try:
             response = openai_client.chat.completions.create(
@@ -163,95 +171,115 @@ def consult_deepblue(fen, mode="auto", user_audio=None):
             )
             reply = response.choices[0].message.content
         except:
-            reply = "Erreur IA."
+            reply = "Connection Error."
 
     audio = generate_voice(reply)
-    return reply, audio, arrow_simple
+    return reply, audio, arrow_visual
 
-# --- BOUCLE DE JEU ---
+# --- GAME LOOP ---
 
-def update_history(new_advice, history_list):
-    if not new_advice or new_advice == "FIN": return history_list
-    history_list.insert(0, f"➤ {new_advice}")
+def update_log(new_advice, history_list):
+    if not new_advice or new_advice == "END": return history_list
+    history_list.insert(0, f"> {new_advice}")
     return history_list
 
-def format_history_display(history_list):
+def format_log(history_list):
     return "\n\n".join(history_list)
 
 def game_cycle(fen, level, history_list):
     board = chess.Board(fen)
     
-    # 1. Fin de jeu ?
+    # Check Instant Win (User mated AI)
     if board.is_game_over():
-        text, audio, _ = consult_deepblue(fen)
-        return fen, text, audio, format_history_display(history_list), history_list
+        text, audio, _ = agent_reasoning(fen)
+        return fen, text, audio, format_log(history_list), history_list
 
-    # 2. Tour IA (Noirs)
+    # AI Turn (Black)
     if board.turn == chess.BLACK:
-        ai_move = get_ai_move(board, level)
+        ai_move = tool_ai_play(board, level)
         if ai_move: board.push(ai_move)
         
-        text, audio, arrow = consult_deepblue(board.fen(), mode="auto")
-        new_hist = update_history(f"Conseil: {arrow}", history_list)
-        return board.fen(), text, audio, format_history_display(new_hist), new_hist
+        # Deep Blue analyzes the new position for the player
+        text, audio, arrow = agent_reasoning(board.fen(), mode="auto")
+        new_hist = update_log(f"OPT: {arrow}", history_list)
+        
+        return board.fen(), text, audio, format_log(new_hist), new_hist
 
-    return fen, "Attente...", None, format_history_display(history_list), history_list
+    return fen, "Awaiting Input...", None, format_log(history_list), history_list
 
 def reset_game():
-    return chess.STARTING_FEN, "SYSTÈME RÉINITIALISÉ.", None, "", []
+    return chess.STARTING_FEN, "SYSTEM REBOOTED.", None, "", []
 
-def ask_deepblue(fen, audio, history_list):
-    text, aud, arrow = consult_deepblue(fen, mode="question", user_audio=audio)
-    return text, aud, format_history_display(history_list), history_list
+def ask_agent(fen, audio, history_list):
+    text, aud, arrow = agent_reasoning(fen, mode="question", user_audio=audio)
+    return text, aud, format_log(history_list), history_list
 
-# --- UI CSS ---
+# --- UI CSS (MODERN BLUE) ---
 css = """
-body { background-color: #0b0f19; color: #e2e8f0; }
-.gradio-container { background-color: #0b0f19 !important; border: none; }
-#title { color: #38bdf8; text-align: center; font-family: 'Courier New', monospace; font-size: 2em; margin-bottom: 0; }
-#board { border: 2px solid #38bdf8; box-shadow: 0 0 20px rgba(56, 189, 248, 0.2); }
-button.primary { background-color: #0ea5e9 !important; color: white !important; font-weight: bold; }
+body { background-color: #020617; color: #e2e8f0; }
+.gradio-container { background-color: #020617 !important; border: none; }
+#title { 
+    color: #0ea5e9; 
+    text-align: center; 
+    font-family: 'Courier New', monospace; 
+    font-size: 4em; /* TITRE GEANT */
+    font-weight: 800;
+    margin-bottom: 20px;
+    letter-spacing: -2px;
+    text-shadow: 0 0 10px rgba(14, 165, 233, 0.5);
+}
+#board { border: 3px solid #0ea5e9; box-shadow: 0 0 30px rgba(14, 165, 233, 0.1); }
+button.primary { background-color: #0ea5e9 !important; color: black !important; font-weight: bold; border: none; }
 button.secondary { background-color: #1e293b !important; color: #94a3b8 !important; border: 1px solid #334155; }
-.feedback { background-color: #1e293b !important; color: #38bdf8 !important; border: 1px solid #334155; font-family: 'Courier New'; }
+.feedback { 
+    background-color: #0f172a !important; 
+    color: #38bdf8 !important; 
+    border: 1px solid #1e293b; 
+    font-family: 'Consolas', 'Monaco', monospace; 
+    font-size: 1.1em;
+}
+label { color: #64748b !important; font-weight: bold; }
 """
 
 # --- INTERFACE ---
 
-with gr.Blocks(title="Coach Deep Blue", css=css, theme=gr.themes.Base()) as demo:
+with gr.Blocks(title="DEEP BLUE", css=css, theme=gr.themes.Base()) as demo:
     
-    # HEADER
     with gr.Row():
-        gr.Markdown("# 🟦 COACH DEEP BLUE", elem_id="title")
+        gr.Markdown("# DEEP BLUE", elem_id="title")
     
     with gr.Row():
-        # Label modifié comme demandé
-        level = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Difficulté Adversaire", interactive=True)
+        level = gr.Dropdown(
+            ["Beginner", "Intermediate", "Advanced", "Grandmaster"], 
+            value="Beginner", 
+            label="OPPONENT DIFFICULTY", 
+            interactive=True
+        )
 
-    # MAIN
     with gr.Row():
-        # GAUCHE (PLATEAU)
+        # LEFT: BOARD
         with gr.Column(scale=2):
-            board = Chessboard(elem_id="board", label="Zone de Combat", value=chess.STARTING_FEN, game_mode=True, interactive=True)
+            board = Chessboard(elem_id="board", label="Battle Zone", value=chess.STARTING_FEN, game_mode=True, interactive=True)
 
-        # DROITE (CONTROLES)
+        # RIGHT: CONTROLS
         with gr.Column(scale=1):
-            btn_reset = gr.Button("🔄 RESTART SYSTEM", variant="secondary")
+            btn_reset = gr.Button("INITIALIZE NEW SEQUENCE", variant="secondary")
             
-            gr.Markdown("### 📟 Terminal Sortie")
-            coach_txt = gr.Textbox(label="Message", interactive=False, lines=3, elem_classes="feedback")
+            gr.Markdown("### 📟 SYSTEM OUTPUT")
+            coach_txt = gr.Textbox(label="Analysis", interactive=False, lines=3, elem_classes="feedback")
             
-            # AUDIO VISIBLE (Pour que l'autoplay fonctionne)
-            coach_audio = gr.Audio(label="Synthèse", autoplay=True, interactive=False, type="filepath", visible=True)
+            # Audio visible for autoplay, but minimal
+            coach_audio = gr.Audio(label="Voice Synthesis", autoplay=True, interactive=False, type="filepath", visible=True)
             
-            gr.Markdown("### 📜 Log Tactique")
+            gr.Markdown("### 📜 STRATEGY LOG")
             history_state = gr.State([])
-            history_display = gr.Textbox(label="Historique Conseils", interactive=False, lines=5, max_lines=10, elem_classes="feedback")
+            history_display = gr.Textbox(label="Optimization History", interactive=False, lines=6, max_lines=10, elem_classes="feedback")
             
-            gr.Markdown("### 🎤 Input Vocal")
+            gr.Markdown("### 🎤 HUMAN INTERFACE")
             mic = gr.Audio(sources=["microphone"], type="filepath", show_label=False)
-            btn_ask = gr.Button("TRANSMETTRE QUESTION", variant="primary")
+            btn_ask = gr.Button("QUERY SYSTEM", variant="primary")
 
-    # LOGIQUE
+    # LOGIC MAPPING
     board.move(
         fn=game_cycle,
         inputs=[board, level, history_state],
@@ -259,8 +287,8 @@ with gr.Blocks(title="Coach Deep Blue", css=css, theme=gr.themes.Base()) as demo
     )
     
     btn_reset.click(fn=reset_game, outputs=[board, coach_txt, coach_audio, history_display, history_state])
-    btn_ask.click(fn=ask_deepblue, inputs=[board, mic, history_state], outputs=[coach_txt, coach_audio, history_display, history_state])
-    mic.stop_recording(fn=ask_deepblue, inputs=[board, mic, history_state], outputs=[coach_txt, coach_audio, history_display, history_state])
+    btn_ask.click(fn=ask_agent, inputs=[board, mic, history_state], outputs=[coach_txt, coach_audio, history_display, history_state])
+    mic.stop_recording(fn=ask_agent, inputs=[board, mic, history_state], outputs=[coach_txt, coach_audio, history_display, history_state])
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, allowed_paths=["/tmp"])