Update app.py

app.py

@@ -169,164 +169,75 @@ Based *only* on the data in the DataFrame, provide the exact answer to the quest
 
 def analyze_chess_image(file_path: str) -> str:
     """
-    Analyzes a chess position from an image using a multimodal model (GPT-4o).
-    Identifies the board state and then uses a chess engine to find the best move for Black.
-    Returns the best move in algebraic notation or an error message.
+    Analyzes a chess position from an image using GPT-4o directly.
+    Asks the model for the best move for Black that guarantees a win.
+
+    NOTE: Relies entirely on the LLM's image interpretation and chess evaluation,
+          which is significantly less reliable than a dedicated chess engine
+          for finding guaranteed winning moves.
+
+    Returns:
+        The move in algebraic notation (if successful) or an error message.
     """
     if not Path(file_path).is_file():
         return f"ERROR: Chess image file not found at {file_path}"
 
     try:
-        logging.info(f"Analyzing chess image: {file_path}")
+        logging.info(f"Analyzing chess image using GPT-4o: {file_path}")
 
         # 1. Encode image to base64
         with open(file_path, "rb") as image_file:
             base64_image = base64.b64encode(image_file.read()).decode('utf-8')
 
-        # 2. Use GPT-4o to get FEN
-        llm = ChatOpenAI(model="gpt-4o", max_tokens=200)
+        # 2. Use GPT-4o to analyze and get the move
+        # Ensure OPENAI_API_KEY is set
+        if not os.getenv("OPENAI_API_KEY"):
+             return "ERROR: OPENAI_API_KEY not set. Cannot analyze chess image."
+
+        llm = ChatOpenAI(model="gpt-4o", max_tokens=50) # Limit tokens as we only want the move
         prompt_messages = [
-            SystemMessage(content="You are a chess analysis assistant. Analyze the provided chess board image."),
+            SystemMessage(content="You are a world-class chess analysis assistant observing a chess game."),
             HumanMessage(content=[
-                {"type": "text", "text": "Describe the chess position shown in this image. Output *only* the Forsyth-Edwards Notation (FEN) string for this position, including side to move, castling rights, en passant target square, halfmove clock, and fullmove number. Assume standard algebraic notation rules (e.g., White pieces on ranks 1 & 2 initially). Determine the board orientation if possible, assuming the image shows the board from White's perspective unless clearly indicated otherwise."},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}} # Specify image type if known (png/jpeg)
+                {
+                    "type": "text",
+                    "text": "Analyze the chess position shown in the image. It is Black's turn to move. Determine the single best move for Black that guarantees a win. Respond with *only* the Standard Algebraic Notation (SAN) for this move (e.g., 'Qh4#', 'Nf3+', 'Rxe5'). Do not include *any* other text, explanation, or commentary."
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        # Specify mime type if known, otherwise OpenAI often infers
+                        "url": f"data:image/png;base64,{base64_image}"
+                        }
+                }
             ])
         ]
-        response = llm.invoke(prompt_messages)
-        fen_string = response.content.strip().replace('`', '') # Remove potential backticks
-        logging.info(f"Extracted FEN (raw): '{fen_string}'")
-
-        # Clean up FEN string - needs robust parsing
-        # Regex to capture full FEN: board turn castling enpassant halfmove fullmove
-        fen_match = re.search(r'([rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+\/[rnbqkpRNBQKP1-8]+)\s+([wb])\s+([-KQkq]+|\-)\s+([-a-h1-8]+|\-)\s+(\d+)\s+(\d+)', fen_string)
-        if not fen_match:
-             # Try simpler regex if full match fails (might miss some parts)
-             fen_match_simple = re.search(r'([rnbqkpRNBQKP1-8\/]+)\s+([wb])', fen_string)
-             if fen_match_simple:
-                 board_part = fen_match_simple.group(1)
-                 turn_part = fen_match_simple.group(2)
-                 if board_part.count('/') == 7:
-                     # Construct a potentially valid FEN, assuming standard defaults
-                     # Crucially, the question states it IS Black's turn.
-                     fen_string = f"{board_part} b - - 0 1"
-                     logging.warning(f"Could only partially parse FEN, assuming defaults and forcing Black's turn: '{fen_string}'")
-                 else:
-                      logging.error(f"Failed to parse FEN: Board part invalid in '{fen_string}'.")
-                      return "ERROR: Could not accurately determine the FEN string from the image (invalid board)."
-             else:
-                 logging.error(f"Failed to parse FEN from image description: '{fen_string}'")
-                 return "ERROR: Could not determine the FEN string from the image."
-        else:
-            fen_string = fen_match.group(0).strip() # Reconstruct matched FEN
-            logging.info(f"Successfully parsed FEN: '{fen_string}'")
-
-        # 3. Validate FEN and ensure it's Black's turn ('b')
-        try:
-            # Validate before potentially modifying turn
-            board_initial_check = chess.Board(fen_string)
-            fen_parts = fen_string.split(' ')
-             # Force turn to black as per question requirement
-            if fen_parts[1] != 'b':
-                 logging.warning(f"FEN indicated '{fen_parts[1]}' turn, but question states Black's turn. Forcing turn to Black.")
-                 fen_parts[1] = 'b'
-                 # Clear en passant if it was White's turn (as en passant is only valid immediately after pawn move)
-                 fen_parts[3] = '-'
-                 corrected_fen = ' '.join(fen_parts)
-                 board = chess.Board(corrected_fen)
-                 logging.info(f"Corrected FEN for Black's turn: {board.fen()}")
-            else:
-                 board = board_initial_check # Use originally parsed board if turn was already black
-
-        except ValueError as e:
-            logging.error(f"Invalid FEN generated or parsed: '{fen_string}'. Error: {e}")
-            # Try to see if the board part alone is valid
-            try:
-                 board_part_only = fen_string.split(' ')[0]
-                 if board_part_only.count('/') == 7:
-                     test_board = chess.Board(f"{board_part_only} b - - 0 1")
-                     logging.warning(f"Original FEN invalid, using board part only and forcing Black's turn: {test_board.fen()}")
-                     board = test_board
-                 else:
-                      return f"ERROR: Invalid FEN string derived from image: {fen_string}"
-            except Exception:
-                 return f"ERROR: Invalid FEN string derived from image: {fen_string}"
-
-
-        # 4. Use Stockfish engine to find the winning move
-        logging.info(f"Analyzing FEN with Stockfish: {board.fen()}")
-        engine = None # Initialize engine variable
-        try:
-            # Make sure the STOCKFISH_PATH environment variable is set correctly,
-            # or the stockfish executable is in the system's PATH.
-            engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
-
-            # Analyze the position - search for a guaranteed win (mate).
-            # Set a reasonable time limit. Increase depth maybe?
-            # Let's try searching for mate specifically first.
-            # info = engine.analyse(board, chess.engine.Limit(time=5.0, depth=20), multipv=1) # Deeper search
-            analysis_result = engine.play(board, chess.engine.Limit(time=5.0, mate=1)) # Search specifically for mate in 1 first
-
-            if analysis_result.move is None or not board.is_legal(analysis_result.move):
-                 # If no immediate mate, do a deeper search for best move
-                 logging.info("No immediate mate found, performing deeper search...")
-                 info = engine.analyse(board, chess.engine.Limit(time=5.0, depth=18), multipv=1) # Allow more time/depth
-                 best_move = info[0].get('pv', [None])[0] if info else None
-                 score = info[0].get('score') if info else None
-            else:
-                 # Mate in 1 found
-                 best_move = analysis_result.move
-                 score = chess.engine.Mate(1) # Represent as mate score
-
-
-            if best_move is None:
-                 logging.error("Stockfish analysis did not return a best move.")
-                 return "ERROR: Chess engine analysis failed to find a move."
-
-            # Check score for confirmation of "guaranteed win"
-            is_win_confirmed = False
-            if score is not None:
-                 pov_score = score.pov(chess.BLACK) # Score from Black's perspective
-                 if pov_score.is_mate():
-                     logging.info(f"Found winning mate ({pov_score.mate()}) for Black: {board.san(best_move)}")
-                     is_win_confirmed = True
-                 elif pov_score.score(mate_score=10000) is not None and pov_score.score(mate_score=10000) > 1000: # High centipawn advantage
-                     logging.info(f"Found large advantage ({pov_score.score()} cp) for Black: {board.san(best_move)}")
-                     is_win_confirmed = True
-                 else:
-                     logging.warning(f"Stockfish analysis score ({score}) does not guarantee a win, but returning best move found.")
-            else:
-                 logging.warning("Stockfish analysis did not provide a score. Returning best move found.")
-
-            # Return the best move found in SAN format
-            san_move = board.san(best_move)
-            logging.info(f"Best move found for Black: {san_move}")
-            return san_move
 
-        except FileNotFoundError:
-             logging.error(f"Stockfish engine not found at '{STOCKFISH_PATH}'. Please install Stockfish or set the STOCKFISH_PATH environment variable.")
-             return f"ERROR: Stockfish engine not found at '{STOCKFISH_PATH}'"
-        except chess.engine.EngineTerminatedError:
-             logging.error("Chess engine terminated unexpectedly.")
-             return "ERROR: Chess engine terminated unexpectedly."
-        except Exception as e:
-            logging.error(f"Error during chess engine analysis: {e}")
-            if board and board.is_variant_end():
-                 logging.warning(f"Position is already game over: {board.result()}")
-                 return f"ERROR: Position is already game over ({board.result()}). No move possible."
-            if board and not board.is_legal(best_move) and best_move is not None:
-                 logging.error(f"Engine suggested an illegal move: {best_move}")
-                 return "ERROR: Chess engine suggested an illegal move."
-            # Check if the error indicates an illegal position from chess library
-            if "invalid fen" in str(e).lower() or "illegal position" in str(e).lower():
-                 return f"ERROR: The derived FEN represents an illegal position: {board.fen() if board else fen_string}"
-            return f"ERROR: Could not analyze chess position with engine. Details: {str(e)}"
-        finally:
-             if engine:
-                  engine.quit()
+        logging.info("Sending chess image analysis request to GPT-4o...")
+        response = llm.invoke(prompt_messages)
+        move_san = response.content.strip()
+
+        # Basic validation: Check if the response is short and doesn't contain spaces
+        # (very crude check, as SAN can have checks/mates like '#', '+')
+        # A more robust check would involve trying to parse with a chess library,
+        # but we removed that dependency.
+        if not move_san:
+             logging.error("GPT-4o returned an empty response for chess analysis.")
+             return "ERROR: LLM analysis returned no move."
+        if ' ' in move_san or len(move_san) > 7: # Arbitrary length limit for typical SAN
+             logging.warning(f"GPT-4o chess response ('{move_san}') seems unusual (contains spaces or is long). Returning it as is, but it might be incorrect/include extra text.")
+             # Attempt to extract just the first 'word' if there are spaces
+             potential_move = move_san.split()[0]
+             # Further check if it contains only valid SAN characters? Maybe too complex.
+             # Let's return the potentially cleaned-up first part.
+             move_san = potential_move
+
+
+        logging.info(f"GPT-4o analysis returned potential move: '{move_san}'")
+        return move_san
 
     except Exception as e:
-        logging.error(f"Unexpected error analyzing chess image {file_path}: {e}")
-        return f"ERROR: Unexpected error processing chess image. Details: {str(e)}"
+        logging.error(f"Unexpected error analyzing chess image {file_path} with GPT-4o: {e}", exc_info=True)
+        return f"ERROR: Unexpected error processing chess image with LLM. Details: {str(e)}"
 
 
 def analyze_video_birds(file_path: str) -> str: