@datamoc/mw_games 0.20.0 → 0.23.0

package/tools/compile-openings.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { applyMove, legalMoves, positionKey, sq, squareName, startingChess } from '../src/board/chess.ts';
+import { parseUciMove } from '../src/board/openings.ts';
+
+/**
+ * Compiles opening tables (`eco`, `name`, `pgn` TSV rows, one per line after the header)
+ * into a position-keyed book a game checks in beside its own code.
+ *
+ * Each row's PGN is SAN, resolved against the real move generator and replayed from the
+ * starting position; every position along the line records the continuation, and the
+ * longest line ending at a position names it (first seen wins ties). The output is plain
+ * JSON (`{ version: 1, positions: { [key]: { eco?, name?, moves: [uci...] } } }`), keyed
+ * by `positionKey`, which is what `board.probeBook` reads back.
+ *
+ * Only Node built-ins plus the framework's own board rules are used, so this adds no
+ * dependency. Rows are vendored data (`data/openings/`, CC0), never fetched: re-vendoring
+ * is copying five files at a new commit, and a row that no longer parses fails the
+ * compile instead of silently dropping a line.
+ *
+ * usage: node tools/compile-openings.mjs <tsv folder> <book.json>
+ */
+
+const PROMOTION_KIND = { q: 'queen', r: 'rook', b: 'bishop', n: 'knight' };
+const PROMOTION_LETTER = { queen: 'q', rook: 'r', bishop: 'b', knight: 'n' };
+
+/** SAN tokens of one PGN line, without move numbers or results */
+export function sanTokens(pgn) {
+	return pgn
+		.split(/\s+/)
+		.map((token) => token.replace(/^\d+\.+/, ''))
+		.filter((token) => token && !/^(1-0|0-1|1\/2-1\/2|\*)$/.test(token));
+}
+
+/**
+ * Resolves one SAN token against the position into a UCI move (`e2e4`, `e7e8q`).
+ * Castling, disambiguation, captures, promotions and trailing check/mate marks are
+ * understood; anything resolving to zero (or several) legal moves throws with the row
+ * it came from, because a silent guess would poison every position past it.
+ */
+export function sanToUci(state, san, context) {
+	const move = san.replace(/[+#?!]+$/, '');
+	if (/^O-O(-O)?$/.test(move)) {
+		const home = state.turn === 'white' ? 0 : 56;
+		return squareName(home + 4) + squareName(home + (move === 'O-O' ? 6 : 2));
+	}
+	const match = /^([KQRBN]?)([a-h]?[1-8]?)(x?)([a-h][1-8])(?:=([QRBN]))?$/.exec(move);
+	if (!match) throw new Error(`${context}: cannot parse '${san}'`);
+	const kind = match[1] === '' ? 'pawn' : { K: 'king', Q: 'queen', R: 'rook', B: 'bishop', N: 'knight' }[match[1]];
+	const to = sq(match[4]);
+	const promotion = match[5] ? PROMOTION_KIND[match[5].toLowerCase()] : undefined;
+	const candidates = legalMoves(state).filter(
+		(candidate) =>
+			state.board[candidate.from]?.kind === kind &&
+			candidate.to === to &&
+			(candidate.promotion ?? null) === (promotion ?? null) &&
+			[...match[2]].every((c) => squareName(candidate.from).includes(c)),
+	);
+	if (candidates.length !== 1) throw new Error(`${context}: '${san}' matches ${candidates.length} moves`);
+	const chosen = candidates[0];
+	return (
+		squareName(chosen.from) + squareName(chosen.to) + (chosen.promotion ? PROMOTION_LETTER[chosen.promotion] : '')
+	);
+}
+
+/** a whole PGN line to UCI, played from the starting position */
+export function lineToUci(pgn, context) {
+	const state = startingChess();
+	const uci = [];
+	for (const san of sanTokens(pgn)) {
+		const move = sanToUci(state, san, context);
+		uci.push(move);
+		applyMove(state, parseUciMove(move));
+	}
+	return uci;
+}
+
+/**
+ * Compiles every TSV row in `dir` into a book: each position along each line keeps the
+ * continuation there, and the longest line ending at a position names it. Terminal
+ * positions keep entries of their own, so a line that stops early still classifies.
+ */
+export function compileBook(dir) {
+	const positions = {};
+	for (const file of readdirSync(dir)
+		.filter((entry) => entry.endsWith('.tsv'))
+		.sort()) {
+		const rows = readFileSync(join(dir, file), 'utf8').split('\n');
+		rows.slice(1).forEach((row, index) => {
+			if (!row.trim()) return;
+			const [eco, name, pgn] = row.split('\t');
+			const context = `${file}:${index + 2} (${eco} ${name})`;
+			if (!eco || !name || !pgn) throw new Error(`${context}: malformed row`);
+			const uci = lineToUci(pgn, context);
+			const state = startingChess();
+			const keys = [positionKey(state)];
+			for (const move of uci) {
+				applyMove(state, parseUciMove(move));
+				keys.push(positionKey(state));
+			}
+			keys.forEach((key, ply) => {
+				let entry = positions[key];
+				if (!entry) entry = positions[key] = { length: 0, moves: [] };
+				if (ply === uci.length && uci.length > entry.length) {
+					entry.eco = eco;
+					entry.name = name;
+					entry.length = uci.length;
+				}
+				if (ply < uci.length && !entry.moves.includes(uci[ply])) entry.moves.push(uci[ply]);
+			});
+		});
+	}
+	for (const key of Object.keys(positions)) delete positions[key].length;
+	return { version: 1, positions };
+}
+
+const isMain = process.argv[1] && import.meta.url.endsWith(basename(process.argv[1]));
+
+if (isMain) {
+	const [dir, out] = process.argv.slice(2);
+	if (!dir || !out) {
+		console.error('usage: node tools/compile-openings.mjs <tsv folder> <book.json>');
+		process.exit(1);
+	}
+	const book = compileBook(dir);
+	writeFileSync(out, `${JSON.stringify(book)}\n`);
+	const count = Object.keys(book.positions).length;
+	console.log(`  ${count} positions from ${relative(process.cwd(), dir)} -> ${relative(process.cwd(), out)}`);
+}

package/tools/play-uci.d.mts

@@ -0,0 +1,26 @@
+import type { ChessMove } from '../src/board/chess.ts';
+import type { OpeningBook } from '../src/board/openings.ts';
+import type { LoadedEnding } from '../src/board/tablebase.ts';
+
+export interface UciSessionOptions {
+	/** plies when `go` names no depth */
+	depth?: number;
+	/** compiled opening book, probed before anything thinks */
+	book?: OpeningBook | null;
+	/** loaded tablebase endings, probed before the search */
+	tables?: Record<string, LoadedEnding>;
+}
+
+export interface UciSession {
+	/** one input line in, zero or more output lines out; never throws */
+	input(line: string): string[];
+}
+
+/** a move in UCI coordinates (`e2e4`, `e7e8q`). */
+export function uciString(move: ChessMove): string;
+
+/**
+ * One stateful UCI conversation over the tournament engine: book, then
+ * tablebase, then `searchTourney`. Feed it input lines, read back output lines.
+ */
+export function createUciSession(options?: UciSessionOptions): UciSession;

package/tools/play-uci.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, basename, extname } from 'node:path';
+import { createInterface } from 'node:readline';
+import { applyMove, cloneChess, legalMoves, parseFen, squareName, startingChess } from '../src/board/chess.ts';
+import { parseUciMove, probeBook } from '../src/board/openings.ts';
+import { searchTourney } from '../src/board/tourney.ts';
+import { loadTablebaseEnding, probeTablebase } from '../src/board/tablebase.ts';
+
+/**
+ * A UCI adapter over the tournament engine: `position`/`go` on stdin, `bestmove`
+ * on stdout, the way a GUI expects. Move choice runs book first, then tablebase,
+ * then `searchTourney`, so each layer only pays when the earlier ones miss.
+ *
+ * This is a Node tool, never part of the browser bundle: it reads files and
+ * stdio, which a `file://` page cannot do. `info score` is centipawns from the
+ * side to move's view (documented because GUIs vary); `bestmove 0000` answers
+ * a position with no legal moves, per the UCI convention.
+ *
+ * usage: node tools/play-uci.mjs [--book <book.json>] [--tables <dir>] [--depth N]
+ */
+
+const PROMOTION_LETTER = { queen: 'q', rook: 'r', bishop: 'b', knight: 'n' };
+
+export function uciString(move) {
+	return squareName(move.from) + squareName(move.to) + (move.promotion ? PROMOTION_LETTER[move.promotion] : '');
+}
+
+/**
+ * One stateful conversation: feed it input lines, read back output lines. Pure
+ * except for the injected search, book and tables, so tests drive transcripts
+ * without spawning anything.
+ */
+export function createUciSession(options = {}) {
+	const book = options.book ?? null;
+	const tables = options.tables ?? {};
+	const fallbackDepth = options.depth ?? 4;
+	let state = startingChess();
+	let halfmove = 0;
+
+	const findMove = (token) => {
+		let parsed;
+		try {
+			parsed = parseUciMove(token);
+		} catch {
+			return null;
+		}
+		return (
+			legalMoves(state).find(
+				(move) =>
+					move.from === parsed.from &&
+					move.to === parsed.to &&
+					(parsed.promotion === undefined
+						? move.promotion === undefined
+						: move.promotion === parsed.promotion),
+			) ?? null
+		);
+	};
+
+	const play = (move) => {
+		const target = move.to === state.enPassant && state.board[move.from]?.kind === 'pawn';
+		const capture = target || state.board[move.to] !== null;
+		const pawn = state.board[move.from]?.kind === 'pawn';
+		applyMove(state, move);
+		halfmove = pawn || capture ? 0 : halfmove + 1;
+	};
+
+	const tablebest = () => {
+		const ids = Object.keys(tables);
+		if (!ids.length) return null;
+		let best = null;
+		let complete = true;
+		for (const move of legalMoves(state)) {
+			const next = cloneChess(state);
+			applyMove(next, move);
+			const probe = probeTablebase(tables, next, halfmove);
+			if (!probe) {
+				complete = false;
+				continue;
+			}
+			const score =
+				probe.outcome === 'loss' ? 100000 - probe.dtm : probe.outcome === 'draw' ? 0 : -(100000 - probe.dtm);
+			if (best === null || score > best.score) best = { move, score };
+		}
+		//a forced mate beats any unprobed capture line; otherwise every successor
+		//must probe, or the search (which sees captures) takes the move instead
+		if (best !== null && (best.score > 90000 || complete)) return best;
+		return null;
+	};
+
+	const go = (args) => {
+		let depth = fallbackDepth;
+		let maxNodes;
+		let timeMs;
+		for (let i = 0; i < args.length; i++) {
+			if (args[i] === 'depth' && args[i + 1] !== undefined) depth = Math.max(1, Math.floor(Number(args[i + 1])));
+			if (args[i] === 'nodes' && args[i + 1] !== undefined)
+				maxNodes = Math.max(1, Math.floor(Number(args[i + 1])));
+			if (args[i] === 'movetime' && args[i + 1] !== undefined)
+				timeMs = Math.max(1, Math.floor(Number(args[i + 1])));
+		}
+		if (!Number.isInteger(depth)) depth = fallbackDepth;
+		const moves = legalMoves(state);
+		if (!moves.length) return ['bestmove 0000'];
+		const entry = book ? probeBook(book, state) : null;
+		if (entry?.moves.length) return ['info string book', `bestmove ${entry.moves[0]}`];
+		const tabled = tablebest();
+		if (tabled) return ['info string tablebase', `bestmove ${uciString(tabled.move)}`];
+		const result = searchTourney(state, { depth, maxNodes, timeMs });
+		if (!result.move) return ['bestmove 0000'];
+		return [
+			`info depth ${result.depth} score cp ${result.score} nodes ${result.nodes}`,
+			`bestmove ${uciString(result.move)}`,
+		];
+	};
+
+	const position = (args) => {
+		const movesAt = args.indexOf('moves');
+		const head = movesAt === -1 ? args : args.slice(0, movesAt);
+		const tail = movesAt === -1 ? [] : args.slice(movesAt + 1);
+		if (head[0] === 'startpos') {
+			state = startingChess();
+			halfmove = 0;
+		} else if (head[0] === 'fen') {
+			try {
+				const fen = head.slice(1).join(' ');
+				state = parseFen(fen);
+				const parts = fen.split(' ');
+				halfmove = parts[4] !== undefined && /^\d+$/.test(parts[4]) ? Number(parts[4]) : 0;
+			} catch {
+				return [`info string bad fen: ${head.slice(1).join(' ')}`];
+			}
+		} else {
+			return [`info string unknown position: ${head[0] ?? ''}`];
+		}
+		for (const token of tail) {
+			const move = findMove(token);
+			if (!move) return [`info string illegal move: ${token}`];
+			play(move);
+		}
+		return [];
+	};
+
+	return {
+		input(line) {
+			const parts = line
+				.trim()
+				.split(/\s+/)
+				.filter((part) => part.length);
+			if (!parts.length) return [];
+			const [command, ...args] = parts;
+			if (command === 'uci') return ['id name mwg tourney', 'uciok'];
+			if (command === 'isready') return ['readyok'];
+			if (command === 'ucinewgame') {
+				state = startingChess();
+				halfmove = 0;
+				return [];
+			}
+			if (command === 'position') return position(args);
+			if (command === 'go') return go(args);
+			if (command === 'quit') return [];
+			return [`info string unknown command: ${command}`];
+		},
+	};
+}
+
+const isMain = process.argv[1] && import.meta.url.endsWith(basename(process.argv[1]));
+
+if (isMain) {
+	const args = process.argv.slice(2);
+	const flag = (name) => {
+		const at = args.indexOf(name);
+		return at === -1 ? undefined : args[at + 1];
+	};
+	const bookPath = flag('--book');
+	const tablesDir = flag('--tables');
+	const depth = flag('--depth') === undefined ? 4 : Math.max(1, Math.floor(Number(flag('--depth'))));
+	const book = bookPath ? JSON.parse(readFileSync(bookPath, 'utf8')) : null;
+	if (book && book.version !== 1) throw new Error(`${bookPath}: unknown opening-book version`);
+	const tables = {};
+	if (tablesDir) {
+		for (const file of readdirSync(tablesDir)) {
+			if (extname(file) !== '.json') continue;
+			const ending = loadTablebaseEnding(JSON.parse(readFileSync(join(tablesDir, file), 'utf8')));
+			tables[ending.id] = ending;
+		}
+	}
+	const session = createUciSession({ book, tables, depth });
+	const lines = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+	for await (const line of lines) {
+		if (line.trim() === 'quit') break;
+		for (const out of session.input(line)) console.log(out);
+	}
+}