@unclick/chessdotcom-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+Apache License 2.0
+
+Copyright (c) 2026 UnClick / malamutemayhem
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,37 @@
+# Chess.com MCP by UnClick
+
+Chess.com player profiles, stats, games, puzzles, and leaderboards. No API key.
+
+> By UnClick. 180+ tools plus persistent agent memory in one install: https://unclick.world
+
+## Install
+
+Installs straight from GitHub, no npm account needed.
+
+```json
+{
+  "mcpServers": {
+    "chessdotcom": {
+      "command": "npx",
+      "args": ["-y", "https://github.com/malamutemayhem/unclick/releases/download/standalone-mcps-latest/chessdotcom.tgz"]
+    }
+  }
+}
+```
+
+## Tools
+
+- `chess_player`
+- `chess_player_stats`
+- `chess_player_games`
+- `chess_puzzles_random`
+- `chess_leaderboards`
+
+## Want the rest?
+
+This is one connector. [UnClick](https://unclick.world) bundles 180+ tools plus
+persistent cross-session agent memory in a single install.
+
+## License
+
+Apache-2.0

package/dist/chessdotcom-tool.js

@@ -0,0 +1,182 @@
+// Chess.com Public API integration for the UnClick MCP server.
+// Uses the Chess.com Published-Data API via fetch - no external dependencies, no API key required.
+// Documentation: https://www.chess.com/news/view/published-data-api
+const CHESS_BASE = "https://api.chess.com/pub";
+// ─── API helper ──────────────────────────────────────────────────────────────
+async function chessFetch(path) {
+    const res = await fetch(`${CHESS_BASE}${path}`, {
+        headers: {
+            "User-Agent": "UnClick MCP Server",
+            Accept: "application/json",
+        },
+    });
+    if (!res.ok) {
+        if (res.status === 404) {
+            throw new Error(`Not found (HTTP 404). Check the username or resource exists.`);
+        }
+        throw new Error(`Chess.com API HTTP ${res.status}`);
+    }
+    return res.json();
+}
+// ─── Operations ──────────────────────────────────────────────────────────────
+export async function chessPlayer(args) {
+    const username = String(args.username ?? "").trim().toLowerCase();
+    if (!username)
+        throw new Error("username is required.");
+    const data = (await chessFetch(`/player/${username}`));
+    return {
+        username: data.username,
+        name: data.name ?? null,
+        title: data.title ?? null,
+        country: data.country ?? null,
+        location: data.location ?? null,
+        joined: data.joined ? new Date(Number(data.joined) * 1000).toISOString() : null,
+        last_online: data.last_online
+            ? new Date(Number(data.last_online) * 1000).toISOString()
+            : null,
+        followers: data.followers ?? 0,
+        is_streamer: data.is_streamer ?? false,
+        verified: data.verified ?? false,
+        url: data.url ?? null,
+        avatar: data.avatar ?? null,
+    };
+}
+export async function chessPlayerStats(args) {
+    const username = String(args.username ?? "").trim().toLowerCase();
+    if (!username)
+        throw new Error("username is required.");
+    const data = (await chessFetch(`/player/${username}/stats`));
+    const extractRating = (gameType) => {
+        if (!gameType || typeof gameType !== "object")
+            return null;
+        const gt = gameType;
+        const last = gt.last ?? {};
+        const best = gt.best ?? {};
+        const record = gt.record ?? {};
+        return {
+            rating: last.rating ?? null,
+            best_rating: best.rating ?? null,
+            wins: record.win ?? 0,
+            losses: record.loss ?? 0,
+            draws: record.draw ?? 0,
+        };
+    };
+    return {
+        username,
+        chess_rapid: extractRating(data.chess_rapid),
+        chess_blitz: extractRating(data.chess_blitz),
+        chess_bullet: extractRating(data.chess_bullet),
+        chess_daily: extractRating(data.chess_daily),
+        tactics: data.tactics
+            ? {
+                highest: data.tactics.highest ?? null,
+                lowest: data.tactics.lowest ?? null,
+            }
+            : null,
+        puzzle_rush: data.puzzle_rush ?? null,
+    };
+}
+export async function chessPlayerGames(args) {
+    const username = String(args.username ?? "").trim().toLowerCase();
+    if (!username)
+        throw new Error("username is required.");
+    const year = String(args.year ?? "").trim();
+    const month = String(args.month ?? "").trim().padStart(2, "0");
+    if (!year)
+        throw new Error("year is required (e.g. 2024).");
+    if (!args.month)
+        throw new Error("month is required (e.g. 1 for January).");
+    const data = (await chessFetch(`/player/${username}/games/${year}/${month}`));
+    const games = data.games ?? [];
+    return {
+        username,
+        year,
+        month,
+        count: games.length,
+        games: games.slice(-20).map((g) => ({
+            url: g.url,
+            pgn_first_move: g.pgn
+                ? String(g.pgn).split("\n").filter((l) => !l.startsWith("[")).join(" ").trim().slice(0, 100)
+                : null,
+            time_class: g.time_class,
+            time_control: g.time_control,
+            rated: g.rated,
+            white: {
+                username: g.white?.username,
+                result: g.white?.result,
+                rating: g.white?.rating,
+            },
+            black: {
+                username: g.black?.username,
+                result: g.black?.result,
+                rating: g.black?.rating,
+            },
+            end_time: g.end_time
+                ? new Date(Number(g.end_time) * 1000).toISOString()
+                : null,
+        })),
+    };
+}
+export async function chessPuzzlesRandom(_args) {
+    const data = (await chessFetch("/puzzle/random"));
+    return {
+        title: data.title ?? null,
+        url: data.url ?? null,
+        publish_time: data.publish_time
+            ? new Date(Number(data.publish_time) * 1000).toISOString()
+            : null,
+        fen: data.fen ?? null,
+        pgn: data.pgn ?? null,
+        image: data.image ?? null,
+    };
+}
+export async function chessLeaderboards(args) {
+    const data = (await chessFetch("/leaderboards"));
+    const gameType = args.game_type ? String(args.game_type) : null;
+    const validTypes = [
+        "live_rapid",
+        "live_blitz",
+        "live_bullet",
+        "live_bughouse",
+        "live_blitz960",
+        "live_threecheck",
+        "live_crazyhouse",
+        "live_kingofthehill",
+        "tactics",
+        "lessons",
+        "puzzle_rush",
+        "daily",
+        "daily960",
+    ];
+    if (gameType) {
+        if (!validTypes.includes(gameType)) {
+            throw new Error(`game_type must be one of: ${validTypes.join(", ")}`);
+        }
+        const board = data[gameType] ?? [];
+        return {
+            game_type: gameType,
+            count: board.length,
+            players: board.slice(0, 20).map((p) => ({
+                rank: p.rank,
+                username: p.username,
+                score: p.score,
+                title: p.title ?? null,
+                country: p.country ?? null,
+            })),
+        };
+    }
+    const result = {};
+    for (const type of ["live_rapid", "live_blitz", "live_bullet", "daily"]) {
+        const board = data[type] ?? [];
+        result[type] = board.slice(0, 5).map((p) => ({
+            rank: p.rank,
+            username: p.username,
+            score: p.score,
+            title: p.title ?? null,
+        }));
+    }
+    return {
+        note: "Showing top 5 for rapid, blitz, bullet, and daily. Pass game_type for a full leaderboard.",
+        leaderboards: result,
+    };
+}

package/dist/index.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Chess.com MCP. Standalone MCP server by UnClick.
+// By UnClick. 180+ tools plus persistent agent memory in one install: https://unclick.world
+//
+// Generated from the UnClick connector by scripts/generate-standalone-mcp.mjs.
+// Edit the connector in the UnClick monorepo, not here.
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { chessPlayer, chessPlayerStats, chessPlayerGames, chessPuzzlesRandom, chessLeaderboards, } from "./chessdotcom-tool.js";
+const TOOLS = [
+    {
+        name: "chess_player",
+        description: "Get a Chess.com player profile.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                username: { type: "string" },
+            },
+            required: ["username"],
+        },
+    },
+    {
+        name: "chess_player_stats",
+        description: "Get Chess.com player statistics.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                username: { type: "string" },
+            },
+            required: ["username"],
+        },
+    },
+    {
+        name: "chess_player_games",
+        description: "Get recent games for a Chess.com player.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                username: { type: "string" },
+                year: { type: "number" },
+                month: { type: "number" },
+            },
+            required: ["username"],
+        },
+    },
+    {
+        name: "chess_puzzles_random",
+        description: "Get a random chess puzzle from Chess.com.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: "chess_leaderboards",
+        description: "Get Chess.com leaderboards.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {},
+        },
+    }
+];
+const HANDLERS = {
+    chess_player: (args) => chessPlayer(args),
+    chess_player_stats: (args) => chessPlayerStats(args),
+    chess_player_games: (args) => chessPlayerGames(args),
+    chess_puzzles_random: (args) => chessPuzzlesRandom(args),
+    chess_leaderboards: (args) => chessLeaderboards(args),
+};
+const server = new Server({ name: "io.github.malamutemayhem/chessdotcom", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const handler = HANDLERS[req.params.name];
+    if (!handler) {
+        return { content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }], isError: true };
+    }
+    try {
+        const result = await handler((req.params.arguments ?? {}));
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    process.stderr.write(`[chessdotcom-mcp] fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@unclick/chessdotcom-mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.malamutemayhem/chessdotcom",
+  "description": "Chess.com player profiles, stats, games, puzzles, and leaderboards. No API key. By UnClick (https://unclick.world).",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "unclick",
+    "chess",
+    "chess.com",
+    "games"
+  ],
+  "author": "UnClick (https://unclick.world)",
+  "type": "module",
+  "bin": {
+    "chessdotcom-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.15.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/malamutemayhem/unclick.git",
+    "directory": "packages/standalone/chessdotcom-mcp"
+  },
+  "homepage": "https://unclick.world"
+}

package/server.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.malamutemayhem/chessdotcom",
+  "title": "Chess.com MCP by UnClick",
+  "description": "Chess.com player profiles, stats, games, puzzles, and leaderboards. No API key. By UnClick.",
+  "version": "0.1.0",
+  "websiteUrl": "https://unclick.world",
+  "icons": [
+    {
+      "src": "https://unclick.world/favicon.png",
+      "mimeType": "image/png",
+      "sizes": [
+        "512x512"
+      ]
+    }
+  ],
+  "repository": {
+    "url": "https://github.com/malamutemayhem/unclick.git",
+    "source": "github",
+    "subfolder": "packages/standalone/chessdotcom-mcp"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@unclick/chessdotcom-mcp",
+      "version": "0.1.0",
+      "runtimeHint": "npx",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}