slashvibe-mcp 0.2.8 → 0.3.13

package/games/chess.js

@@ -0,0 +1,451 @@
+/**
+ * Chess game implementation for /vibe
+ * Supports standard chess rules with algebraic notation
+ */
+
+// Chess piece values for basic evaluation
+const PIECE_VALUES = {
+  'P': 1, 'N': 3, 'B': 3, 'R': 5, 'Q': 9, 'K': 0,
+  'p': -1, 'n': -3, 'b': -3, 'r': -5, 'q': -9, 'k': 0
+};
+
+// Initial chess board setup
+const INITIAL_BOARD = [
+  ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
+  ['p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'],
+  ['', '', '', '', '', '', '', ''],
+  ['', '', '', '', '', '', '', ''],
+  ['', '', '', '', '', '', '', ''],
+  ['', '', '', '', '', '', '', ''],
+  ['P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'],
+  ['R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R']
+];
+
+// Convert file letters to indices
+function fileToIndex(file) {
+  return file.charCodeAt(0) - 97; // 'a' = 0, 'b' = 1, etc.
+}
+
+function indexToFile(index) {
+  return String.fromCharCode(97 + index);
+}
+
+// Convert rank numbers to indices (rank 1 = index 7, rank 8 = index 0)
+function rankToIndex(rank) {
+  return 8 - parseInt(rank);
+}
+
+function indexToRank(index) {
+  return (8 - index).toString();
+}
+
+// Parse algebraic notation to board coordinates
+function parseAlgebraicNotation(notation, board, isWhiteTurn) {
+  // Remove check/checkmate indicators
+  const move = notation.replace(/[+#]$/, '');
+  
+  // Handle castling
+  if (move === 'O-O' || move === '0-0') {
+    return isWhiteTurn ? 
+      { from: [7, 4], to: [7, 6], type: 'castle-short' } :
+      { from: [0, 4], to: [0, 6], type: 'castle-short' };
+  }
+  if (move === 'O-O-O' || move === '0-0-0') {
+    return isWhiteTurn ? 
+      { from: [7, 4], to: [7, 2], type: 'castle-long' } :
+      { from: [0, 4], to: [0, 2], type: 'castle-long' };
+  }
+
+  // Handle pawn moves (no piece letter)
+  if (/^[a-h][1-8]$/.test(move)) {
+    // Simple pawn move like e4
+    const toFile = fileToIndex(move[0]);
+    const toRank = rankToIndex(move[1]);
+    const fromRank = isWhiteTurn ? toRank + 1 : toRank - 1;
+    
+    // Check if it's a valid pawn move
+    if (fromRank >= 0 && fromRank < 8 && board[fromRank][toFile] === (isWhiteTurn ? 'P' : 'p')) {
+      return { from: [fromRank, toFile], to: [toRank, toFile], type: 'move' };
+    }
+    
+    // Check for double pawn move
+    const doubleFromRank = isWhiteTurn ? 6 : 1;
+    if (board[doubleFromRank][toFile] === (isWhiteTurn ? 'P' : 'p') && board[toRank][toFile] === '') {
+      return { from: [doubleFromRank, toFile], to: [toRank, toFile], type: 'move' };
+    }
+  }
+
+  // Handle pawn captures like exd5
+  if (/^[a-h]x[a-h][1-8]$/.test(move)) {
+    const fromFile = fileToIndex(move[0]);
+    const toFile = fileToIndex(move[2]);
+    const toRank = rankToIndex(move[3]);
+    const fromRank = isWhiteTurn ? toRank + 1 : toRank - 1;
+    
+    if (fromRank >= 0 && fromRank < 8 && board[fromRank][fromFile] === (isWhiteTurn ? 'P' : 'p')) {
+      return { from: [fromRank, fromFile], to: [toRank, toFile], type: 'capture' };
+    }
+  }
+
+  // Handle piece moves like Nf3, Bb5, etc.
+  const pieceMatch = move.match(/^([NBRQK])([a-h]?[1-8]?)(x?)([a-h][1-8])$/);
+  if (pieceMatch) {
+    const piece = isWhiteTurn ? pieceMatch[1] : pieceMatch[1].toLowerCase();
+    const disambiguator = pieceMatch[2];
+    const isCapture = pieceMatch[3] === 'x';
+    const toSquare = pieceMatch[4];
+    const toFile = fileToIndex(toSquare[0]);
+    const toRank = rankToIndex(toSquare[1]);
+
+    // Find the piece that can make this move
+    const possibleMoves = findPieceLocations(board, piece);
+    const validFromSquares = possibleMoves.filter(([fromRank, fromFile]) => {
+      return canPieceMove(board, piece, fromRank, fromFile, toRank, toFile);
+    });
+
+    // Apply disambiguator if provided
+    if (disambiguator) {
+      if (/[a-h]/.test(disambiguator)) {
+        const disambiguatorFile = fileToIndex(disambiguator);
+        return validFromSquares.find(([r, f]) => f === disambiguatorFile);
+      } else if (/[1-8]/.test(disambiguator)) {
+        const disambiguatorRank = rankToIndex(disambiguator);
+        return validFromSquares.find(([r, f]) => r === disambiguatorRank);
+      }
+    }
+
+    if (validFromSquares.length === 1) {
+      return { 
+        from: validFromSquares[0], 
+        to: [toRank, toFile], 
+        type: isCapture ? 'capture' : 'move' 
+      };
+    }
+  }
+
+  return null; // Invalid notation
+}
+
+// Find all locations of a specific piece on the board
+function findPieceLocations(board, piece) {
+  const locations = [];
+  for (let rank = 0; rank < 8; rank++) {
+    for (let file = 0; file < 8; file++) {
+      if (board[rank][file] === piece) {
+        locations.push([rank, file]);
+      }
+    }
+  }
+  return locations;
+}
+
+// Check if a piece can legally move from one square to another
+function canPieceMove(board, piece, fromRank, fromFile, toRank, toFile) {
+  const pieceType = piece.toLowerCase();
+  const dx = toFile - fromFile;
+  const dy = toRank - fromRank;
+
+  switch (pieceType) {
+    case 'p': // Pawn
+      const direction = piece === 'P' ? -1 : 1;
+      const startRank = piece === 'P' ? 6 : 1;
+      
+      // Forward move
+      if (dx === 0) {
+        if (dy === direction && board[toRank][toFile] === '') return true;
+        if (fromRank === startRank && dy === 2 * direction && board[toRank][toFile] === '') return true;
+      }
+      // Capture
+      if (Math.abs(dx) === 1 && dy === direction) {
+        const targetPiece = board[toRank][toFile];
+        return targetPiece !== '' && isOpponentPiece(piece, targetPiece);
+      }
+      return false;
+
+    case 'r': // Rook
+      if (dx === 0 || dy === 0) {
+        return isPathClear(board, fromRank, fromFile, toRank, toFile);
+      }
+      return false;
+
+    case 'n': // Knight
+      return (Math.abs(dx) === 2 && Math.abs(dy) === 1) || 
+             (Math.abs(dx) === 1 && Math.abs(dy) === 2);
+
+    case 'b': // Bishop
+      if (Math.abs(dx) === Math.abs(dy)) {
+        return isPathClear(board, fromRank, fromFile, toRank, toFile);
+      }
+      return false;
+
+    case 'q': // Queen
+      if (dx === 0 || dy === 0 || Math.abs(dx) === Math.abs(dy)) {
+        return isPathClear(board, fromRank, fromFile, toRank, toFile);
+      }
+      return false;
+
+    case 'k': // King
+      return Math.abs(dx) <= 1 && Math.abs(dy) <= 1;
+
+    default:
+      return false;
+  }
+}
+
+// Check if path between two squares is clear
+function isPathClear(board, fromRank, fromFile, toRank, toFile) {
+  const dx = toFile - fromFile;
+  const dy = toRank - fromRank;
+  const steps = Math.max(Math.abs(dx), Math.abs(dy));
+  
+  const stepX = dx === 0 ? 0 : dx / Math.abs(dx);
+  const stepY = dy === 0 ? 0 : dy / Math.abs(dy);
+
+  for (let i = 1; i < steps; i++) {
+    const checkRank = fromRank + stepY * i;
+    const checkFile = fromFile + stepX * i;
+    if (board[checkRank][checkFile] !== '') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Check if two pieces are opponents
+function isOpponentPiece(piece1, piece2) {
+  return (piece1 >= 'A' && piece1 <= 'Z') !== (piece2 >= 'A' && piece2 <= 'Z');
+}
+
+// Check if a piece is white
+function isWhitePiece(piece) {
+  return piece >= 'A' && piece <= 'Z';
+}
+
+// Find king position
+function findKing(board, isWhite) {
+  const king = isWhite ? 'K' : 'k';
+  for (let rank = 0; rank < 8; rank++) {
+    for (let file = 0; file < 8; file++) {
+      if (board[rank][file] === king) {
+        return [rank, file];
+      }
+    }
+  }
+  return null;
+}
+
+// Check if a square is attacked by opponent
+function isSquareAttacked(board, rank, file, byWhite) {
+  // Check all opponent pieces
+  for (let r = 0; r < 8; r++) {
+    for (let f = 0; f < 8; f++) {
+      const piece = board[r][f];
+      if (!piece) continue;
+      if (isWhitePiece(piece) !== byWhite) continue;
+
+      // Check if this piece can attack the target square
+      if (canPieceMove(board, piece, r, f, rank, file)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Check if king is in check
+function isKingInCheck(board, isWhiteKing) {
+  const kingPos = findKing(board, isWhiteKing);
+  if (!kingPos) return false;
+  return isSquareAttacked(board, kingPos[0], kingPos[1], !isWhiteKing);
+}
+
+// Get all legal moves for a player
+function getAllLegalMoves(board, isWhiteTurn) {
+  const moves = [];
+
+  for (let fromRank = 0; fromRank < 8; fromRank++) {
+    for (let fromFile = 0; fromFile < 8; fromFile++) {
+      const piece = board[fromRank][fromFile];
+      if (!piece) continue;
+      if (isWhitePiece(piece) !== isWhiteTurn) continue;
+
+      // Try all possible destination squares
+      for (let toRank = 0; toRank < 8; toRank++) {
+        for (let toFile = 0; toFile < 8; toFile++) {
+          if (fromRank === toRank && fromFile === toFile) continue;
+
+          // Check if piece can move there
+          if (!canPieceMove(board, piece, fromRank, fromFile, toRank, toFile)) continue;
+
+          // Check if destination has own piece
+          const destPiece = board[toRank][toFile];
+          if (destPiece && isWhitePiece(destPiece) === isWhiteTurn) continue;
+
+          // Simulate move and check if king is still in check
+          const testBoard = board.map(row => [...row]);
+          testBoard[toRank][toFile] = piece;
+          testBoard[fromRank][fromFile] = '';
+
+          if (!isKingInCheck(testBoard, isWhiteTurn)) {
+            moves.push({
+              from: [fromRank, fromFile],
+              to: [toRank, toFile],
+              piece
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return moves;
+}
+
+// Check for checkmate or stalemate
+function getGameEndState(board, isWhiteTurn) {
+  const legalMoves = getAllLegalMoves(board, isWhiteTurn);
+  const inCheck = isKingInCheck(board, isWhiteTurn);
+
+  if (legalMoves.length === 0) {
+    if (inCheck) {
+      return { checkmate: true, winner: isWhiteTurn ? 'black' : 'white' };
+    } else {
+      return { stalemate: true };
+    }
+  }
+
+  return { check: inCheck };
+}
+
+// Convert move to algebraic notation
+function moveToAlgebraicNotation(board, move) {
+  const { from, to, piece } = move;
+  const [fromRank, fromFile] = from;
+  const [toRank, toFile] = to;
+  
+  const toSquare = indexToFile(toFile) + indexToRank(toRank);
+  const isCapture = board[toRank][toFile] !== '';
+  
+  if (piece.toLowerCase() === 'p') {
+    if (isCapture) {
+      return indexToFile(fromFile) + 'x' + toSquare;
+    } else {
+      return toSquare;
+    }
+  } else {
+    const pieceSymbol = piece.toUpperCase();
+    const captureSymbol = isCapture ? 'x' : '';
+    return pieceSymbol + captureSymbol + toSquare;
+  }
+}
+
+// Create initial chess state
+function createInitialChessState() {
+  return {
+    board: INITIAL_BOARD.map(row => [...row]),
+    turn: 'white',
+    moves: 0,
+    history: [],
+    check: false,
+    checkmate: false,
+    stalemate: false,
+    winner: null
+  };
+}
+
+// Format chess board for display
+function formatChessBoard(board, lastMove = null) {
+  const files = '  a b c d e f g h';
+  let display = '```\n' + files + '\n';
+  
+  for (let rank = 0; rank < 8; rank++) {
+    let row = (8 - rank) + ' ';
+    for (let file = 0; file < 8; file++) {
+      const piece = board[rank][file];
+      const symbol = piece || (rank + file) % 2 === 0 ? '·' : ' ';
+      row += symbol + ' ';
+    }
+    row += (8 - rank);
+    display += row + '\n';
+  }
+  
+  display += files + '\n```';
+  return display;
+}
+
+// Make a move on the chess board
+function makeMove(gameState, moveNotation) {
+  const { board, turn, moves, history } = gameState;
+  const isWhiteTurn = turn === 'white';
+  
+  const parsedMove = parseAlgebraicNotation(moveNotation, board, isWhiteTurn);
+  if (!parsedMove) {
+    return { error: 'Invalid move notation' };
+  }
+
+  const { from, to, type } = parsedMove;
+  const [fromRank, fromFile] = from;
+  const [toRank, toFile] = to;
+  
+  // Get the piece being moved
+  const piece = board[fromRank][fromFile];
+  if (!piece) {
+    return { error: 'No piece at source square' };
+  }
+
+  // Check if it's the correct player's piece
+  const isPieceWhite = piece >= 'A' && piece <= 'Z';
+  if (isPieceWhite !== isWhiteTurn) {
+    return { error: 'Not your piece' };
+  }
+
+  // Create new board state
+  const newBoard = board.map(row => [...row]);
+  newBoard[fromRank][fromFile] = '';
+  newBoard[toRank][toFile] = piece;
+
+  // Handle castling
+  if (type === 'castle-short') {
+    const rookFromFile = 7;
+    const rookToFile = 5;
+    const rankIndex = isWhiteTurn ? 7 : 0;
+    newBoard[rankIndex][rookFromFile] = '';
+    newBoard[rankIndex][rookToFile] = isWhiteTurn ? 'R' : 'r';
+  } else if (type === 'castle-long') {
+    const rookFromFile = 0;
+    const rookToFile = 3;
+    const rankIndex = isWhiteTurn ? 7 : 0;
+    newBoard[rankIndex][rookFromFile] = '';
+    newBoard[rankIndex][rookToFile] = isWhiteTurn ? 'R' : 'r';
+  }
+
+  // Check game end state for opponent
+  const nextPlayerIsWhite = !isWhiteTurn;
+  const endState = getGameEndState(newBoard, nextPlayerIsWhite);
+
+  const newGameState = {
+    board: newBoard,
+    turn: isWhiteTurn ? 'black' : 'white',
+    moves: moves + 1,
+    history: [...history, moveNotation],
+    check: endState.check || false,
+    checkmate: endState.checkmate || false,
+    stalemate: endState.stalemate || false,
+    winner: endState.winner || null,
+    lastMove: { from, to, notation: moveNotation }
+  };
+
+  return { success: true, gameState: newGameState };
+}
+
+module.exports = {
+  createInitialChessState,
+  makeMove,
+  formatChessBoard,
+  parseAlgebraicNotation,
+  moveToAlgebraicNotation,
+  isKingInCheck,
+  getAllLegalMoves,
+  getGameEndState
+};