@knights-eye-chess/ai-analysis 0.0.0-stage → 0.1.0-dev.17

package/dist/owner-tests/move-mechanism-facts.test.mjs

@@ -0,0 +1,396 @@
+// test/owner/move-mechanism-facts.test.mjs
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Chess as Chess3 } from "chess.js";
+
+// src/chess-reasoning/move-mechanism-facts.ts
+import { Chess as Chess2, SQUARES as SQUARES2 } from "chess.js";
+
+// src/chess-reasoning/piece-identities.ts
+import { Chess, SQUARES } from "chess.js";
+
+// src/chess-reasoning/types.ts
+var CHESS_REASONING_SCHEMA_VERSION = "0.2.0";
+
+// src/chess-reasoning/piece-identities.ts
+var PIECE_NAMES = {
+  p: "pawn",
+  n: "knight",
+  b: "bishop",
+  r: "rook",
+  q: "queen",
+  k: "king"
+};
+var COLOR_NAMES = { w: "white", b: "black" };
+function pieceId(color, type, square, ordinal = 0) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:${square}:${ordinal}`;
+}
+function promotionId(color, type, square, ordinal) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:promotion:${square}:${ordinal}`;
+}
+function clonePieces(pieces) {
+  return Object.fromEntries(Object.entries(pieces).map(([id, piece]) => [id, { ...piece }]));
+}
+function createIdentityState(fen = new Chess().fen(), branchId = "main", ply = 0) {
+  const chess = new Chess(fen);
+  const pieces = {};
+  const squares = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const square of SQUARES) {
+    const piece = chess.get(square);
+    if (!piece) continue;
+    const key = `${piece.color}:${piece.type}:${square}`;
+    const ordinal = seen.get(key) || 0;
+    seen.set(key, ordinal + 1);
+    const id = pieceId(piece.color, piece.type, square, ordinal);
+    pieces[id] = {
+      id,
+      color: piece.color,
+      type: piece.type,
+      originSquare: square,
+      createdPly: ply,
+      promotedFrom: null,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[square] = id;
+  }
+  return {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId,
+    fen: chess.fen(),
+    ply,
+    pieces,
+    squares,
+    promotionSequence: 0
+  };
+}
+function applyIdentityMove(state, moveInput) {
+  const chess = new Chess(state.fen);
+  const beforeFen = chess.fen();
+  const move = chess.move(moveInput);
+  const nextPly = state.ply + 1;
+  const pieces = clonePieces(state.pieces);
+  const squares = { ...state.squares };
+  const mover = squares[move.from];
+  if (!mover) throw new Error(`No stable piece identity at ${move.from}`);
+  let captured = null;
+  const capturedSquare = move.isEnPassant() ? `${move.to[0]}${move.from[1]}` : move.to;
+  if (move.isCapture() || move.isEnPassant()) {
+    captured = squares[capturedSquare] || null;
+    if (!captured) throw new Error(`No captured piece identity at ${capturedSquare}`);
+    pieces[captured] = { ...pieces[captured], capturedAtPly: nextPly };
+    delete squares[capturedSquare];
+  }
+  delete squares[move.from];
+  let rookMoved = null;
+  if (move.isKingsideCastle() || move.isQueensideCastle()) {
+    const rank = move.from[1];
+    const rookFrom = `${move.isKingsideCastle() ? "h" : "a"}${rank}`;
+    const rookTo = `${move.isKingsideCastle() ? "f" : "d"}${rank}`;
+    rookMoved = squares[rookFrom] || null;
+    if (!rookMoved) throw new Error(`No stable rook identity at ${rookFrom}`);
+    delete squares[rookFrom];
+    squares[rookTo] = rookMoved;
+  }
+  let promoted = null;
+  let promotionSequence = state.promotionSequence;
+  if (move.isPromotion()) {
+    promotionSequence += 1;
+    pieces[mover] = { ...pieces[mover], retiredAtPly: nextPly };
+    promoted = promotionId(move.color, move.promotion, move.to, promotionSequence);
+    pieces[promoted] = {
+      id: promoted,
+      color: move.color,
+      type: move.promotion,
+      originSquare: move.to,
+      createdPly: nextPly,
+      promotedFrom: mover,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[move.to] = promoted;
+  } else {
+    squares[move.to] = mover;
+  }
+  const nextState = {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId: state.branchId,
+    fen: chess.fen(),
+    ply: nextPly,
+    pieces,
+    squares,
+    promotionSequence
+  };
+  return {
+    state: nextState,
+    delta: {
+      branchId: state.branchId,
+      ply: nextPly,
+      uci: `${move.from}${move.to}${move.promotion || ""}`,
+      san: move.san,
+      mover,
+      captured,
+      promoted,
+      rookMoved,
+      beforeFen,
+      afterFen: chess.fen()
+    }
+  };
+}
+
+// src/chess-reasoning/move-mechanism-facts.ts
+var DIRECTIONS = [
+  ["N", 0, 1],
+  ["NE", 1, 1],
+  ["E", 1, 0],
+  ["SE", 1, -1],
+  ["S", 0, -1],
+  ["SW", -1, -1],
+  ["W", -1, 0],
+  ["NW", -1, 1]
+];
+function enemy(color) {
+  return color === "w" ? "b" : "w";
+}
+function attackers(board, square, color) {
+  return board.attackers(square, color).sort((a, b) => SQUARES2.indexOf(a) - SQUARES2.indexOf(b));
+}
+function ray(board, origin, fileStep, rankStep) {
+  const squares = [];
+  const file = origin.charCodeAt(0) - 97;
+  const rank = Number(origin[1]) - 1;
+  for (let distance = 1; distance < 8; distance += 1) {
+    const f = file + fileStep * distance;
+    const r = rank + rankStep * distance;
+    if (f < 0 || f > 7 || r < 0 || r > 7) break;
+    const square = `${String.fromCharCode(97 + f)}${r + 1}`;
+    squares.push(square);
+    if (board.get(square)) break;
+  }
+  return squares;
+}
+function sliderDirections(type) {
+  if (type === "q") return DIRECTIONS;
+  return DIRECTIONS.filter(([, dx, dy]) => type === "r" ? !dx || !dy : !!dx && !!dy);
+}
+function moveMechanismFacts(before, after, from, to, beforeIds, afterIds) {
+  const moverBefore = before.get(from);
+  const moverAfter = after.get(to);
+  if (!moverBefore || !moverAfter || moverBefore.color !== moverAfter.color) {
+    throw new Error(`Move mechanism has no corresponding mover at ${from}-${to}`);
+  }
+  const beforeState = beforeIds || createIdentityState(before.fen());
+  if (beforeState.fen !== before.fen() || afterIds && afterIds.fen !== after.fen()) {
+    throw new Error("Move mechanism identity position does not match the board");
+  }
+  const actualMove = before.moves({ verbose: true }).find((move) => {
+    if (move.from !== from || move.to !== to) return false;
+    const replay = new Chess2(before.fen());
+    replay.move({ from, to, promotion: move.promotion });
+    return replay.fen() === after.fen();
+  });
+  if (!actualMove) throw new Error(`Move mechanism after-position is not a legal ${from}-${to} result`);
+  const afterState = afterIds || applyIdentityMove(beforeState, {
+    from,
+    to,
+    promotion: actualMove.promotion
+  }).state;
+  const pieceId2 = beforeState.squares[from];
+  const pieceIdAfter = afterState.squares[to];
+  if (!pieceId2 || !pieceIdAfter || (actualMove.promotion ? afterState.pieces[pieceIdAfter]?.promotedFrom !== pieceId2 : pieceIdAfter !== pieceId2)) {
+    throw new Error("Move mechanism mover identities do not match");
+  }
+  const attackedUnmovedFriendlyPieces = [];
+  const stationarySliderRays = [];
+  const color = moverBefore.color;
+  for (const square of SQUARES2) {
+    const piece = before.get(square);
+    const samePiece = after.get(square);
+    const id = beforeState.squares[square];
+    if (!piece || !samePiece || !id || afterState.squares[square] !== id || piece.color !== samePiece.color || piece.type !== samePiece.type) continue;
+    if (piece.color === color) {
+      const beforeAttackers = attackers(before, square, enemy(color));
+      const afterAttackers = attackers(after, square, enemy(color));
+      if (beforeAttackers.length || afterAttackers.length) {
+        attackedUnmovedFriendlyPieces.push({
+          pieceId: id,
+          square,
+          pieceType: piece.type,
+          attackersBefore: beforeAttackers,
+          attackersAfter: afterAttackers
+        });
+      }
+    }
+    if (piece.type !== "r" && piece.type !== "b" && piece.type !== "q") continue;
+    for (const [direction, dx, dy] of sliderDirections(piece.type)) {
+      const beforeSquares = ray(before, square, dx, dy);
+      const afterSquares = ray(after, square, dx, dy);
+      const beforeSet = new Set(beforeSquares);
+      const afterSet = new Set(afterSquares);
+      const gainedSquares = afterSquares.filter((target) => !beforeSet.has(target));
+      const lostSquares = beforeSquares.filter((target) => !afterSet.has(target));
+      if (gainedSquares.length || lostSquares.length) {
+        stationarySliderRays.push({
+          pieceId: id,
+          fromSquare: square,
+          color: piece.color,
+          pieceType: piece.type,
+          direction,
+          beforeSquares,
+          afterSquares,
+          gainedSquares,
+          lostSquares
+        });
+      }
+    }
+  }
+  const controlDelta = [];
+  for (const square of SQUARES2) {
+    for (const attackingColor of ["w", "b"]) {
+      const attackersBefore = attackers(before, square, attackingColor);
+      const attackersAfter = attackers(after, square, attackingColor);
+      if (attackersBefore.length !== attackersAfter.length || attackersBefore.some((origin, index) => origin !== attackersAfter[index])) {
+        controlDelta.push({ square, color: attackingColor, attackersBefore, attackersAfter });
+      }
+    }
+  }
+  return {
+    mover: {
+      pieceId: pieceId2,
+      pieceIdAfter,
+      fromSquare: from,
+      toSquare: to,
+      color,
+      pieceTypeBefore: moverBefore.type,
+      pieceTypeAfter: moverAfter.type,
+      attackersBefore: attackers(before, from, enemy(color)),
+      attackersAfter: attackers(after, to, enemy(color))
+    },
+    attackedUnmovedFriendlyPieces,
+    stationarySliderRays,
+    controlDelta,
+    checksRun: [
+      "mover-geometric-attackers-before-after",
+      "unmoved-friendly-piece-geometric-attackers-before-after",
+      "stationary-slider-visible-rays-before-after",
+      "all-square-both-color-geometric-control-delta"
+    ],
+    scope: "Complete board-local geometric measurements at this move. Attackers include pinned pieces; visible slider rays include the first occupied square. Empty lists mean measured none or no change. No claim of legal captures, safe retreat, exchange profit, forced purpose, or strategic importance."
+  };
+}
+
+// test/owner/move-mechanism-facts.test.mjs
+function facts(fen, uci, suppliedIdentities = true) {
+  const before = new Chess3(fen);
+  const beforeIds = createIdentityState(fen);
+  const { state: afterIds } = applyIdentityMove(beforeIds, {
+    from: uci.slice(0, 2),
+    to: uci.slice(2, 4),
+    promotion: uci.slice(4) || void 0
+  });
+  const after = new Chess3(afterIds.fen);
+  return moveMechanismFacts(
+    before,
+    after,
+    uci.slice(0, 2),
+    uci.slice(2, 4),
+    ...suppliedIdentities ? [beforeIds, afterIds] : []
+  );
+}
+test("KE-REASON-016/021: Rb2+ mover is unattacked while the unmoved rook on d1 is attacked from a4", () => {
+  const observed = facts("1k1r3r/2p5/p2p1p2/2P2B2/b3PB1p/5P2/3R2PP/2KR4 w - - 1 25", "d2b2");
+  assert.equal(observed.mover.pieceId, "white-rook:d2:0");
+  assert.deepEqual(observed.mover.attackersBefore, []);
+  assert.deepEqual(observed.mover.attackersAfter, []);
+  assert.deepEqual(observed.attackedUnmovedFriendlyPieces.find((piece) => piece.square === "d1"), {
+    pieceId: "white-rook:d1:0",
+    square: "d1",
+    pieceType: "r",
+    attackersBefore: ["a4"],
+    attackersAfter: ["a4"]
+  });
+  assert.ok(observed.checksRun.includes("unmoved-friendly-piece-geometric-attackers-before-after"));
+  assert.match(observed.scope, /geometric measurements/i);
+});
+test("KE-REASON-016/021: after 7...b6, e5 frees the queen d4 horizontal ray through f4-h4, not a8", () => {
+  const observed = facts("r1bqkb1r/p1pp1pp1/1p3n1p/8/2BQP3/2N5/PPP2PPP/R1B1K2R w KQkq - 0 8", "e4e5");
+  const east = observed.stationarySliderRays.find((item) => item.fromSquare === "d4" && item.direction === "E");
+  assert.deepEqual(east?.beforeSquares, ["e4"]);
+  assert.deepEqual(east?.afterSquares, ["e4", "f4", "g4", "h4"]);
+  assert.deepEqual(east?.gainedSquares, ["f4", "g4", "h4"]);
+  assert.ok(!observed.stationarySliderRays.some((item) => item.fromSquare === "d4" && item.gainedSquares.includes("a8")));
+  assert.deepEqual(observed.controlDelta.find((item) => item.square === "g4" && item.color === "w")?.attackersAfter, ["d4"]);
+});
+test("KE-REASON-016/021: control loss occurs at the actual knight move, not the prior pawn push", () => {
+  const rootFen = "r1bqkb1r/p1pp1pp1/1p3n1p/8/2BQP3/2N5/PPP2PPP/R1B1K2R w KQkq - 0 8";
+  const pawnPush = facts(rootFen, "e4e5");
+  assert.equal(pawnPush.controlDelta.find((item) => item.square === "d5" && item.color === "b"), void 0);
+  const afterPawnPush = new Chess3(rootFen);
+  afterPawnPush.move({ from: "e4", to: "e5" });
+  const knightMove = facts(afterPawnPush.fen(), "f6h7");
+  assert.deepEqual(knightMove.controlDelta.find((item) => item.square === "d5" && item.color === "b"), {
+    square: "d5",
+    color: "b",
+    attackersBefore: ["f6"],
+    attackersAfter: []
+  });
+  assert.deepEqual(knightMove.mover.attackersBefore, ["e5"]);
+});
+test("KE-REASON-016/021: moving slider is not reported as stationary opening, even along same file", () => {
+  const rootFen = "k1B5/1R6/p2B1p2/8/4P2p/5P2/6PP/2K2b2 w - - 7 34";
+  const observed = facts(rootFen, "b7b2");
+  assert.ok(!observed.stationarySliderRays.some((item) => item.pieceId === observed.mover.pieceId));
+  assert.ok(!observed.stationarySliderRays.some((item) => item.fromSquare === "b7" || item.fromSquare === "b2"));
+  const afterRook = new Chess3(rootFen);
+  afterRook.move({ from: "b7", to: "b2" });
+  const response = facts(afterRook.fen(), "f1b5");
+  const blocked = response.stationarySliderRays.find((item) => item.fromSquare === "b2" && item.direction === "N");
+  assert.deepEqual(blocked?.beforeSquares, ["b3", "b4", "b5", "b6", "b7", "b8"]);
+  assert.deepEqual(blocked?.afterSquares, ["b3", "b4", "b5"]);
+  assert.deepEqual(blocked?.lostSquares, ["b6", "b7", "b8"]);
+});
+test("KE-REASON-016/021: Bf7+, queen promotion and bishop underpromotion have exact mover identities and controls", () => {
+  const bishop = facts("8/4P3/1R2B3/6Bk/7P/8/8/2K5 w - - 3 50", "e6f7");
+  assert.equal(bishop.mover.pieceId, bishop.mover.pieceIdAfter);
+  assert.equal(bishop.mover.pieceTypeBefore, "b");
+  assert.deepEqual(bishop.controlDelta.find((item) => item.square === "e8" && item.color === "w")?.attackersAfter, ["f7"]);
+  assert.deepEqual(bishop.controlDelta.find((item) => item.square === "g4" && item.color === "w"), {
+    square: "g4",
+    color: "w",
+    attackersBefore: ["e6"],
+    attackersAfter: []
+  });
+  const mateFen = "8/4P3/1R2B3/6Bk/7P/8/8/2K5 w - - 3 50";
+  for (const uci of ["e7e8q", "e7e8b"]) {
+    const promotionMate = new Chess3(mateFen);
+    promotionMate.move({ from: "e7", to: "e8", promotion: uci.slice(4) });
+    assert.equal(promotionMate.isCheckmate(), true, `${uci} is a legal mate at the observed board`);
+    assert.equal(facts(mateFen, uci).mover.pieceTypeAfter, uci.slice(4));
+  }
+  const promotionFen = "8/4P3/1R2B3/6B1/7P/5k2/8/2K5 w - - 7 52";
+  const queen = facts(promotionFen, "e7e8q");
+  const underpromotion = facts(promotionFen, "e7e8b", false);
+  assert.equal(queen.mover.pieceTypeAfter, "q");
+  assert.equal(underpromotion.mover.pieceTypeAfter, "b");
+  assert.notEqual(queen.mover.pieceId, queen.mover.pieceIdAfter);
+  assert.match(queen.mover.pieceIdAfter, /promotion:e8/);
+  assert.ok(queen.controlDelta.some((entry) => entry.square === "e7" && entry.color === "w"));
+  assert.ok(!underpromotion.controlDelta.some((entry) => entry.square === "e7" && entry.color === "w"));
+});
+test("KE-REASON-016/021: en passant removes the off-target blocker and castling excludes the moved rook", () => {
+  const ep = facts("7k/8/8/3pP3/8/8/8/K2R4 w - d6 0 1", "e5d6");
+  assert.deepEqual(ep.controlDelta.find((item) => item.square === "e4" && item.color === "b"), {
+    square: "e4",
+    color: "b",
+    attackersBefore: ["d5"],
+    attackersAfter: []
+  });
+  assert.deepEqual(
+    ep.stationarySliderRays.find((item) => item.fromSquare === "d1" && item.direction === "N")?.afterSquares,
+    ["d2", "d3", "d4", "d5", "d6"]
+  );
+  const castle = facts("4k3/8/8/8/8/8/8/4K2R w K - 0 1", "e1g1");
+  assert.ok(!castle.stationarySliderRays.some((item) => item.pieceId === "white-rook:h1:0"));
+  assert.equal(castle.mover.toSquare, "g1");
+});