cito-mcp 0.1.0 → 0.2.2

package/dist/tools/standings.js

@@ -0,0 +1,319 @@
+/**
+ * standings
+ */
+import { clampInt, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, } from '../client.js';
+import { errorEnvelope, mapHttpToCode, newRequestId, successEnvelope, } from '../envelope.js';
+import { gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
+function normalizeStandingRow(row, index) {
+    const r = asRecord(row) ?? {};
+    const entity = asRecord(r.team) ?? asRecord(r.fighter) ?? asRecord(r.org) ?? r;
+    const name = pickString(asRecord(entity)?.name, r.teamName, r.name, r.orgName, r.fighterName, asRecord(entity)?.slug) ?? `row-${index + 1}`;
+    // UFC official lists: champion has rank=null + rankText="C"; contenders 1..15.
+    // Never fall back to index+1 for null ranks — that produced two "#1" rows (champ + #1).
+    const championStatus = pickString(r.championStatus, asRecord(entity)?.championStatus);
+    const rankText = pickString(r.rankText);
+    const isChampion = championStatus === 'champion' ||
+        rankText === 'C' ||
+        r.isChampion === true ||
+        r.isTitleHolder === true;
+    let rank;
+    if (isChampion) {
+        rank = 'C';
+    }
+    else if (typeof r.rank === 'number') {
+        rank = r.rank;
+    }
+    else if (typeof r.position === 'number') {
+        rank = r.position;
+    }
+    else if (rankText && /^\d+$/.test(rankText)) {
+        rank = Number(rankText);
+    }
+    else if (r.rank === null && rankText) {
+        rank = rankText;
+    }
+    else {
+        rank = index + 1;
+    }
+    return {
+        rank,
+        rankText: rankText ?? (typeof rank === 'number' || typeof rank === 'string' ? String(rank) : null),
+        championStatus: isChampion ? 'champion' : championStatus === 'interim' ? 'interim' : 'none',
+        teamOrFighter: {
+            id: pickString(asRecord(entity)?.id, r.teamId, r.fighterId, r.orgId, r.id),
+            slug: pickString(asRecord(entity)?.slug, r.orgSlug, r.teamSlug, r.slug, r.fighterSlug),
+            name,
+        },
+        played: r.played ?? r.gamesPlayed ?? r.matches ?? null,
+        wins: r.wins ?? r.w ?? null,
+        losses: r.losses ?? r.l ?? null,
+        draws: r.draws ?? r.ties ?? null,
+        points: r.points ?? r.pts ?? r.score ?? null,
+        mapDiff: r.mapDiff ?? r.gameDiff ?? r.diff ?? null,
+        streak: r.streak ?? null,
+        meta: {
+            ...(r.division ? { division: r.division } : {}),
+            ...(r.normalizedDivision ? { normalizedDivision: r.normalizedDivision } : {}),
+            ...(r.region ? { region: r.region } : {}),
+            ...(isChampion ? { isChampion: true } : {}),
+        },
+    };
+}
+export const standings = {
+    name: 'standings',
+    description: `League/event standings or world/division rankings normalized to ranked rows.
+
+When to use:
+- Table / playoff picture
+- UFC rankings; CS2 world or event standings; CDL standings; LoL league/tournament tables
+
+Prefer over: raw standings via call_api for agent-normalized rows.
+
+Do not use when: single team form → team_profile; live scores → live_matches.
+Dota has no first-class standings (may NOT_IMPLEMENTED or weak worldRanking).
+
+Required scope keys by game:
+- lol: leagueId OR tournamentId
+- cs2: omit for world rankings; eventId for event standings
+- cod: optional season/stage
+- ufc: optional division (scope=division)
+- dota2: best-effort worldRanking only
+
+Parallel-safe: yes. Upstream cost: 1–2.
+Example: { "game": "cod", "season": "2026", "limit": 50 }`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['game'],
+        properties: {
+            game: gameSchema({ allowAll: false, required: true }),
+            scope: {
+                type: 'string',
+                enum: ['league', 'tournament', 'event', 'world', 'division'],
+                description: 'Interpretation depends on game; defaults sensibly per game.',
+            },
+            leagueId: stringSchema('LoL league id for league standings.'),
+            tournamentId: stringSchema('LoL/COD tournament id.'),
+            eventId: stringSchema('CS2 event id for event standings.'),
+            season: stringSchema('Season key (COD).'),
+            stage: stringSchema('Stage key (COD / LoL).'),
+            division: stringSchema('UFC division key.'),
+            limit: limitSchema({ default: 50, max: 100 }),
+        },
+    },
+    handler: async (args, ctx) => {
+        const started = Date.now();
+        const requestId = newRequestId();
+        const gameParse = parseGame(args.game, { allowAll: false, required: true });
+        if (gameParse.error || !gameParse.game || !isPrimaryGame(gameParse.game)) {
+            return errorEnvelope({
+                code: gameParse.error?.includes('unsupported') ? 'UNSUPPORTED_GAME' : 'VALIDATION',
+                message: gameParse.error ?? 'game is required',
+                game: null,
+                source: 'standings',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const game = gameParse.game;
+        const limit = clampInt(args.limit, 50, 1, 100);
+        const scope = typeof args.scope === 'string' ? args.scope : undefined;
+        const leagueId = typeof args.leagueId === 'string' ? args.leagueId : undefined;
+        const tournamentId = typeof args.tournamentId === 'string' ? args.tournamentId : undefined;
+        const eventId = typeof args.eventId === 'string' ? args.eventId : undefined;
+        const season = typeof args.season === 'string' ? args.season : undefined;
+        const stage = typeof args.stage === 'string' ? args.stage : undefined;
+        const division = typeof args.division === 'string' ? args.division : undefined;
+        let path = '';
+        let query = {};
+        let title = `${game} standings`;
+        let effectiveScope = scope ?? 'world';
+        if (game === 'lol') {
+            if (tournamentId || scope === 'tournament') {
+                if (!tournamentId) {
+                    return errorEnvelope({
+                        code: 'VALIDATION',
+                        message: 'tournamentId required for LoL tournament standings',
+                        game,
+                        source: 'standings',
+                        requestId,
+                        tookMs: Date.now() - started,
+                    });
+                }
+                path = `/lol/tournaments/${encodeURIComponent(tournamentId)}/standings`;
+                effectiveScope = 'tournament';
+                title = `LoL tournament ${tournamentId}`;
+            }
+            else {
+                if (!leagueId) {
+                    return errorEnvelope({
+                        code: 'VALIDATION',
+                        message: 'leagueId (or tournamentId) required for LoL standings',
+                        game,
+                        source: 'standings',
+                        requestId,
+                        tookMs: Date.now() - started,
+                        recover: [
+                            'Call search_entities or resolve_entity for the league',
+                            'Retry standings with leagueId or tournamentId',
+                        ],
+                    });
+                }
+                path = `/lol/leagues/${encodeURIComponent(leagueId)}/standings`;
+                query = { ...(season ? { season } : {}), ...(stage ? { stage } : {}) };
+                effectiveScope = 'league';
+                title = `LoL league ${leagueId}`;
+            }
+        }
+        else if (game === 'cs2') {
+            if (eventId || scope === 'event') {
+                if (!eventId) {
+                    return errorEnvelope({
+                        code: 'VALIDATION',
+                        message: 'eventId required for CS2 event standings',
+                        game,
+                        source: 'standings',
+                        requestId,
+                        tookMs: Date.now() - started,
+                    });
+                }
+                path = `/cs2/events/${encodeURIComponent(eventId)}/standings`;
+                effectiveScope = 'event';
+                title = `CS2 event ${eventId}`;
+            }
+            else {
+                path = '/cs2/rankings/teams';
+                query = { limit };
+                effectiveScope = 'world';
+                title = 'CS2 world team rankings';
+            }
+        }
+        else if (game === 'cod') {
+            path = '/cod/standings';
+            query = {
+                ...(season ? { season } : {}),
+                ...(stage ? { stage } : {}),
+            };
+            effectiveScope = scope ?? 'league';
+            title = 'CDL standings';
+        }
+        else if (game === 'ufc') {
+            if (division || scope === 'division') {
+                path = division
+                    ? `/ufc/rankings/media/${encodeURIComponent(division)}`
+                    : '/ufc/rankings/media';
+                effectiveScope = 'division';
+                title = division ? `UFC ${division} rankings` : 'UFC media rankings';
+            }
+            else {
+                path = '/ufc/rankings';
+                effectiveScope = 'world';
+                title = 'UFC rankings';
+            }
+        }
+        else if (game === 'dota2') {
+            // No first-class standings — try team list worldRanking
+            const res = await fetchJson(ctx, '/dota2/teams', { query: { limit } });
+            if (!res.ok) {
+                return errorEnvelope({
+                    code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                    message: 'Dota standings unavailable',
+                    game,
+                    source: 'standings',
+                    requestId,
+                    tookMs: Date.now() - started,
+                    upstreamCalls: 1,
+                    httpStatus: res.status,
+                    rateLimit: res.headers,
+                });
+            }
+            const rows = extractRows(res.data)
+                .map((row, i) => {
+                const r = asRecord(row) ?? {};
+                const rank = r.worldRanking ?? r.rank ?? i + 1;
+                return normalizeStandingRow({ ...r, rank }, i);
+            })
+                .filter((row) => row.rank != null)
+                .sort((a, b) => Number(a.rank) - Number(b.rank))
+                .slice(0, limit);
+            if (rows.length === 0) {
+                return errorEnvelope({
+                    code: 'NOT_IMPLEMENTED',
+                    message: 'Dota 2 has no first-class standings endpoint',
+                    game,
+                    source: 'standings',
+                    requestId,
+                    tookMs: Date.now() - started,
+                    upstreamCalls: 1,
+                    recover: [
+                        'Use team_profile with radar for style/form',
+                        'Use call_api if a standings path is added later',
+                    ],
+                });
+            }
+            return successEnvelope({
+                source: 'standings',
+                game,
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls: 1,
+                rateLimit: res.headers,
+                warnings: ['Dota standings composed from team worldRanking fields; sparse'],
+                data: {
+                    scope: 'world',
+                    title: 'Dota 2 world ranking (best-effort)',
+                    season: null,
+                    stage: null,
+                    rows,
+                    updatedAt: null,
+                },
+            });
+        }
+        const res = await fetchJson(ctx, path, { query });
+        if (!res.ok) {
+            return errorEnvelope({
+                code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                message: `Standings failed (HTTP ${res.status})`,
+                game,
+                source: 'standings',
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls: 1,
+                httpStatus: res.status,
+                rateLimit: res.headers,
+            });
+        }
+        let rows = extractRows(res.data).map((row, i) => normalizeStandingRow(row, i)).slice(0, limit);
+        // UFC rankings may be nested by division
+        if (game === 'ufc' && rows.length === 0) {
+            const obj = asRecord(res.data) ?? {};
+            const nested = [];
+            for (const value of Object.values(obj)) {
+                if (Array.isArray(value))
+                    nested.push(...value);
+                else if (asRecord(value) && Array.isArray(asRecord(value).rankings)) {
+                    nested.push(...asRecord(value).rankings);
+                }
+            }
+            rows = nested.map((row, i) => normalizeStandingRow(row, i)).slice(0, limit);
+        }
+        const obj = asRecord(res.data);
+        return successEnvelope({
+            source: 'standings',
+            game,
+            requestId,
+            tookMs: Date.now() - started,
+            upstreamCalls: 1,
+            rateLimit: res.headers,
+            data: {
+                scope: effectiveScope,
+                title,
+                season: season ?? null,
+                stage: stage ?? null,
+                rows,
+                updatedAt: pickString(obj?.updatedAt, obj?.lastUpdated) ?? null,
+            },
+        });
+    },
+};
+export const standingsTools = [standings];