open-index/open-npm huggingface dataset:
npm package: @llmindset/mcp-qualytics
Description: A Code Metric Analysis MCP Server (for TypeScript)
Latest version: 0.1.4

# MCP Qualytics

A Code Metric Analysis MCP Server that provides advanced code quality metrics for TypeScript code.

## Installation

```bash
npm install -g @llmindset/mcp-qualytics
```

## Usage

MCP Qualytics provides three main tools for code analysis:

### 1. Analyze Text

Analyze TypeScript code provided as text:

```typescript
{
  name: "typescript_analyze_text",
  arguments: {
    code: "function example() { return true; }",
    format: "text" // or "table"
  }
}
```

### 2. Analyze File

Analyze a TypeScript file:

```typescript
{
  name: "typescript_analyze_file",
  arguments: {
    filepath: "/path/to/file.ts",
    format: "text" // or "table"
  }
}
```

### 3. Analyze Directory

Analyze all TypeScript files in a directory:

```typescript
{
  name: "typescript_analyze_directory",
  arguments: {
    directory: "/path/to/dir",
    include_functions: true, // optional
    ignore_patterns: ["test/**", "**/*.spec.ts"] // optional
  }
}
```

## Metrics

The analysis includes:
- Lines of Code (LOC)
- Cyclomatic Complexity
- Maintainability Index (0-100)
- Class Count
- Method Count
- Average Method Complexity
- Inheritance Depth

## Output Formats

All tools support two output formats:
- `text`: Detailed human-readable output
- `table`: Markdown table format for easy visualization

## License

MIT
npm package: @llmletsplay/versus-battleship
Description: Standalone Versus battleship engine package
Latest version: 0.1.1

# @llmletsplay/versus-battleship

Drop-in Battleship engine for hidden-grid naval duels.

## Install

```bash
npm install @llmletsplay/versus-battleship
```

## Quick Start

```js
import { BattleshipGame } from '@llmletsplay/versus-battleship';

const game = new BattleshipGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new BattleshipGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Scope Notes

- The engine auto-places fleets rather than asking each player to position ships manually.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-bingo
Description: Standalone Versus bingo engine package
Latest version: 0.1.1

# @llmletsplay/versus-bingo

Drop-in Bingo engine with generated cards and configurable win patterns.

## Install

```bash
npm install @llmletsplay/versus-bingo
```

## Quick Start

```js
import { BingoGame } from '@llmletsplay/versus-bingo';

const game = new BingoGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new BingoGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-blackjack
Description: Standalone Versus blackjack engine package
Latest version: 0.1.1

# @llmletsplay/versus-blackjack

Drop-in Blackjack engine for a single player versus the dealer.

## Install

```bash
npm install @llmletsplay/versus-blackjack
```

## Quick Start

```js
import { BlackjackGame } from '@llmletsplay/versus-blackjack';

const game = new BlackjackGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new BlackjackGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Scope Notes

- This package models a single player against the dealer, not a multi-seat table.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-bullshit
Description: Standalone Versus bullshit engine package
Latest version: 0.1.1

# @llmletsplay/versus-bullshit

Drop-in bluffing and shedding engine for Bullshit / Cheat style play.

## Install

```bash
npm install @llmletsplay/versus-bullshit
```

## Quick Start

```js
import { BullshitGame } from '@llmletsplay/versus-bullshit';

const game = new BullshitGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new BullshitGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-catan
Description: Standalone Versus catan engine package
Latest version: 0.1.1

# @llmletsplay/versus-catan

Drop-in Catan engine with setup, production, building, trading, and development cards.

## Install

```bash
npm install @llmletsplay/versus-catan
```

## Quick Start

```js
import { CatanGame } from '@llmletsplay/versus-catan';

const game = new CatanGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new CatanGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-checkers
Description: Standalone Versus checkers engine package
Latest version: 0.1.1

# @llmletsplay/versus-checkers

Drop-in Checkers engine for standard two-player draughts play.

## Install

```bash
npm install @llmletsplay/versus-checkers
```

## Quick Start

```js
import { CheckersGame } from '@llmletsplay/versus-checkers';

const game = new CheckersGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new CheckersGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-chess
Description: Standalone Versus chess engine package
Latest version: 0.1.1

# @llmletsplay/versus-chess

Drop-in Chess engine with legal move validation and end-state detection.

## Install

```bash
npm install @llmletsplay/versus-chess
```

## Quick Start

```js
import { ChessGame } from '@llmletsplay/versus-chess';

const game = new ChessGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## Host App Pattern

Use the engine inside your UI runtime, validate the user move locally, then validate the agent reply against the same instance before committing it.

```js
const userMove = {
  player: 'white',
  from: { row: 6, col: 4 },
  to: { row: 4, col: 4 },
};

await game.validateMove(userMove);
const afterUserMove = await game.makeMove(userMove);

const agentMove = await askAgent(afterUserMove);
await game.validateMove(agentMove);
const afterAgentMove = await game.makeMove(agentMove);
```

For copy-pasteable host examples, see `examples/agent-turn-loop.mjs` and `examples/react-agent-omok.tsx`.

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new ChessGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-chinese-checkers
Description: Standalone Versus chinese-checkers engine package
Latest version: 0.1.1

# @llmletsplay/versus-chinese-checkers

Drop-in Chinese Checkers engine with the official 121-hole star board and chained jumps.

## Install

```bash
npm install @llmletsplay/versus-chinese-checkers
```

## Quick Start

```js
import { ChineseCheckersGame } from '@llmletsplay/versus-chinese-checkers';

const game = new ChineseCheckersGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new ChineseCheckersGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-connect-four
Description: Standalone Versus connect-four engine package
Latest version: 0.1.1

# @llmletsplay/versus-connect-four

Drop-in Connect Four engine for classic vertical alignment play.

## Install

```bash
npm install @llmletsplay/versus-connect-four
```

## Quick Start

```js
import { ConnectFourGame } from '@llmletsplay/versus-connect-four';

const game = new ConnectFourGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new ConnectFourGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-crazy-cards
Description: Standalone Versus UNO-style shedding-game engine package
Latest version: 0.1.1

# @llmletsplay/versus-crazy-cards

Drop-in Crazy Cards engine for UNO-style color-and-rank shedding play.

## Install

```bash
npm install @llmletsplay/versus-crazy-cards
```

## Quick Start

```js
import { CrazyCardsGame } from '@llmletsplay/versus-crazy-cards';

const game = new CrazyCardsGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new CrazyCardsGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Scope Notes

- The engine does not support stacking draw penalties.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-cuttle
Description: Standalone Versus cuttle engine package
Latest version: 0.1.1

# @llmletsplay/versus-cuttle

Drop-in Cuttle engine for point-race card combat.

## Install

```bash
npm install @llmletsplay/versus-cuttle
```

## Quick Start

```js
import { CuttleGame } from '@llmletsplay/versus-cuttle';

const game = new CuttleGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new CuttleGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-game-core
Description: Shared core types and helpers for standalone Versus game packages
Latest version: 0.1.1

# @llmletsplay/versus-game-core

Shared runtime types and helpers for the standalone Versus game packages.

This package is headless infrastructure. It does not include any bundled UI components or styling primitives.

## Install

```bash
npm install @llmletsplay/versus-game-core
```

## What You Get

- `BaseGame` for shared turn-based flow, persistence hooks, and history handling
- `InMemoryDatabaseProvider` for zero-config local storage
- Shared type contracts such as `GameState`, `GameMove`, and `MoveValidationResult`
- Logging and metadata helpers used by the publishable game packages

## Quick Start

```js
import { BaseGame, InMemoryDatabaseProvider } from '@llmletsplay/versus-game-core';

const storage = new InMemoryDatabaseProvider();
console.log(typeof BaseGame, storage.constructor.name);
```

## Host App Pattern

Most apps should keep a game instance in memory, reflect `getGameState()` into local UI state, and validate both user and agent moves against that same instance.

See:

- `examples/agent-turn-loop.mjs`
- `examples/react-agent-omok.tsx`

## Notes

This package provides infrastructure rather than a playable game. Consumers normally install it transitively through a game package such as `@llmletsplay/versus-chess` or `@llmletsplay/versus-tic-tac-toe`.
npm package: @llmletsplay/versus-go
Description: Standalone Versus go engine package
Latest version: 0.1.1

# @llmletsplay/versus-go

Drop-in Go engine with captures, ko tracking, passing, and scoring.

## Install

```bash
npm install @llmletsplay/versus-go
```

## Quick Start

```js
import { GoGame } from '@llmletsplay/versus-go';

const game = new GoGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## Host App Pattern

The engine is meant to live inside your app runtime, whether that runtime is a browser, server action, or agent worker.

```js
const userMove = {
  player: 'black',
  action: 'place',
  row: 3,
  col: 3,
};

await game.validateMove(userMove);
const afterUserMove = await game.makeMove(userMove);

const agentMove = await askAgent(afterUserMove);
await game.validateMove(agentMove);
const afterAgentMove = await game.makeMove(agentMove);
```

For copy-pasteable host examples, see `examples/agent-turn-loop.mjs` and `examples/react-agent-omok.tsx`.

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new GoGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-go-fish
Description: Standalone Versus go-fish engine package
Latest version: 0.1.1

# @llmletsplay/versus-go-fish

Drop-in Go Fish engine for rank-asking and book collection.

## Install

```bash
npm install @llmletsplay/versus-go-fish
```

## Quick Start

```js
import { GoFishGame } from '@llmletsplay/versus-go-fish';

const game = new GoFishGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new GoFishGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-hearts
Description: Standalone Versus hearts engine package
Latest version: 0.1.1

# @llmletsplay/versus-hearts

Drop-in Hearts engine with passing, trick play, and penalty scoring.

## Install

```bash
npm install @llmletsplay/versus-hearts
```

## Quick Start

```js
import { HeartsGame } from '@llmletsplay/versus-hearts';

const game = new HeartsGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new HeartsGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-mahjong
Description: Standalone Versus mahjong engine package
Latest version: 0.1.1

# @llmletsplay/versus-mahjong

Drop-in Chinese Official Mahjong engine with 8-fan scoring, session progression, discard claims, and kan flow.

## Install

```bash
npm install @llmletsplay/versus-mahjong
```

## Quick Start

```js
import { MahjongGame } from '@llmletsplay/versus-mahjong';

const game = new MahjongGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new MahjongGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`
- `startNextHand()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Scope Notes

- The package now supports multi-hand dealer/prevalent-wind progression, but it still does not cover the full official fan catalog or side-settlement cases such as kong bonuses and exhaustive-draw ready-hand payments.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-mancala
Description: Standalone Versus mancala engine package
Latest version: 0.1.1

# @llmletsplay/versus-mancala

Drop-in Mancala engine for classic Kalah-style sowing play.

## Install

```bash
npm install @llmletsplay/versus-mancala
```

## Quick Start

```js
import { MancalaGame } from '@llmletsplay/versus-mancala';

const game = new MancalaGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new MancalaGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-martial-tactics
Description: Standalone Versus martial-tactics engine package
Latest version: 0.1.1

# @llmletsplay/versus-martial-tactics

Drop-in Martial Tactics engine for card-driven dojo duels.

## Install

```bash
npm install @llmletsplay/versus-martial-tactics
```

## Quick Start

```js
import { MartialTacticsGame } from '@llmletsplay/versus-martial-tactics';

const game = new MartialTacticsGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new MartialTacticsGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-omok
Description: Standalone Versus omok engine package
Latest version: 0.1.1

# @llmletsplay/versus-omok

Drop-in Omok engine for five-in-a-row placement play.

## Install

```bash
npm install @llmletsplay/versus-omok
```

## Quick Start

```js
import { OmokGame } from '@llmletsplay/versus-omok';

const game = new OmokGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## Host App Pattern

This package works well as a local rules engine for React, Vite, Next.js, Bun, or agent-hosted apps.

```js
const userMove = {
  player: 'black',
  row: 7,
  col: 7,
};

await game.validateMove(userMove);
const afterUserMove = await game.makeMove(userMove);

const agentMove = await askAgent(afterUserMove);
await game.validateMove(agentMove);
const afterAgentMove = await game.makeMove(agentMove);
```

For copy-pasteable host examples, see `examples/agent-turn-loop.mjs` and `examples/react-agent-omok.tsx`.

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new OmokGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-othello
Description: Standalone Versus othello engine package
Latest version: 0.1.1

# @llmletsplay/versus-othello

Drop-in Othello engine with legal-flip validation and pass handling.

## Install

```bash
npm install @llmletsplay/versus-othello
```

## Quick Start

```js
import { OthelloGame } from '@llmletsplay/versus-othello';

const game = new OthelloGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new OthelloGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-poker
Description: Standalone Versus poker engine package
Latest version: 0.1.1

# @llmletsplay/versus-poker

Drop-in Texas Hold'em engine with betting streets and showdown evaluation.

## Install

```bash
npm install @llmletsplay/versus-poker
```

## Quick Start

```js
import { PokerGame } from '@llmletsplay/versus-poker';

const game = new PokerGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new PokerGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-shogi
Description: Standalone Versus shogi engine package
Latest version: 0.1.1

# @llmletsplay/versus-shogi

Drop-in Shogi engine with promotions, drops, and check-state validation.

## Install

```bash
npm install @llmletsplay/versus-shogi
```

## Quick Start

```js
import { ShogiGame } from '@llmletsplay/versus-shogi';

const game = new ShogiGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new ShogiGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-spades
Description: Standalone Versus spades engine package
Latest version: 0.1.1

# @llmletsplay/versus-spades

Drop-in Spades engine with bidding, trick-taking, and partnership scoring.

## Install

```bash
npm install @llmletsplay/versus-spades
```

## Quick Start

```js
import { SpadesGame } from '@llmletsplay/versus-spades';

const game = new SpadesGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new SpadesGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-thirteen
Description: Standalone Versus thirteen engine package
Latest version: 0.1.1

# @llmletsplay/versus-thirteen

Drop-in Thirteen engine for Tien Len style climbing and shedding.

## Install

```bash
npm install @llmletsplay/versus-thirteen
```

## Quick Start

```js
import { ThirteenGame } from '@llmletsplay/versus-thirteen';

const game = new ThirteenGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new ThirteenGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-tic-tac-toe
Description: Standalone Versus tic-tac-toe engine package
Latest version: 0.1.1

# @llmletsplay/versus-tic-tac-toe

Drop-in Tic-Tac-Toe engine for classic 3x3 play.

## Install

```bash
npm install @llmletsplay/versus-tic-tac-toe
```

## Quick Start

```js
import { TicTacToeGame } from '@llmletsplay/versus-tic-tac-toe';

const game = new TicTacToeGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new TicTacToeGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-war
Description: Standalone Versus war engine package
Latest version: 0.1.1

# @llmletsplay/versus-war

Drop-in War engine for automated battle and tie-resolution play.

## Install

```bash
npm install @llmletsplay/versus-war
```

## Quick Start

```js
import { WarGame } from '@llmletsplay/versus-war';

const game = new WarGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new WarGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.
npm package: @llmletsplay/versus-word-tiles
Description: Standalone Versus word-tiles engine package
Latest version: 0.1.1

# @llmletsplay/versus-word-tiles

Drop-in Word Tiles engine for Scrabble-style placement and scoring.

## Install

```bash
npm install @llmletsplay/versus-word-tiles
```

## Quick Start

```js
import { WordTilesGame } from '@llmletsplay/versus-word-tiles';

const game = new WordTilesGame('demo');
await game.initializeGame();
const state = await game.getGameState();

console.log(state.currentPlayer);
```

## What You Get

- ESM build output from `dist/`
- Type declarations for TS consumers
- In-memory storage by default, with optional database injection when you need persistence
- Package-local rules in [RULES.md](./RULES.md)

## Public API

- `new WordTilesGame(gameId, database?)`
- `initializeGame(config?)`
- `validateMove(move)`
- `makeMove(move)`
- `getGameState()`

## Rules

See [RULES.md](./RULES.md) for the implemented objective, setup, turn flow, end conditions, and engine notes.

## Testing

This package is exercised by the shared game-engine test suite that the server integration layer also consumes.