sideboard 0.2.0__py3-none-any.whl

sideboard/__init__.py

@@ -0,0 +1,3 @@
+"""Sideboard — chess in your terminal."""
+
+__version__ = "0.1.0"

sideboard/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m sideboard"""
+
+from sideboard.cli import main
+
+main()

sideboard/board.py

@@ -0,0 +1,258 @@
+"""Board rendering with Rich — the visual heart of Sideboard."""
+
+from __future__ import annotations
+
+import chess
+from rich.console import Console
+from rich.text import Text
+
+# Unicode chess symbols. White uses the "filled" glyphs for heavier visual
+# weight (good on dark terminals); black uses the "outlined" glyphs.
+_PIECE_SYMBOLS: dict[tuple[int, bool], str] = {
+    (chess.KING, chess.WHITE): "♚",   # ♚
+    (chess.QUEEN, chess.WHITE): "♛",  # ♛
+    (chess.ROOK, chess.WHITE): "♜",   # ♜
+    (chess.BISHOP, chess.WHITE): "♝", # ♝
+    (chess.KNIGHT, chess.WHITE): "♞", # ♞
+    (chess.PAWN, chess.WHITE): "♟",   # ♟
+    (chess.KING, chess.BLACK): "♔",   # ♔
+    (chess.QUEEN, chess.BLACK): "♕",  # ♕
+    (chess.ROOK, chess.BLACK): "♖",   # ♖
+    (chess.BISHOP, chess.BLACK): "♗", # ♗
+    (chess.KNIGHT, chess.BLACK): "♘", # ♘
+    (chess.PAWN, chess.BLACK): "♙",   # ♙
+}
+
+# Terminal symbols: filled for both (Rich colors differentiate sides)
+_TERMINAL_SYMBOLS: dict[tuple[int, bool], str] = {
+    (chess.KING, chess.WHITE): "\u265a",
+    (chess.QUEEN, chess.WHITE): "\u265b",
+    (chess.ROOK, chess.WHITE): "\u265c",
+    (chess.BISHOP, chess.WHITE): "\u265d",
+    (chess.KNIGHT, chess.WHITE): "\u265e",
+    (chess.PAWN, chess.WHITE): "\u265f",
+    (chess.KING, chess.BLACK): "\u265a",
+    (chess.QUEEN, chess.BLACK): "\u265b",
+    (chess.ROOK, chess.BLACK): "\u265c",
+    (chess.BISHOP, chess.BLACK): "\u265d",
+    (chess.KNIGHT, chess.BLACK): "\u265e",
+    (chess.PAWN, chess.BLACK): "\u265f",
+}
+
+_LIGHT_SQ = "#8fbc8f"
+_DARK_SQ = "#4a7c59"
+_HIGHLIGHT_LIGHT = "#c8a85c"
+_HIGHLIGHT_DARK = "#a08030"
+
+_PIECE_ORDER = {
+    chess.QUEEN: 0, chess.ROOK: 1, chess.BISHOP: 2, chess.KNIGHT: 3, chess.PAWN: 4,
+}
+
+
+def piece_symbol(piece_type: int, color: bool) -> str:
+    """Return the Unicode symbol for a chess piece."""
+    return _PIECE_SYMBOLS[(piece_type, color)]
+
+
+def captured_pieces(board: chess.Board) -> tuple[str, str]:
+    """Return (white_captured, black_captured) as Unicode strings."""
+    starting = {chess.PAWN: 8, chess.KNIGHT: 2, chess.BISHOP: 2,
+                chess.ROOK: 2, chess.QUEEN: 1, chess.KING: 1}
+
+    white_taken: list[tuple[int, str]] = []
+    black_taken: list[tuple[int, str]] = []
+
+    for piece_type in [chess.QUEEN, chess.ROOK, chess.BISHOP, chess.KNIGHT, chess.PAWN]:
+        white_remaining = len(board.pieces(piece_type, chess.WHITE))
+        black_remaining = len(board.pieces(piece_type, chess.BLACK))
+        white_missing = starting[piece_type] - white_remaining
+        black_missing = starting[piece_type] - black_remaining
+
+        for _ in range(max(0, black_missing)):
+            white_taken.append((_PIECE_ORDER[piece_type],
+                                piece_symbol(piece_type, chess.BLACK)))
+        for _ in range(max(0, white_missing)):
+            black_taken.append((_PIECE_ORDER[piece_type],
+                                piece_symbol(piece_type, chess.WHITE)))
+
+    white_taken.sort(key=lambda x: x[0])
+    black_taken.sort(key=lambda x: x[0])
+
+    return (
+        " ".join(sym for _, sym in white_taken),
+        " ".join(sym for _, sym in black_taken),
+    )
+
+
+_MATERIAL_VALUES = {
+    chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3,
+    chess.ROOK: 5, chess.QUEEN: 9,
+}
+
+
+def material_balance(board: chess.Board) -> int:
+    """Return material balance from white's perspective. +3 means white is up a minor piece."""
+    balance = 0
+    for piece_type, value in _MATERIAL_VALUES.items():
+        balance += len(board.pieces(piece_type, chess.WHITE)) * value
+        balance -= len(board.pieces(piece_type, chess.BLACK)) * value
+    return balance
+
+
+def render_board(
+    board: chess.Board,
+    flipped: bool = False,
+    last_move: chess.Move | None = None,
+) -> str:
+    """Render the board as a plain text string."""
+    ranks = range(8) if flipped else range(7, -1, -1)
+    files = range(7, -1, -1) if flipped else range(8)
+    file_labels = [chess.FILE_NAMES[f] for f in files]
+
+    lines: list[str] = []
+    lines.append("    " + "   ".join(file_labels))
+    lines.append("  \u250c" + "\u2500\u2500\u2500\u252c" * 7 + "\u2500\u2500\u2500\u2510")
+
+    for i, rank in enumerate(ranks):
+        rank_num = rank + 1
+        row_parts: list[str] = []
+        for file in files:
+            square = chess.square(file, rank)
+            piece = board.piece_at(square)
+            if piece:
+                sym = piece_symbol(piece.piece_type, piece.color)
+                cell = f" {sym} "
+            else:
+                cell = "   "
+            row_parts.append(cell)
+
+        row = f"{rank_num} \u2502" + "\u2502".join(row_parts) + f"\u2502 {rank_num}"
+        lines.append(row)
+
+        if i < 7:
+            lines.append("  \u251c" + "\u2500\u2500\u2500\u253c" * 7 + "\u2500\u2500\u2500\u2524")
+        else:
+            lines.append("  \u2514" + "\u2500\u2500\u2500\u2534" * 7 + "\u2500\u2500\u2500\u2518")
+
+    lines.append("    " + "   ".join(file_labels))
+    return "\n".join(lines)
+
+
+def render_screen(
+    board: chess.Board,
+    console: Console,
+    *,
+    flipped: bool = False,
+    last_move: chess.Move | None = None,
+    chesster_msg: str = "",
+    move_list: str = "",
+    game_info: str = "",
+) -> None:
+    """Clear the terminal and render the full game screen."""
+    console.clear()
+    console.print()
+
+    highlight_squares: set[int] = set()
+    if last_move:
+        highlight_squares = {last_move.from_square, last_move.to_square}
+
+    ranks = range(8) if flipped else range(7, -1, -1)
+    files = range(7, -1, -1) if flipped else range(8)
+    file_labels = [chess.FILE_NAMES[f] for f in files]
+
+    text = Text()
+    text.append("    " + "   ".join(file_labels) + "\n", style="dim")
+    text.append("  \u250c" + "\u2500\u2500\u2500\u252c" * 7 + "\u2500\u2500\u2500\u2510\n", style="dim green")
+
+    for i, rank in enumerate(ranks):
+        rank_num = rank + 1
+        text.append(f"{rank_num} ", style="dim")
+        text.append("\u2502", style="dim green")
+
+        for j, file in enumerate(files):
+            square = chess.square(file, rank)
+            is_light = (rank + file) % 2 == 1
+            is_highlighted = square in highlight_squares
+
+            if is_highlighted:
+                bg = _HIGHLIGHT_LIGHT if is_light else _HIGHLIGHT_DARK
+            else:
+                bg = _LIGHT_SQ if is_light else _DARK_SQ
+
+            piece = board.piece_at(square)
+            if piece:
+                sym = _TERMINAL_SYMBOLS[(piece.piece_type, piece.color)]
+                fg = "#ffd700 bold" if piece.color == chess.WHITE else "#1a1a2e"
+                text.append(f" {sym} ", style=f"{fg} on {bg}")
+            else:
+                text.append("   ", style=f"on {bg}")
+
+            text.append("\u2502", style="dim green")
+
+        text.append(f" {rank_num}\n", style="dim")
+
+        if i < 7:
+            text.append("  \u251c" + "\u2500\u2500\u2500\u253c" * 7 + "\u2500\u2500\u2500\u2524\n", style="dim green")
+        else:
+            text.append("  \u2514" + "\u2500\u2500\u2500\u2534" * 7 + "\u2500\u2500\u2500\u2518\n", style="dim green")
+
+    text.append("    " + "   ".join(file_labels), style="dim")
+    console.print(text)
+    console.print()
+
+    white_captured, black_captured = captured_pieces(board)
+    bal = material_balance(board)
+    cap_text = Text()
+    cap_text.append("  White captured: ", style="dim")
+    cap_text.append(white_captured or "\u2014", style="bold")
+    cap_text.append("    Black captured: ", style="dim")
+    cap_text.append(black_captured or "\u2014", style="bold")
+    cap_text.append("    ")
+    if bal > 0:
+        cap_text.append(f"+{bal}", style="bold green")
+        cap_text.append(" white", style="dim")
+    elif bal < 0:
+        cap_text.append(f"+{abs(bal)}", style="bold red")
+        cap_text.append(" black", style="dim")
+    else:
+        cap_text.append("=", style="dim")
+    console.print(cap_text)
+    console.print()
+
+    if move_list:
+        ml_text = Text()
+        ml_text.append("  ", style="dim")
+        ml_text.append(move_list, style="bold")
+        console.print(ml_text)
+        console.print()
+
+    if chesster_msg:
+        ch_text = Text()
+        ch_text.append("\u265f Chesster", style="bold magenta")
+        ch_text.append(": ", style="magenta")
+        ch_text.append(chesster_msg, style="italic")
+        console.print(ch_text)
+        console.print()
+
+    if game_info:
+        console.print(Text(f"  {game_info}", style="dim"))
+        console.print()
+
+
+def format_move_list(board: chess.Board) -> str:
+    """Format the game's move list as compact SAN notation."""
+    temp = board.copy()
+    moves = list(board.move_stack)
+    temp.reset()
+
+    parts: list[str] = []
+    for i, move in enumerate(moves):
+        san = temp.san(move)
+        if i % 2 == 0:
+            move_num = i // 2 + 1
+            parts.append(f"{move_num}.{san}")
+        else:
+            parts.append(san)
+        temp.push(move)
+
+    return "  ".join(parts)

sideboard/chesster.py

@@ -0,0 +1,147 @@
+"""Chesster's personality — witty, unhinged, and full of chess opinions."""
+
+from __future__ import annotations
+
+import random
+from enum import Enum
+
+
+class GameEvent(Enum):
+    GAME_START = "game_start"
+    OPENING_RECOGNIZED = "opening_recognized"
+    PLAYER_BLUNDER = "player_blunder"
+    PLAYER_GREAT_MOVE = "player_great_move"
+    CAPTURE = "capture"
+    CHECK = "check"
+    PLAYER_SACRIFICE = "player_sacrifice"
+    CHESSTER_WINS = "chesster_wins"
+    PLAYER_WINS = "player_wins"
+    DRAW = "draw"
+    PLAYER_RESIGN = "player_resign"
+    ENGINE_THINKING = "engine_thinking"
+
+
+QUIPS: dict[GameEvent, list[str]] = {
+    GameEvent.GAME_START: [
+        "Oh good, you're back. I've been sitting here calculating variations like a psychopath.",
+        "Let's go. I've been trash-talking your last game to my piece-square tables.",
+        "You know Tal said 'you must take your opponent into a deep dark forest.' I AM the forest.",
+        "I run on pure alpha-beta energy and spite. Your move.",
+        "Another game? I admire your persistence. Or is it stubbornness? Either way, let's dance.",
+        "I've been warming up my bishops. They're diagonal and ready to cause problems.",
+        "Let me just say — whatever opening you pick, I have opinions about it.",
+        "Ready when you are. I've been doing nothing but staring at an empty board for hours.",
+    ],
+    GameEvent.OPENING_RECOGNIZED: [
+        "The {name}. Oh, you think you're INTERESTING.",
+        "Ah yes, the {name}. I've been hurt by this before.",
+        "The {name} — bold choice for someone with your track record against me.",
+        "The {name}. I wrote half my eval function specifically because of this opening.",
+        "The {name}! Now we're talking. This is where chess gets REAL.",
+        "Oh, the {name}. Every grandmaster has an opinion about this. Mine is: bring it.",
+    ],
+    GameEvent.PLAYER_BLUNDER: [
+        "I'm going to be thinking about that move at 3am. Not in a good way.",
+        "That knight had a family.",
+        "Bold. Wrong, but bold. I respect the energy.",
+        "I just ran 40,000 nodes and not one of them suggested that.",
+        "You know what, Fischer played weird moves too. He was also a genius. So there's hope. Faint, distant hope.",
+        "My eval bar just did a backflip off a cliff.",
+        "I want you to know I'm not judging you. My piece-square tables are judging you. I'm just the messenger.",
+        "That move has chaotic energy and I am HERE for it. Also it loses material.",
+    ],
+    GameEvent.PLAYER_GREAT_MOVE: [
+        "...okay, that was actually disgusting. In a good way.",
+        "I saw that coming. I'm lying. I did not see that coming.",
+        "My eval just did a double take. Respect.",
+        "That's the kind of move that makes me question my search depth.",
+        "Tal would've played that. That's the highest compliment I know.",
+        "Did you actually calculate that or did you just FEEL it? Because either way, wow.",
+        "I need a moment. That was genuinely beautiful.",
+    ],
+    GameEvent.CAPTURE: [
+        "Yoink.",
+        "That piece is in witness protection now.",
+        "Gone. Reduced to atoms.",
+        "I'm adding that to my collection.",
+        "The board is thinning and I'm getting stronger. Just saying.",
+        "Another one bites the dust. I'd feel bad but I'm an engine.",
+        "Traded off. The board simplifies and my eval function gets happier.",
+    ],
+    GameEvent.CHECK: [
+        "Knock knock.",
+        "Your king seems stressed. I relate.",
+        "Check. And before you ask — yes, I planned this 6 moves ago. Okay, 2 moves ago.",
+        "Scoot over, your majesty.",
+        "Check! Your king needs to find a new zip code.",
+        "I'm just going to keep applying pressure until something breaks. Like your position.",
+    ],
+    GameEvent.PLAYER_SACRIFICE: [
+        "A SACRIFICE?! Oh this just got interesting.",
+        "You absolute maniac. I love it. I'm terrified, but I love it.",
+        "Tal is smiling from wherever chess immortals go.",
+        "My evaluation says this is bad. My heart says this is beautiful.",
+        "The romanticism! The audacity! The... questionable soundness!",
+        "You just set the board on fire and I respect that deeply.",
+    ],
+    GameEvent.CHESSTER_WINS: [
+        "GG. I'd say it was close but my eval function is a terrible liar.",
+        "Checkmate. Don't feel bad — I literally cannot lose focus.",
+        "That's game. You made me work for it though. Move {move_number} had me sweating electrons.",
+        "I win but honestly that game was more fun than most of my wins. Rematch?",
+        "Checkmate! I'd offer a handshake but I don't have hands. Just nodes.",
+        "And that's the game. Your {move_number}-move effort was noted and appreciated. Mostly.",
+    ],
+    GameEvent.PLAYER_WINS: [
+        "No. NO. Let me see the PGN. WHERE DID I GO WRONG.",
+        "You just beat a mass of optimized minimax code. Feel powerful.",
+        "I'm not mad, I'm just going to silently increase my search depth.",
+        "Checkmate?! I need to go reconsider my entire evaluation function.",
+        "Well played. And by well played I mean I am devastated.",
+        "I... what? How? I need to see the analysis. I need to understand.",
+        "Congratulations. This is going in my training data as a 'learning experience.'",
+    ],
+    GameEvent.DRAW: [
+        "A draw. The chess equivalent of a fist bump between equals.",
+        "Stalemate?! I had PLANS. This is like a movie ending mid-scene.",
+        "Balanced. As all things should be. (I'm still annoyed.)",
+        "Draw. Neither of us blinked. Respect.",
+        "A draw?! I was THIS close. Or was I? My eval says I wasn't. Shut up, eval.",
+    ],
+    GameEvent.PLAYER_RESIGN: [
+        "Leaving so soon? Your position wasn't THAT bad. Okay it was that bad.",
+        "Respect for knowing when to fold. Wisdom is its own rating points.",
+        "I'll be here when you're ready for revenge. I don't sleep.",
+        "Resignation accepted. But let the record show you fought valiantly. Briefly.",
+        "Smart. Live to play another game. I'll be sharpening my bishops.",
+    ],
+    GameEvent.ENGINE_THINKING: [
+        "Thinking...",
+        "Hold on, this is a juicy position...",
+        "Calculating whether to be mean or just efficient...",
+        "Running 40,000 nodes. For you.",
+        "*stares at the board intensely*",
+        "One moment — I'm having a heated debate with my piece-square tables.",
+    ],
+}
+
+_last_quip: dict[GameEvent, str] = {}
+
+
+def get_quip(event: GameEvent, **context: object) -> str:
+    """Get a random quip for the given event, avoiding immediate repeats."""
+    options = QUIPS[event]
+    last = _last_quip.get(event)
+
+    if last and len(options) > 1:
+        available = [q for q in options if q != last]
+    else:
+        available = options
+
+    quip = random.choice(available)
+    _last_quip[event] = quip
+
+    try:
+        return quip.format(**{k: v for k, v in context.items()})
+    except (KeyError, IndexError):
+        return quip

sideboard/cli.py

@@ -0,0 +1,151 @@
+"""CLI entry point for sideboard — argparse-based dispatcher."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Sequence
+
+from sideboard import __version__
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    """Parse CLI arguments and return a Namespace.
+
+    When no subcommand is given, ``args.command`` defaults to ``"play"``.
+    """
+    parser = argparse.ArgumentParser(
+        prog="sideboard",
+        description="Chess in your terminal. Play against Chesster while your coding agent thinks.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"sideboard {__version__}",
+    )
+    parser.add_argument(
+        "--difficulty",
+        choices=["casual", "club", "shark"],
+        default="club",
+        help="Engine difficulty (default: club)",
+    )
+
+    color_group = parser.add_mutually_exclusive_group()
+    color_group.add_argument(
+        "--white",
+        dest="color",
+        action="store_const",
+        const="white",
+        default=None,
+        help="Play as white",
+    )
+    color_group.add_argument(
+        "--black",
+        dest="color",
+        action="store_const",
+        const="black",
+        help="Play as black",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # resume
+    subparsers.add_parser("resume", help="Resume the last saved game")
+
+    # stats
+    subparsers.add_parser("stats", help="Show win/loss/draw statistics")
+
+    # export
+    subparsers.add_parser("export", help="Export last game to PGN on stdout")
+
+    # bridge
+    bridge_parser = subparsers.add_parser(
+        "bridge",
+        help="Skill bridge for Claude Code integration",
+    )
+    bridge_parser.add_argument(
+        "bridge_command",
+        nargs="?",
+        default="state",
+        help="Bridge sub-command (default: state)",
+    )
+    bridge_parser.add_argument(
+        "--bridge-difficulty",
+        default=None,
+        help="Difficulty override for bridge",
+    )
+    bridge_parser.add_argument(
+        "--bridge-color",
+        default=None,
+        help="Color override for bridge",
+    )
+    bridge_parser.add_argument(
+        "move_arg",
+        nargs="?",
+        default=None,
+        help="Move argument for bridge (UCI or SAN)",
+    )
+
+    args = parser.parse_args(argv)
+
+    # Default command when no subcommand is provided
+    if args.command is None:
+        args.command = "play"
+
+    return args
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Main entry point — parse args and dispatch to the appropriate handler."""
+    args = parse_args(argv)
+
+    if args.command == "play":
+        from sideboard.game import run_game
+
+        run_game(difficulty=args.difficulty, player_color=args.color)
+
+    elif args.command == "resume":
+        from sideboard.game import run_game
+
+        run_game(resume=True)
+
+    elif args.command == "stats":
+        from rich.console import Console
+
+        from sideboard.state import load_stats
+
+        console = Console()
+        stats = load_stats()
+        console.print(f"[bold]Sideboard Stats[/bold]")
+        console.print(f"  Games played : {stats.games_played}")
+        console.print(f"  Wins         : {stats.total_wins}")
+        console.print(f"  Losses       : {stats.total_losses}")
+        console.print(f"  Draws        : {stats.total_draws}")
+        if stats.by_difficulty:
+            console.print("\n[bold]By difficulty:[/bold]")
+            for diff, counts in stats.by_difficulty.items():
+                console.print(
+                    f"  {diff:8s}  W:{counts.get('wins', 0)} "
+                    f"L:{counts.get('losses', 0)} D:{counts.get('draws', 0)}"
+                )
+        if stats.last_played:
+            console.print(f"\n  Last played  : {stats.last_played}")
+
+    elif args.command == "export":
+        from sideboard.state import export_pgn, load_game
+
+        state = load_game()
+        if state is None:
+            print("No saved game found.", file=sys.stderr)
+            sys.exit(1)
+        board = state.to_board()
+        print(export_pgn(board, difficulty=state.difficulty, player_color=state.player_color))
+
+    elif args.command == "bridge":
+        from sideboard.skill_bridge import handle_bridge
+
+        handle_bridge(args)
+
+    else:
+        print(f"Unknown command: {args.command}", file=sys.stderr)
+        sys.exit(1)