schess 1.0.0

package/src/game/ChessGame.ts

@@ -0,0 +1,81 @@
+import { Chess, type Square, type Move } from 'chess.js';
+import type { PlayerColor, PieceInfo } from './types.js';
+
+export class ChessGame {
+  private chess: Chess;
+
+  constructor(fen?: string) {
+    this.chess = new Chess(fen);
+  }
+
+  getPiece(square: Square): PieceInfo | null {
+    return this.chess.get(square);
+  }
+
+  getValidMoves(square: Square): Square[] {
+    const moves = this.chess.moves({ square, verbose: true });
+    return moves.map((m) => m.to);
+  }
+
+  makeMove(from: Square, to: Square): Move | null {
+    try {
+      return this.chess.move({ from, to, promotion: 'q' }); // Auto-promote to queen
+    } catch {
+      return null;
+    }
+  }
+
+  loadMove(from: Square, to: Square): boolean {
+    try {
+      this.chess.move({ from, to, promotion: 'q' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getCurrentTurn(): PlayerColor {
+    return this.chess.turn();
+  }
+
+  isCheck(): boolean {
+    return this.chess.isCheck();
+  }
+
+  isCheckmate(): boolean {
+    return this.chess.isCheckmate();
+  }
+
+  isStalemate(): boolean {
+    return this.chess.isStalemate();
+  }
+
+  isDraw(): boolean {
+    return this.chess.isDraw();
+  }
+
+  isGameOver(): boolean {
+    return this.chess.isGameOver();
+  }
+
+  getGameOverReason(): string | null {
+    if (this.isCheckmate()) return 'Checkmate';
+    if (this.isStalemate()) return 'Stalemate';
+    if (this.chess.isThreefoldRepetition()) return 'Draw by repetition';
+    if (this.chess.isInsufficientMaterial()) return 'Draw by insufficient material';
+    if (this.chess.isDraw()) return 'Draw';
+    return null;
+  }
+
+  getFen(): string {
+    return this.chess.fen();
+  }
+
+  loadFen(fen: string): void {
+    this.chess.load(fen);
+  }
+
+  reset(): void {
+    this.chess.reset();
+  }
+}

package/src/game/constants.ts

@@ -0,0 +1,39 @@
+// Unicode chess pieces
+export const PIECES = {
+  w: {
+    k: '♔',
+    q: '♕',
+    r: '♖',
+    b: '♗',
+    n: '♘',
+    p: '♙',
+  },
+  b: {
+    k: '♚',
+    q: '♛',
+    r: '♜',
+    b: '♝',
+    n: '♞',
+    p: '♟',
+  },
+} as const;
+
+export const FILES = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] as const;
+export const RANKS = ['8', '7', '6', '5', '4', '3', '2', '1'] as const;
+
+// Board drawing characters
+export const BOARD_CHARS = {
+  topLeft: '╔',
+  topRight: '╗',
+  bottomLeft: '╚',
+  bottomRight: '╝',
+  horizontal: '═',
+  vertical: '║',
+  topT: '╤',
+  bottomT: '╧',
+  leftT: '╟',
+  rightT: '╢',
+  cross: '┼',
+  innerHorizontal: '───',
+  innerVertical: '│',
+} as const;

package/src/game/types.ts

@@ -0,0 +1,26 @@
+import type { Chess, Square, Move, Color, PieceSymbol } from 'chess.js';
+
+export type PlayerColor = 'w' | 'b';
+
+export interface Position {
+  row: number; // 0-7 (0 = rank 8, 7 = rank 1)
+  col: number; // 0-7 (0 = file a, 7 = file h)
+}
+
+export interface GameState {
+  cursor: Position;
+  selectedSquare: Square | null;
+  validMoves: Square[];
+  lastMove: { from: Square; to: Square } | null;
+  isMyTurn: boolean;
+  playerColor: PlayerColor;
+  gameOver: boolean;
+  gameOverReason: string | null;
+}
+
+export interface PieceInfo {
+  type: PieceSymbol;
+  color: Color;
+}
+
+export type { Chess, Square, Move, Color, PieceSymbol };

package/src/index.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { joinCommand } from './commands/join.js';
+
+const program = new Command();
+
+program
+  .name('schess')
+  .description('CLI Chess game over LAN')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Host a new chess game')
+  .action(async () => {
+    await initCommand();
+  });
+
+program
+  .command('join <address>')
+  .description('Join a chess game (e.g., schess join 192.168.1.100:12345)')
+  .action(async (address: string) => {
+    await joinCommand(address);
+  });
+
+program.parse();

package/src/network/Client.ts

@@ -0,0 +1,112 @@
+import WebSocket from 'ws';
+import chalk from 'chalk';
+import ora from 'ora';
+import { serializeMessage, parseMessage, type GameMessage } from './Protocol.js';
+import { GameScreen } from '../ui/GameScreen.js';
+import type { Square, PlayerColor } from '../game/types.js';
+
+export async function connectToServer(address: string): Promise<void> {
+  // Parse address
+  const [host, portStr] = address.split(':');
+  if (!host || !portStr) {
+    console.error(chalk.red('Invalid address format. Use: schess join <ip:port>'));
+    process.exit(1);
+  }
+
+  const port = parseInt(portStr, 10);
+  if (isNaN(port)) {
+    console.error(chalk.red('Invalid port number'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold.cyan('\n  ♔ SCHESS - Chess over LAN ♚\n'));
+
+  const spinner = ora(`Connecting to ${host}:${port}...`).start();
+
+  const ws = new WebSocket(`ws://${host}:${port}`);
+  let gameScreen: GameScreen | null = null;
+
+  ws.on('open', () => {
+    spinner.succeed('Connected to game!');
+    ws.send(serializeMessage({ type: 'join' }));
+  });
+
+  ws.on('message', (data) => {
+    const msg = parseMessage(data.toString());
+    if (!msg) return;
+
+    handleMessage(msg);
+  });
+
+  ws.on('close', () => {
+    if (gameScreen) {
+      gameScreen.opponentResigned();
+      setTimeout(() => {
+        cleanup();
+        process.exit(0);
+      }, 3000);
+    } else {
+      spinner.fail('Disconnected from server');
+      process.exit(1);
+    }
+  });
+
+  ws.on('error', (err) => {
+    spinner.fail(`Connection failed: ${err.message}`);
+    process.exit(1);
+  });
+
+  function handleMessage(msg: GameMessage): void {
+    switch (msg.type) {
+      case 'start': {
+        const color: PlayerColor = msg.color;
+        console.log(chalk.green(`  You are playing as ${color === 'w' ? 'White' : 'Black'}.\n`));
+
+        gameScreen = new GameScreen(color, {
+          onMove: (from: Square, to: Square) => {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(serializeMessage({ type: 'move', from, to }));
+            }
+          },
+          onResign: () => {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(serializeMessage({ type: 'resign' }));
+            }
+            cleanup();
+          },
+        });
+
+        setTimeout(() => {
+          gameScreen?.start();
+        }, 500);
+        break;
+      }
+      case 'move':
+        gameScreen?.receiveMove(msg.from, msg.to);
+        break;
+      case 'resign':
+        gameScreen?.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3000);
+        break;
+      case 'error':
+        console.error(chalk.red(`Server error: ${msg.message}`));
+        cleanup();
+        process.exit(1);
+        break;
+    }
+  }
+
+  function cleanup(): void {
+    gameScreen?.stop();
+    ws.close();
+  }
+
+  // Handle process termination
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(0);
+  });
+}

package/src/network/NetworkUtils.ts

@@ -0,0 +1,24 @@
+import { networkInterfaces } from 'os';
+
+export function getLanIp(): string | null {
+  const interfaces = networkInterfaces();
+
+  for (const name of Object.keys(interfaces)) {
+    const nets = interfaces[name];
+    if (!nets) continue;
+
+    for (const net of nets) {
+      // Skip internal (loopback) and non-IPv4 addresses
+      if (net.family === 'IPv4' && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function getRandomPort(): number {
+  // Random port between 10000-60000
+  return Math.floor(Math.random() * 50000) + 10000;
+}

package/src/network/Protocol.ts

@@ -0,0 +1,41 @@
+import type { Square } from '../game/types.js';
+
+export type MessageType = 'join' | 'start' | 'move' | 'resign' | 'error';
+
+export interface JoinMessage {
+  type: 'join';
+}
+
+export interface StartMessage {
+  type: 'start';
+  color: 'w' | 'b';
+}
+
+export interface MoveMessage {
+  type: 'move';
+  from: Square;
+  to: Square;
+}
+
+export interface ResignMessage {
+  type: 'resign';
+}
+
+export interface ErrorMessage {
+  type: 'error';
+  message: string;
+}
+
+export type GameMessage = JoinMessage | StartMessage | MoveMessage | ResignMessage | ErrorMessage;
+
+export function serializeMessage(msg: GameMessage): string {
+  return JSON.stringify(msg);
+}
+
+export function parseMessage(data: string): GameMessage | null {
+  try {
+    return JSON.parse(data) as GameMessage;
+  } catch {
+    return null;
+  }
+}

package/src/network/Server.ts

@@ -0,0 +1,104 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getLanIp, getRandomPort } from './NetworkUtils.js';
+import { serializeMessage, parseMessage, type GameMessage } from './Protocol.js';
+import { GameScreen } from '../ui/GameScreen.js';
+import type { Square } from '../game/types.js';
+
+export async function startServer(): Promise<void> {
+  const port = getRandomPort();
+  const ip = getLanIp() || 'localhost';
+
+  const wss = new WebSocketServer({ port });
+  let opponent: WebSocket | null = null;
+  let gameScreen: GameScreen | null = null;
+
+  console.log(chalk.bold.cyan('\n  ♔ SCHESS - Chess over LAN ♚\n'));
+  console.log(chalk.green('  Game created! You are playing as White.\n'));
+  console.log(chalk.white('  Share this command with your opponent:\n'));
+  console.log(chalk.yellow.bold(`    schess join ${ip}:${port}\n`));
+
+  const spinner = ora('Waiting for opponent to join...').start();
+
+  wss.on('connection', (ws) => {
+    if (opponent) {
+      ws.send(serializeMessage({ type: 'error', message: 'Game is full' }));
+      ws.close();
+      return;
+    }
+
+    opponent = ws;
+    spinner.succeed('Opponent connected!');
+
+    // Send start message - opponent plays as Black
+    ws.send(serializeMessage({ type: 'start', color: 'b' }));
+
+    // Create game screen
+    gameScreen = new GameScreen('w', {
+      onMove: (from: Square, to: Square) => {
+        if (opponent && opponent.readyState === WebSocket.OPEN) {
+          opponent.send(serializeMessage({ type: 'move', from, to }));
+        }
+      },
+      onResign: () => {
+        if (opponent && opponent.readyState === WebSocket.OPEN) {
+          opponent.send(serializeMessage({ type: 'resign' }));
+        }
+        cleanup();
+      },
+    });
+
+    // Start the game
+    setTimeout(() => {
+      gameScreen?.start();
+    }, 500);
+
+    ws.on('message', (data) => {
+      const msg = parseMessage(data.toString());
+      if (!msg) return;
+
+      handleMessage(msg);
+    });
+
+    ws.on('close', () => {
+      if (gameScreen) {
+        gameScreen.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3000);
+      }
+    });
+
+    ws.on('error', (err) => {
+      console.error(chalk.red('Connection error:'), err.message);
+    });
+  });
+
+  function handleMessage(msg: GameMessage): void {
+    switch (msg.type) {
+      case 'move':
+        gameScreen?.receiveMove(msg.from, msg.to);
+        break;
+      case 'resign':
+        gameScreen?.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3000);
+        break;
+    }
+  }
+
+  function cleanup(): void {
+    gameScreen?.stop();
+    wss.close();
+  }
+
+  // Handle process termination
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(0);
+  });
+}

package/src/ui/Board.ts

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import { PIECES, FILES, RANKS } from '../game/constants.js';
+import type { ChessGame } from '../game/ChessGame.js';
+import type { GameState, Square, Position, PlayerColor } from '../game/types.js';
+
+function positionToSquare(pos: Position): Square {
+  return `${FILES[pos.col]}${RANKS[pos.row]}` as Square;
+}
+
+function squareToPosition(square: Square): Position {
+  const col = FILES.indexOf(square[0] as typeof FILES[number]);
+  const row = RANKS.indexOf(square[1] as typeof RANKS[number]);
+  return { row, col };
+}
+
+export function renderBoard(game: ChessGame, state: GameState): string {
+  const lines: string[] = [];
+  const { cursor, selectedSquare, validMoves, lastMove, playerColor } = state;
+
+  // File labels (a-h)
+  const fileLabels = playerColor === 'w'
+    ? '     a   b   c   d   e   f   g   h'
+    : '     h   g   f   e   d   c   b   a';
+  lines.push(chalk.gray(fileLabels));
+
+  // Top border
+  lines.push(chalk.gray('   ╔═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╗'));
+
+  // Determine row/col iteration based on player color
+  const rowOrder = playerColor === 'w' ? [0, 1, 2, 3, 4, 5, 6, 7] : [7, 6, 5, 4, 3, 2, 1, 0];
+  const colOrder = playerColor === 'w' ? [0, 1, 2, 3, 4, 5, 6, 7] : [7, 6, 5, 4, 3, 2, 1, 0];
+
+  for (let i = 0; i < 8; i++) {
+    const row = rowOrder[i];
+    const rank = RANKS[row];
+    let line = chalk.gray(` ${rank} ║`);
+
+    for (let j = 0; j < 8; j++) {
+      const col = colOrder[j];
+      const square = positionToSquare({ row, col });
+      const piece = game.getPiece(square);
+
+      // Determine cell content
+      let cellContent = '   ';
+      if (piece) {
+        const pieceChar = PIECES[piece.color][piece.type];
+        cellContent = ` ${pieceChar} `;
+      }
+
+      // Apply highlighting
+      const isCursor = cursor.row === row && cursor.col === col;
+      const isSelected = selectedSquare === square;
+      const isValidMove = validMoves.includes(square);
+      const isLastMoveFrom = lastMove?.from === square;
+      const isLastMoveTo = lastMove?.to === square;
+
+      if (isCursor) {
+        cellContent = chalk.bgYellow.black(cellContent);
+      } else if (isSelected) {
+        cellContent = chalk.bgRgb(255, 140, 0).black(cellContent); // Orange
+      } else if (isValidMove) {
+        cellContent = chalk.bgGreen.black(cellContent);
+      } else if (isLastMoveFrom || isLastMoveTo) {
+        cellContent = chalk.bgBlue.white(cellContent);
+      }
+
+      line += cellContent;
+      line += j < 7 ? chalk.gray('│') : chalk.gray('║');
+    }
+
+    lines.push(line);
+
+    // Row separator or bottom border
+    if (i < 7) {
+      lines.push(chalk.gray('   ╟───┼───┼───┼───┼───┼───┼───┼───╢'));
+    } else {
+      lines.push(chalk.gray('   ╚═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╝'));
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function renderStatus(game: ChessGame, state: GameState): string {
+  const turn = game.getCurrentTurn();
+  const turnText = turn === 'w' ? 'White' : 'Black';
+  const yourTurn = state.isMyTurn ? chalk.green('Your turn') : chalk.yellow('Opponent\'s turn');
+
+  let status = `  ${turnText} to move | ${yourTurn}`;
+
+  if (game.isCheck()) {
+    status += chalk.red(' | CHECK!');
+  }
+
+  if (state.gameOver) {
+    status = chalk.bold.red(`  Game Over: ${state.gameOverReason}`);
+    const winner = state.gameOverReason === 'Checkmate'
+      ? (turn === 'w' ? 'Black wins!' : 'White wins!')
+      : '';
+    if (winner) {
+      status += chalk.bold.yellow(` ${winner}`);
+    }
+  }
+
+  return status;
+}
+
+export function renderControls(): string {
+  return chalk.gray('  ↑↓←→: Move | Enter: Select | Esc: Cancel | Q: Quit');
+}
+
+export { positionToSquare, squareToPosition };