cito-mcp 0.4.4 → 0.4.6

package/dist/tools/team.js

@@ -1,6 +1,3 @@
-/**
- * team_profile + head_to_head
- */
 import { clampInt, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, unwrapPayload, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
 import { normalizeMatch } from './normalize.js';
@@ -9,9 +6,6 @@ function teamIdentity(game, raw, idHint, slugHint) {
     const r = asRecord(raw) ?? {};
     const nested = asRecord(r.data) ?? r;
     const slug = pickString(nested.slug, nested.orgSlug, slugHint);
-    // When the caller asks for an alias the API resolves it, and the resolved
-    // slug is the truth. Falling back to the requested value for `id` produced
-    // id:"t1a" beside slug:"t1-challengers", a row that disagreed with itself.
     const resolved = pickString(nested.slug, nested.orgSlug);
     const id = pickString(nested.id, nested.teamId) ??
         resolved ??
@@ -24,16 +18,11 @@ function teamIdentity(game, raw, idHint, slugHint) {
         name,
         game,
         region: pickString(nested.region, nested.country) ?? null,
-        // CS2 publishes countryName/countryCode and worldRanking on the team
-        // resource and none of it reached this card: a team page rendered with no
-        // flag and no ladder position while the API had both. Spirit came back as
-        // {id, slug, name, game, region} with world #1 nowhere in sight.
         country: pickString(nested.countryName, nested.country, nested.countryCode) ?? null,
         countryCode: pickString(nested.countryCode) ?? null,
         worldRanking: numberOrNull(nested.worldRanking ?? nested.ranking ?? nested.rank),
     };
 }
-/** A finite number, or null. Ranks arrive as number or numeric string. */
 function numberOrNull(value) {
     if (value === null || value === undefined || value === '')
         return null;
@@ -60,10 +49,6 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
         additionalProperties: false,
         required: ['game'],
         properties: {
-            // Tennis is deliberately absent: singles has players, not team rosters,
-            // and advertising it here only to throw NOT_IMPLEMENTED on every call is
-            // a trap — the schema told the caller the request was valid. player_profile
-            // and standings{game:"tennis"} cover the same ground honestly.
             game: {
                 type: 'string',
                 enum: PRIMARY_GAMES.filter((g) => g !== 'tennis'),
@@ -166,9 +151,7 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
             teamRaw = res.data;
         }
         else if (game === 'cs2') {
-            // A cs2-team-<n> / hltv-team-<n> id resolves 1:1 — fetch it directly instead of
-            // name-searching, which could silently fall back to rows[0] of an unrelated search.
-            const directId = /^(cs2|hltv)-team-\d+$/i.test(idOrSlug);
+            const directId = /^[a-z0-9]{3,4}-team-\d+$/i.test(idOrSlug);
             const res = directId
                 ? await fetchJson(ctx, `/cs2/teams/${encodeURIComponent(idOrSlug)}`)
                 : await fetchJson(ctx, '/cs2/teams', { query: { search: idOrSlug, limit: 5 } });
@@ -314,11 +297,6 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                 }
             })());
             tasks.push((async () => {
-                // The matches index, not /lol/schedule. Schedule returned the team's
-                // oldest fixtures: a T1 profile showed MSI 2023 as "recent" while the
-                // index had the 2026 LCK split, newest first. Sort here anyway rather
-                // than trusting upstream order, so the contract holds if either
-                // endpoint changes.
                 const slug = team.slug || idOrSlug;
                 const res = await fetchJson(ctx, `/lol/teams/${encodeURIComponent(slug)}/matches`, {
                     query: { limit: String(recentLimit) },
@@ -330,10 +308,6 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                         const t = Date.parse(String(row?.startTime ?? ''));
                         return Number.isFinite(t) ? t : -Infinity;
                     };
-                    // RECENT means finished AND in the past. The index also carries
-                    // scheduled fixtures, and this path forced every row to
-                    // "completed", so Gen.G and HLE both listed their 2026-09-05
-                    // playoff match as a completed result days before it was played.
                     const nowMs = Date.now();
                     const isFinished = (row) => {
                         const r = asRecord(row) ?? {};
@@ -343,7 +317,6 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                         const state = String(r.state ?? r.status ?? '').toLowerCase();
                         if (/unstarted|scheduled|upcoming|not_?started|in_?progress|live/.test(state))
                             return false;
-                        // No usable state: fall back to the clock plus a decided result.
                         if (!state)
                             return Number.isFinite(t) && t <= nowMs;
                         return /complete|finish|final|ended/.test(state);
@@ -388,9 +361,6 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                 const res = await fetchJson(ctx, `/cs2/teams/${encodeURIComponent(tid)}/trends`);
                 upstreamCalls += 1;
                 rateLimit = { ...rateLimit, ...res.headers };
-                // res.data is the whole upstream body, so this nested
-                // {success, data:{...}} inside our own envelope. Every other field
-                // here is normalized; this one leaked the REST wrapper to the agent.
                 if (res.ok)
                     form = unwrapPayload(res.data) ?? res.data;
                 else {
@@ -631,13 +601,9 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
         let upstreamCalls = 0;
         let rateLimit = {};
         let rows = [];
-        // Names used for client-side side matching; replaced with resolved team names
-        // when the id-based REST H2H succeeds (short inputs like "navi" never substring-match "Natus Vincere").
         let matchA = sideA;
         let matchB = sideB;
         if (game === 'cs2') {
-            // Prefer the purpose-built id-based H2H endpoint; /cs2/matches?team= name-substring
-            // filtering misses short names ("navi" vs stored "Natus Vincere").
             const resolveCs2Side = async (side) => {
                 const res = await fetchJson(ctx, '/cs2/teams', { query: { search: side, limit: 5 } });
                 upstreamCalls += 1;
@@ -662,8 +628,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 upstreamCalls += 1;
                 rateLimit = { ...rateLimit, ...res.headers };
                 if (res.ok) {
-                    // Rows are side-A-perspective summaries (summarizeMatchForTeam); reshape into
-                    // flat match rows so the shared normalize/score pipeline applies unchanged.
                     rows = extractRows(res.data).map((row) => {
                         const r = asRecord(row) ?? {};
                         return {
@@ -726,11 +690,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             rows = extractRows(res.data);
         }
         else if (game === 'lol') {
-            // First-class H2H. The old path pulled sideA's /lol/schedule and filtered
-            // client-side, which missed meetings and returned the oldest first, so a
-            // T1 vs HLE rivalry showed 2023 games and called the earliest one the
-            // "last meeting". This endpoint states the record outright (22 meetings,
-            // 8-13) and lists them newest first.
             const h2hRes = await fetchJson(ctx, `/lol/teams/${encodeURIComponent(sideA)}/h2h/${encodeURIComponent(sideB)}`, { query: { limit: String(limit) } });
             upstreamCalls += 1;
             rateLimit = { ...rateLimit, ...h2hRes.headers };
@@ -753,9 +712,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                         matchId: pickString(r.matchId) ?? null,
                         startTime: pickString(r.date) ?? null,
                         tournamentName: pickString(r.tournamentName) ?? null,
-                        // The feed gives scores in the match's own team order, which it
-                        // does not label, so they are reported as-is rather than being
-                        // assigned to a side we would be guessing at.
                         team1Score: typeof r.team1Score === 'number' ? r.team1Score : null,
                         team2Score: typeof r.team2Score === 'number' ? r.team2Score : null,
                         winnerSlug: pickString(r.winner) ?? null,
@@ -829,7 +785,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             rows = extractRows(res.data);
         }
         else if (game === 'ufc') {
-            // Use fighter fight history (not global /bouts page 1, which rarely contains both fighters).
             const [aRes, bRes, histA, histB] = await Promise.all([
                 fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(sideA)}`),
                 fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(sideB)}`),
@@ -854,15 +809,11 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 });
             }
             const toBouts = (payload) => extractRows(payload).map((row) => {
-                // History rows carry the two corners as fighterSlug/opponent, not on
-                // the nested bout. Dropping them here is why Jones vs Cormier reported
-                // zero meetings while the profile listed both fights.
                 const r = asRecord(row) ?? {};
                 return { ...(asRecord(r.bout) ?? {}), ...r };
             });
             const fromA = histA.ok ? toBouts(histA.data) : [];
             const fromB = histB.ok ? toBouts(histB.data) : [];
-            // Union by bout id
             const byId = new Map();
             for (const bout of [...fromA, ...fromB]) {
                 const m = normalizeMatch('ufc', bout);
@@ -876,7 +827,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             }
         }
         if (game === 'tennis') {
-            // Tennis has a first-class H2H endpoint; resolve names to player ids first when needed.
             const resolveTennisSide = async (side) => {
                 if (/^(atp|wta)_\d+$/i.test(side))
                     return { id: side, name: side };
@@ -928,14 +878,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             }
             const envelope = asRecord(res.data) ?? {};
             const h2h = asRecord(envelope.data) ?? envelope;
-            // The id-shaped shortcut above never resolves a name — sideA:"atp_207989"
-            // came in already looking like an id, so resolveTennisSide handed back
-            // {id: side, name: side} without ever asking who that id belongs to. The
-            // /tennis/h2h payload already states both names one level down (its own
-            // player1/player2, keyed by the same player1_id/player2_id this request
-            // just sent), so read from there rather than trusting the resolver's
-            // name at all: it is authoritative and always available once the H2H
-            // call itself succeeded.
             const h2hP1 = asRecord(h2h.player1);
             const h2hP2 = asRecord(h2h.player2);
             const sideAName = pickString(h2hP1?.name) ?? tA.name;
@@ -957,15 +899,13 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
         }
         const meetings = rows
             .map((row) => normalizeMatch(game, row))
-            // Past fights only. The booked bout between the two sides is in the
-            // same list and is not a meeting yet.
             .filter((m) => m.status === 'completed')
             .filter((m) => sidesMatch(m, matchA, matchB))
             .filter((m) => {
             if (!fromIso && !toIso)
                 return true;
             if (!m.startTime)
-                return true; // keep undated rows; date filter is best-effort
+                return true;
             const t = Date.parse(m.startTime);
             if (Number.isNaN(t))
                 return true;
@@ -975,10 +915,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 return false;
             return true;
         })
-            // Newest first. Nothing sorted this before, so `lastMeeting` below was
-            // whichever row the upstream happened to return first, which on an
-            // ascending feed is the OLDEST meeting. It also means a limit cut off the
-            // recent games rather than the ancient ones.
             .sort((a, b) => {
             const ta = a.startTime ? Date.parse(a.startTime) : NaN;
             const tb = b.startTime ? Date.parse(b.startTime) : NaN;
@@ -1022,21 +958,6 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
         });
     },
 };
-/**
- * h2h_matrix (TENNIS-24, cycle 60).
- *
- * Tennis-only: multi-player head-to-head comparison grid from the first-class
- * GET /tennis/h2h/matrix route (2-16 player ids, comma-separated). Upstream
- * shape (verified 2026-09-09): { players: [{ id, name, ioc, wins }], matrix:
- * { [rowId]: { [colId]: "W-L" | "-" } } }. Cell "7-6" at [A][B] means A won 7
- * and B won 6 of their meetings; "-" marks the self diagonal. Unknown ids get
- * honest 0-0 cells and no players entry (no 404); fewer than 2 or more than 16
- * ids 422, which surfaces as VALIDATION here.
- *
- * Names are resolved to atp_/wta_ ids via /tennis/players/search first (same
- * id-shaped shortcut as the head_to_head tennis branch); duplicates collapse
- * to one grid row.
- */
 export const h2hMatrix = {
     name: 'h2h_matrix',
     description: `Multi-player tennis head-to-head grid: every pair's series record in one comparison matrix.
@@ -1145,8 +1066,6 @@ Parallel-safe: yes. Upstream cost: 1 + one search per unresolved name.`,
                 ],
             });
         }
-        // Dedupe resolved ids preserving order: REST dict keys would collapse
-        // anyway, but players_info would list the duplicate twice.
         const ids = [...new Set(resolved.map((r) => r.id))];
         if (ids.length < 2) {
             return errorEnvelope({

package/dist/tools/tournaments.js

@@ -1,21 +1,7 @@
-/**
- * tournaments — tennis tournament discovery (TENNIS-25).
- *
- * WHY THIS EXISTS
- * event_card already renders a tournament Profile/Draw, but only once you know a
- * tournament id. There was no way to ASK for tournaments — so "list the 2026
- * WTA 1000 events" or "what ATP 250s are on clay" was impossible without
- * call_api, even though /tennis/tournaments supports exactly those filters
- * (year, tour, level, surface, country) and the level filter was recently made
- * to accept names like "WTA 1000" rather than only raw tier codes.
- *
- * This tool is the discovery half; event_card stays the detail half.
- */
 import { asRecord, clampInt, fetchJson, gameNotIncludedHint, pickString, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, successEnvelope, } from '../envelope.js';
 import { gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
 const SURFACES = ['Hard', 'Clay', 'Grass', 'Carpet'];
-/** Human level names the API accepts on ?level=, plus the raw tier codes. */
 const LEVEL_NAMES = [
     'Grand Slam',
     'Masters 1000',
@@ -42,9 +28,6 @@ function normalizeTournament(row) {
         name: pickString(r.name) ?? null,
         tour: pickString(r.tour) ?? null,
         year: num(r.year),
-        // `tier` is the human level the API derives from the tier code; `level` is
-        // the raw code. Both are surfaced because callers filter on the name but
-        // cross-reference by the code.
         level: pickString(r.tier) ?? pickString(r.level) ?? null,
         levelCode: pickString(r.tier_code, r.level) ?? null,
         category: pickString(r.category) ?? null,
@@ -174,25 +157,6 @@ Parallel-safe: yes. Upstream cost: 1.`,
                 });
             }
         }
-        /**
-         * A level name that starts with a tour token constrains the tour, and the
-         * upstream filter does not know that.
-         *
-         * The API's reverse level map is not tour-aware: `_TIER_WTA` carries BOTH
-         * "PM" and "M" as "WTA 1000" (M is the fallback label for a WTA row stored
-         * with the ATP code), so `?level=WTA 1000` resolves to `tier_code IN
-         * ('PM','M')` and returns every ATP Masters 1000 event alongside the WTA
-         * ones. Verified live: asking for "WTA 1000" returned Rome Masters, Madrid
-         * Masters, Monte Carlo, Miami Masters and Indian Wells Masters (all ATP).
-         * The same widening hits "WTA 125" (code C, shared with ATP Challengers) and
-         * "ATP 500"/"ATP 250" (code A, shared with WTA tour-level rows).
-         *
-         * The tool therefore asserts the invariant the label states: it sends the
-         * tour, and it verifies the rows that come back. Rows that contradict the
-         * requested level are dropped and counted rather than passed through as
-         * "close enough" — a filter that returns other-tour events is worse than a
-         * filter that returns nothing, because the caller has no way to notice.
-         */
         const levelTourPrefix = (() => {
             const m = /^(ATP|WTA)\b/i.exec(levelRaw);
             return m ? m[1].toUpperCase() : null;
@@ -246,7 +210,6 @@ Parallel-safe: yes. Upstream cost: 1.`,
         const root = asRecord(res.data) ?? {};
         const body = asRecord(root.data) ?? root;
         const rawItems = (Array.isArray(body.items) ? body.items : []).map(normalizeTournament);
-        // Verify the invariant the level label states. See levelTourPrefix above.
         const contradictions = levelTourPrefix
             ? rawItems.filter((t) => t.tour && t.tour.toUpperCase() !== levelTourPrefix)
             : [];

package/dist/tools/types.js

@@ -1,5 +1,4 @@
 import { ENVELOPE_OUTPUT_SCHEMA, toMcpResult } from '../envelope.js';
-/** All curated tools fetch Cito data. None delete, post, or mutate user state. */
 export const READ_TOOL_ANNOTATIONS = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -79,7 +78,6 @@ export function stringSchema(description, example) {
         schema.examples = [example];
     return schema;
 }
-/** Levenshtein distance, capped for short arg names. */
 function editDistance(a, b) {
     const m = a.length;
     const n = b.length;
@@ -93,7 +91,6 @@ function editDistance(a, b) {
     }
     return prev[n];
 }
-/** Closest known parameter to a mistyped one, if it is plausibly a typo. */
 function suggestParam(unknown, known) {
     const u = unknown.toLowerCase();
     let best = null;
@@ -104,24 +101,12 @@ function suggestParam(unknown, known) {
     }
     if (!best)
         return null;
-    // Accept near-misses, plus prefix relationships like query -> q.
     const threshold = Math.max(2, Math.floor(Math.max(u.length, best.name.length) / 3));
     if (best.d <= threshold)
         return best.name;
     const prefixHit = known.find((k) => u.startsWith(k.toLowerCase()) || k.toLowerCase().startsWith(u));
     return prefixHit ?? null;
 }
-/**
- * Args the tool does not declare, when its schema says additionalProperties:false.
- *
- * Every tool already declared that, but nothing enforced it: the MCP SDK does
- * not validate arguments against inputSchema, so a plausible-but-wrong name was
- * dropped on the floor and the tool ran with a default. search_entities
- * { game:"ufc", query:"Jon Jones" } — `q` is the real parameter — returned
- * ok:true with an unrelated roster. Silently wrong beats loudly wrong for a
- * human skimming output, but for an agent it is far worse: it has no way to
- * tell a real answer from a discarded question.
- */
 export function unknownArgKeys(def, args) {
     const schema = def.inputSchema ?? {};
     if (schema.additionalProperties !== false)
@@ -132,7 +117,6 @@ export function unknownArgKeys(def, args) {
     const known = Object.keys(props);
     return Object.keys(args ?? {}).filter((k) => !known.includes(k));
 }
-/** Normalize MCP handler return to MCP content result. */
 export async function runTool(def, args, ctx) {
     try {
         const unknown = unknownArgKeys(def, args ?? {});
@@ -144,7 +128,6 @@ export async function runTool(def, args, ctx) {
             return toResult(errorEnvelope({
                 code: 'VALIDATION',
                 message: `${def.name}: unknown argument${unknown.length > 1 ? 's' : ''} ` +
-                    // Avoid "?." when the last hint is a did-you-mean question.
                     `${hints.join('; ')}${hints[hints.length - 1].endsWith('?') ? '' : '.'} ` +
                     `Accepted: ${known.join(', ')}.`,
                 game: typeof args?.game === 'string' ? args.game : null,

package/dist/version.js

@@ -1,19 +1,4 @@
 import { createRequire } from 'node:module';
-/**
- * Single source of truth for the server version.
- *
- * This used to be hardcoded in three places — package.json, PACKAGE_VERSION in
- * index.ts, and CATALOG_VERSION in tools/meta.ts — which had already drifted:
- * a test asserted 0.2.4 while the package shipped 0.2.5. Agents read the version
- * out of list_capabilities, so a stale value there is a support problem, not a
- * cosmetic one. Read it from the manifest instead, so `npm version` is the only
- * edit a release needs.
- *
- * createRequire rather than a JSON import: import assertions are still awkward
- * across the Node versions this package supports (>=20), and this resolves the
- * same from src/ under tsx and from dist/ once built, because package.json is
- * always published alongside dist.
- */
 const require = createRequire(import.meta.url);
 function readVersion() {
     try {
@@ -21,8 +6,6 @@ function readVersion() {
         return typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
     }
     catch {
-        // Never let a packaging quirk crash the server on boot; a wrong-but-present
-        // version is far better than a failed start.
         return '0.0.0';
     }
 }

package/package.json

@@ -1,8 +1,28 @@
 {
   "name": "cito-mcp",
-  "version": "0.4.4",
-  "description": "Standalone MCP server for the Cito esports and sports API — 42 curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
+  "version": "0.4.6",
+  "description": "Standalone MCP server for the Cito esports and sports API — curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
   "type": "module",
+  "homepage": "https://cito.gg",
+  "//REPOSITORY": "Intentionally NOT set. cito-api-scraper and cito.gg are PRIVATE repos and must stay that way, so a repository URL pointing at them would render as a broken 404 link on the public npm page and would not satisfy MCP Registry npm ownership validation. Set this only if a PUBLIC repo for this package is ever created (e.g. achillesscriptsvip/cito-mcp with this directory as root) — then use `git+https://github.com/OWNER/REPO.git` and mirror it in the `mcpName`/server.json `name` pair. Do not point it at the private monorepo.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "esports",
+    "cs2",
+    "counter-strike",
+    "counter-strike-2",
+    "lol",
+    "league-of-legends",
+    "dota2",
+    "cod",
+    "ufc",
+    "mma",
+    "tennis",
+    "live-scores",
+    "sports-data",
+    "esports-api"
+  ],
   "bin": {
     "cito-mcp": "dist/index.js"
   },