cito-mcp 0.1.0 → 0.2.2

package/dist/tools/normalize.js

@@ -0,0 +1,177 @@
+/**
+ * Cross-game row normalization for live/schedule boards and entity cards.
+ */
+import { asRecord, pickString } from '../client.js';
+function sideFrom(name, id, slug, score) {
+    if (!name && !id && !slug)
+        return null;
+    return {
+        name: name ?? slug ?? id ?? '?',
+        ...(id ? { id } : {}),
+        ...(slug ? { slug } : {}),
+        ...(score !== undefined ? { score } : {}),
+    };
+}
+function nestedSide(raw) {
+    const o = asRecord(raw);
+    if (!o) {
+        if (typeof raw === 'string')
+            return { name: raw };
+        return null;
+    }
+    const profile = asRecord(o.profile);
+    const name = pickString(o.name, o.fighterName, o.code, o.shortName, o.nickname, o.displayName, profile?.name, profile?.nickname);
+    const id = pickString(o.id, o.teamId, o.orgId, o.fighterId, profile?.id);
+    const slug = pickString(o.slug, o.orgSlug, o.fighterSlug, profile?.slug);
+    const scoreRaw = o.score ?? o.mapsWon ?? o.gamesWon;
+    const score = typeof scoreRaw === 'number'
+        ? scoreRaw
+        : typeof scoreRaw === 'string' && scoreRaw !== ''
+            ? Number(scoreRaw)
+            : null;
+    return sideFrom(name, id, slug, Number.isFinite(score) ? score : null);
+}
+function scoreNum(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v !== '' && Number.isFinite(Number(v)))
+        return Number(v);
+    return null;
+}
+export function normalizeMatch(game, row, forcedStatus) {
+    const r = asRecord(row) ?? {};
+    const matchId = pickString(r.matchId, r.boutId, r.id, r.gameId, r.match_id, r.dataId, r.fightMetricId) ?? 'unknown';
+    let team1 = nestedSide(r.team1) ??
+        sideFrom(pickString(r.team1Name, r.team_a_name, r.redName, r.fighter1Name, r.homeName), pickString(r.team1Id, r.team1_id, r.redId, r.fighter1Id), pickString(r.team1Slug, r.redSlug, r.fighter1Slug), scoreNum(r.team1Score ?? r.score1 ?? r.team1Maps ?? r.redScore));
+    let team2 = nestedSide(r.team2) ??
+        sideFrom(pickString(r.team2Name, r.team_b_name, r.blueName, r.fighter2Name, r.awayName), pickString(r.team2Id, r.team2_id, r.blueId, r.fighter2Id), pickString(r.team2Slug, r.blueSlug, r.fighter2Slug), scoreNum(r.team2Score ?? r.score2 ?? r.team2Maps ?? r.blueScore));
+    // UFC / live corners: red/blue objects, corner arrays, or fighters[] with corner field.
+    // Public API serializeBout uses fighters:[{ corner, fighterName, fighterSlug, profile:{name,slug} }].
+    // Live tracking uses red/blue + fighters[] (not team1/team2).
+    if (game === 'ufc' || (!team1 && !team2 && (r.red || r.blue || Array.isArray(r.fighters)))) {
+        const fromCornerObj = (raw) => {
+            const o = asRecord(raw);
+            if (!o) {
+                if (typeof raw === 'string' && raw.trim())
+                    return { name: raw.trim() };
+                return null;
+            }
+            // Nested profile from serializeBoutFighter
+            const profile = asRecord(o.profile);
+            const fighter = asRecord(o.fighter);
+            const name = pickString(o.name, o.fighterName, o.displayName, o.nickname, profile?.name, profile?.nickname, fighter?.name, fighter?.nickname);
+            const id = pickString(o.id, o.fighterId, profile?.id, fighter?.id);
+            const slug = pickString(o.slug, o.fighterSlug, profile?.slug, fighter?.slug);
+            const score = scoreNum(o.score ?? o.points);
+            return sideFrom(name, id, slug, score);
+        };
+        team1 =
+            team1 ??
+                fromCornerObj(r.red) ??
+                fromCornerObj(r.redCorner) ??
+                fromCornerObj(r.fighter1) ??
+                fromCornerObj(r.fighterA);
+        team2 =
+            team2 ??
+                fromCornerObj(r.blue) ??
+                fromCornerObj(r.blueCorner) ??
+                fromCornerObj(r.fighter2) ??
+                fromCornerObj(r.fighterB);
+        const fightersList = Array.isArray(r.fighters) ? r.fighters : [];
+        if (fightersList.length) {
+            const byCorner = (want) => fightersList.find((f) => {
+                const c = pickString(asRecord(f)?.corner, asRecord(f)?.side)?.toLowerCase();
+                return c === want || c === want[0]; // "red" / "r"
+            });
+            const redF = byCorner('red') ?? byCorner('r') ?? fightersList[0];
+            const blueF = byCorner('blue') ??
+                byCorner('b') ??
+                (fightersList.length > 1 ? fightersList[1] : undefined);
+            team1 = team1 ?? fromCornerObj(redF);
+            team2 = team2 ?? fromCornerObj(blueF);
+        }
+    }
+    // COD sometimes uses teams[]
+    if ((!team1 || !team2) && Array.isArray(r.teams)) {
+        team1 = team1 ?? nestedSide(r.teams[0]);
+        team2 = team2 ?? nestedSide(r.teams[1]);
+    }
+    const startTime = pickString(r.startTime, r.scheduledAt, r.startsAt, r.date, r.startDate, r.beginAt) ?? null;
+    const statusRaw = pickString(r.status, r.state, r.matchStatus)?.toLowerCase() ?? '';
+    let status = forcedStatus ?? 'unknown';
+    if (!forcedStatus) {
+        if (/live|running|in_?progress|ongoing|started/.test(statusRaw))
+            status = 'live';
+        else if (/upcoming|scheduled|not_started|pending|soon/.test(statusRaw))
+            status = 'upcoming';
+        else if (/complete|finished|ended|final|closed|done/.test(statusRaw))
+            status = 'completed';
+        else if (forcedStatus)
+            status = forcedStatus;
+    }
+    const eventName = pickString(asRecord(r.event)?.name, r.eventName, r.event, asRecord(r.tournament)?.name, r.tournamentName);
+    const eventId = pickString(asRecord(r.event)?.id, r.eventId, asRecord(r.tournament)?.id, r.tournamentId);
+    const eventSlug = pickString(asRecord(r.event)?.slug, r.eventSlug, asRecord(r.tournament)?.slug);
+    const leagueName = pickString(asRecord(r.league)?.name, r.leagueName, r.league, r.leagueSlug);
+    const leagueId = pickString(asRecord(r.league)?.id, r.leagueId);
+    const leagueSlug = pickString(asRecord(r.league)?.slug, r.leagueSlug);
+    const label = pickString(r.label, r.title, r.name) ??
+        `${team1?.name ?? '?'} vs ${team2?.name ?? '?'}`;
+    return {
+        game,
+        matchId,
+        status,
+        startTime,
+        label: label.replace(/\s+/g, ' ').trim(),
+        team1,
+        team2,
+        event: eventName || eventId || eventSlug ? { id: eventId, slug: eventSlug, name: eventName } : null,
+        league: leagueName || leagueId || leagueSlug ? { id: leagueId, slug: leagueSlug, name: leagueName } : null,
+    };
+}
+export function entityRef(row, type, game) {
+    const r = asRecord(row) ?? {};
+    const id = pickString(r.id, r.teamId, r.playerId, r.lolPlayerId, r.codPlayerId, r.matchId, r.boutId, r.eventId, r.tournamentId, r.leagueId) ??
+        pickString(r.slug) ??
+        'unknown';
+    const slug = pickString(r.slug, r.orgSlug, r.teamSlug);
+    const name = pickString(r.name, r.nickname, r.displayName, r.tag, r.code, r.title, slug, id) ?? id;
+    return {
+        game,
+        type,
+        id,
+        ...(slug ? { slug } : {}),
+        name,
+        meta: {
+            ...(r.region ? { region: r.region } : {}),
+            ...(r.role ? { role: r.role } : {}),
+            ...(r.nationality ? { nationality: r.nationality } : {}),
+            ...(r.entity_type ? { entity_type: r.entity_type } : {}),
+        },
+    };
+}
+/** Simple fuzzy score: exact > startsWith > includes (case-insensitive). */
+export function rankScore(query, name, id, slug) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return 0;
+    const candidates = [name, id, slug].filter(Boolean).map((s) => String(s).toLowerCase());
+    let best = 0;
+    for (const c of candidates) {
+        if (c === q)
+            best = Math.max(best, 100);
+        else if (c.startsWith(q))
+            best = Math.max(best, 80 - Math.min(20, c.length - q.length));
+        else if (c.includes(q))
+            best = Math.max(best, 50 - Math.min(20, c.indexOf(q)));
+        else {
+            // token overlap
+            const qt = q.split(/\s+/);
+            const ct = c.split(/[\s_-]+/);
+            const hits = qt.filter((t) => ct.some((x) => x.includes(t) || t.includes(x))).length;
+            if (hits)
+                best = Math.max(best, 20 + hits * 10);
+        }
+    }
+    return best;
+}

package/dist/tools/player.js

@@ -0,0 +1,357 @@
+/**
+ * player_profile
+ */
+import { clampInt, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, } from '../client.js';
+import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
+import { normalizeMatch } from './normalize.js';
+import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
+function identityFrom(game, raw, idHint, slugHint) {
+    const r = asRecord(raw) ?? {};
+    const id = pickString(r.id, r.playerId, r.lolPlayerId, r.codPlayerId, idHint, slugHint) ?? 'unknown';
+    const slug = pickString(r.slug, slugHint);
+    const name = pickString(r.name, r.nickname, r.displayName, r.tag, slug, id) ?? id;
+    const team = asRecord(r.team) ??
+        asRecord(r.currentTeam) ??
+        (r.teamName || r.orgSlug
+            ? { name: r.teamName, slug: r.orgSlug, id: r.teamId }
+            : null);
+    return {
+        id,
+        slug,
+        name,
+        game,
+        team: team
+            ? {
+                id: pickString(asRecord(team)?.id, asRecord(team)?.teamId),
+                slug: pickString(asRecord(team)?.slug, asRecord(team)?.orgSlug),
+                name: pickString(asRecord(team)?.name) ?? '?',
+            }
+            : null,
+        role: pickString(r.role, r.position) ?? null,
+        nationality: pickString(r.nationality, r.country) ?? null,
+    };
+}
+export const playerProfile = {
+    name: 'player_profile',
+    description: `Player or UFC fighter profile: identity, current team, recent matches, and form/trends/radar when available.
+
+When to use:
+- "How is X playing lately?"
+- Player page scaffold; form inputs for previews
+
+Prefer over: manual multi-call career/trends/matches via call_api.
+
+Do not use when: full team roster needed → team_profile; unresolved name → resolve_entity first.
+
+Parallel-safe: yes. Upstream cost: 2–5.
+Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includeTrends": true }`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['game'],
+        properties: {
+            game: gameSchema({ allowAll: false, required: true }),
+            playerId: stringSchema('Pass exactly one of playerId or slug. Example: "cs2-player-1".', 'cs2-player-1'),
+            slug: stringSchema('UFC fighter slug; also accepted where game allows idOrSlug.', 'islam-makhachev'),
+            recentLimit: limitSchema({ default: 10, max: 25, description: 'Recent matches window (default 10, max 25).' }),
+            window: stringSchema('Form/radar window (e.g. Dota radar).'),
+            role: stringSchema('Dota radar role filter.'),
+            includeTrends: boolSchema('Include trends/radar/career enrichment when available.', true),
+            view: {
+                type: 'string',
+                enum: ['summary', 'full'],
+                default: 'summary',
+                description: 'Payload weight. Default summary.',
+            },
+        },
+    },
+    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: 'player_profile',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const game = gameParse.game;
+        const playerId = typeof args.playerId === 'string' ? args.playerId.trim() : '';
+        const slug = typeof args.slug === 'string' ? args.slug.trim() : '';
+        if (!playerId && !slug) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: 'Pass exactly one of playerId or slug',
+                game,
+                source: 'player_profile',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Call resolve_entity with the player/fighter name',
+                    'Retry player_profile with the returned id or slug',
+                ],
+            });
+        }
+        if (playerId && slug && playerId !== slug) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: 'Pass exactly one of playerId or slug (not two different values)',
+                game,
+                source: 'player_profile',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Retry with only playerId, or only slug',
+                    'Use the id/slug from resolve_entity.best',
+                ],
+            });
+        }
+        const idOrSlug = playerId || slug;
+        const recentLimit = clampInt(args.recentLimit, 10, 1, 25);
+        const includeTrends = args.includeTrends !== false;
+        const view = args.view === 'full' ? 'full' : 'summary';
+        const partial = [];
+        let upstreamCalls = 0;
+        let rateLimit = {};
+        let primaryPath = '';
+        if (game === 'lol')
+            primaryPath = `/lol/players/${encodeURIComponent(idOrSlug)}`;
+        else if (game === 'cs2')
+            primaryPath = `/cs2/players/${encodeURIComponent(idOrSlug)}`;
+        else if (game === 'dota2')
+            primaryPath = `/dota2/players`; // list/search; detail via radar
+        else if (game === 'cod')
+            primaryPath = `/cod/players/${encodeURIComponent(idOrSlug)}`;
+        else if (game === 'ufc')
+            primaryPath = `/ufc/fighters/${encodeURIComponent(slug || idOrSlug)}`;
+        let playerRaw = null;
+        if (game === 'dota2') {
+            // Prefer radar as primary signal; try list filter
+            const list = await fetchJson(ctx, '/dota2/players', { query: { search: idOrSlug, limit: 5 } });
+            upstreamCalls += 1;
+            rateLimit = list.headers;
+            if (list.ok) {
+                const rows = extractRows(list.data);
+                playerRaw =
+                    rows.find((row) => {
+                        const r = asRecord(row) ?? {};
+                        const hay = [r.id, r.slug, r.name, r.nickname].map((x) => String(x ?? '').toLowerCase());
+                        return hay.includes(idOrSlug.toLowerCase());
+                    }) ?? rows[0] ?? null;
+            }
+            if (!playerRaw) {
+                // still try radar with idOrSlug
+                playerRaw = { id: idOrSlug, slug: idOrSlug, name: idOrSlug };
+            }
+        }
+        else {
+            const res = await fetchJson(ctx, primaryPath);
+            upstreamCalls += 1;
+            rateLimit = res.headers;
+            if (!res.ok) {
+                return errorEnvelope({
+                    code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                    message: `Player/fighter not found: ${idOrSlug}`,
+                    game,
+                    source: 'player_profile',
+                    requestId,
+                    tookMs: Date.now() - started,
+                    upstreamCalls,
+                    rateLimit: res.headers,
+                    httpStatus: res.status,
+                });
+            }
+            playerRaw = res.data;
+            // some APIs wrap in data
+            const obj = asRecord(res.data);
+            if (obj?.data && typeof obj.data === 'object' && !Array.isArray(obj.data)) {
+                playerRaw = obj.data;
+            }
+        }
+        const player = identityFrom(game, playerRaw, playerId || undefined, slug || undefined);
+        let currentTeam = player.team;
+        let recentMatches = [];
+        let form = null;
+        let career = null;
+        let radar = null;
+        let seasonStats = null;
+        const tasks = [];
+        if (game === 'lol') {
+            tasks.push((async () => {
+                const res = await fetchJson(ctx, `/lol/players/${encodeURIComponent(idOrSlug)}/teams`);
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    const rows = extractRows(res.data);
+                    const first = asRecord(rows[0]);
+                    if (first) {
+                        currentTeam = {
+                            id: pickString(first.id, first.teamId),
+                            slug: pickString(first.slug),
+                            name: pickString(first.name) ?? '?',
+                        };
+                    }
+                }
+                else {
+                    partial.push(partialFromRejection('currentTeam', {
+                        code: mapHttpToCode(res.status),
+                        message: `team history HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+        }
+        if (game === 'cs2' && includeTrends) {
+            for (const [section, path] of [
+                ['career', `/cs2/players/${encodeURIComponent(idOrSlug)}/career`],
+                ['seasonStats', `/cs2/players/${encodeURIComponent(idOrSlug)}/seasons`],
+                ['form', `/cs2/players/${encodeURIComponent(idOrSlug)}/trends`],
+            ]) {
+                tasks.push((async () => {
+                    const res = await fetchJson(ctx, path);
+                    upstreamCalls += 1;
+                    rateLimit = { ...rateLimit, ...res.headers };
+                    if (!res.ok) {
+                        partial.push(partialFromRejection(section, {
+                            code: mapHttpToCode(res.status),
+                            message: `${section} HTTP ${res.status}`,
+                            httpStatus: res.status,
+                        }));
+                        return;
+                    }
+                    if (section === 'career')
+                        career = res.data;
+                    if (section === 'seasonStats')
+                        seasonStats = res.data;
+                    if (section === 'form') {
+                        form = {
+                            summary: 'CS2 trends',
+                            trend: res.data,
+                            window: null,
+                            metrics: asRecord(res.data) ?? res.data,
+                        };
+                    }
+                })());
+            }
+        }
+        if (game === 'dota2' && includeTrends) {
+            tasks.push((async () => {
+                const query = {};
+                if (typeof args.window === 'string')
+                    query.window = args.window;
+                if (typeof args.role === 'string')
+                    query.role = args.role;
+                const res = await fetchJson(ctx, `/dota2/players/${encodeURIComponent(idOrSlug)}/radar`, {
+                    query,
+                });
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    radar = res.data;
+                    form = {
+                        summary: 'Dota radar percentiles',
+                        trend: null,
+                        window: args.window ?? null,
+                        metrics: res.data,
+                    };
+                }
+                else {
+                    partial.push(partialFromRejection('radar', {
+                        code: mapHttpToCode(res.status),
+                        message: `radar HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+        }
+        if (game === 'cod') {
+            tasks.push((async () => {
+                const res = await fetchJson(ctx, `/cod/players/${encodeURIComponent(idOrSlug)}/stats`);
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    seasonStats = res.data;
+                    form = { summary: 'COD season stats', trend: null, window: null, metrics: res.data };
+                }
+                else {
+                    partial.push(partialFromRejection('seasonStats', {
+                        code: mapHttpToCode(res.status),
+                        message: `stats HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+            tasks.push((async () => {
+                const res = await fetchJson(ctx, `/cod/players/${encodeURIComponent(idOrSlug)}/matches`, {
+                    query: { limit: recentLimit },
+                });
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    recentMatches = extractRows(res.data)
+                        .slice(0, recentLimit)
+                        .map((row) => normalizeMatch('cod', row));
+                }
+                else {
+                    partial.push(partialFromRejection('recentMatches', {
+                        code: mapHttpToCode(res.status),
+                        message: `matches HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+        }
+        if (game === 'ufc') {
+            tasks.push((async () => {
+                const res = await fetchJson(ctx, `/ufc/fighters/${encodeURIComponent(slug || idOrSlug)}/stats`);
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    form = { summary: 'UFC fighter stats', trend: null, window: null, metrics: res.data };
+                    seasonStats = res.data;
+                }
+                else {
+                    partial.push(partialFromRejection('form', {
+                        code: mapHttpToCode(res.status),
+                        message: `fighter stats HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+        }
+        await Promise.all(tasks);
+        if (view === 'summary' && recentMatches.length > recentLimit) {
+            recentMatches = recentMatches.slice(0, recentLimit);
+        }
+        return successEnvelope({
+            source: 'player_profile',
+            game,
+            requestId,
+            tookMs: Date.now() - started,
+            upstreamCalls,
+            rateLimit,
+            partial: partial.length ? partial : undefined,
+            entities: {
+                games: [game],
+                ids: {
+                    playerId: player.id,
+                    ...(player.slug ? { slug: player.slug } : {}),
+                },
+            },
+            data: {
+                player,
+                currentTeam,
+                recentMatches,
+                form,
+                career,
+                radar,
+                seasonStats,
+            },
+        });
+    },
+};
+export const playerTools = [playerProfile];