claudial 0.1.3 → 0.2.0

package/README.md

@@ -123,18 +123,20 @@ v1 is being built live during the group stage. Follow the commits.
 
 ## Notes
 
-- Match data comes from SofaScore's public endpoints. This project is
-  unofficial and not affiliated with SofaScore.
+- Match data comes from [ESPN's public soccer scoreboard](https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard)
+  — facts only (scores, scorers, cards), no logos or branding. See
+  [DATA.md](DATA.md) for why this source. Not affiliated with or endorsed by
+  ESPN or FIFA.
 - Not affiliated with Anthropic. The aesthetic is a love letter to
   [Claude Code](https://claude.com/claude-code), whose terminal UI this
   proudly imitates.
-- Polling is deliberately gentle (15 s live, 5 min fixtures). Please keep
-  it that way.
+- Polling is deliberately gentle (15 s live, 5 min fixtures), and a single
+  scoreboard call serves all live matches at once. Please keep it that way.
 
 ```js
 // Canada — Bosnia & Herzegovina, 12 June 2026, was on while this was built.
-// Jovo Lukić's 21' goal was the first one this codebase ever saw — it hit
-// the API smoke test before any UI existed to celebrate it. Legendary.
+// Jovo Lukić's 21' goal was the first one this codebase ever saw — it showed
+// up in a smoke test before any UI existed to celebrate it. Legendary.
 ```
 
 ## License

package/dist/api/espn.js

@@ -0,0 +1,66 @@
+import { parseEvent, parseIncidents } from './parse.js';
+// ESPN's public soccer scoreboard for the FIFA World Cup (league fifa.world).
+// Keyless, served openly to ESPN's own web/apps, facts-only. One call returns
+// every match for a date (or date range) with goals and cards inline.
+const BASE = 'https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world';
+async function get(path) {
+    const res = await fetch(`${BASE}${path}`, { headers: { Accept: 'application/json' } });
+    if (!res.ok)
+        throw new Error(`espn ${res.status} ${path}`);
+    const text = await res.text();
+    if (!text)
+        throw new Error(`espn empty body ${path}`);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`espn: malformed JSON from ${path}: ${text.slice(0, 120)}`);
+    }
+}
+function yyyymmdd(d) {
+    return `${d.getUTCFullYear()}${String(d.getUTCMonth() + 1).padStart(2, '0')}${String(d.getUTCDate()).padStart(2, '0')}`;
+}
+// Brief cache so one live tick (live + per-match incidents) is a single fetch.
+const cache = new Map();
+const CACHE_MS = 5_000;
+async function scoreboard(dates) {
+    const hit = cache.get(dates);
+    if (hit && Date.now() - hit.at < CACHE_MS)
+        return hit.events;
+    const data = await get(`/scoreboard?dates=${dates}`);
+    const events = data.events ?? [];
+    cache.set(dates, { at: Date.now(), events });
+    return events;
+}
+function todayRange(daysAhead) {
+    const now = new Date();
+    const start = yyyymmdd(now);
+    if (daysAhead <= 0)
+        return start;
+    const end = new Date(now.getTime() + daysAhead * 86_400_000);
+    return `${start}-${yyyymmdd(end)}`;
+}
+// Kept for call-site compatibility; ESPN needs no season id to query.
+export async function resolveSeasonId() {
+    return 2026;
+}
+export async function fetchLive() {
+    const events = await scoreboard(todayRange(0));
+    return events.map(parseEvent).filter((m) => m.status === 'live' || m.status === 'halftime');
+}
+export async function fetchUpcoming(_seasonId) {
+    const events = await scoreboard(todayRange(10));
+    return events
+        .map(parseEvent)
+        .filter((m) => m.status === 'upcoming')
+        .sort((a, b) => a.startTimestamp - b.startTimestamp);
+}
+export async function fetchRecent(_seasonId) {
+    const events = await scoreboard(todayRange(0));
+    return events.map(parseEvent).filter((m) => m.status === 'finished');
+}
+export async function fetchIncidents(eventId) {
+    const events = await scoreboard(todayRange(0));
+    const event = events.find((e) => Number(e.id) === eventId);
+    return event ? parseIncidents(event) : [];
+}

package/dist/api/parse.js

@@ -1,114 +1,103 @@
-export const WORLD_CUP_ID = 16;
-export function isWorldCup(raw) {
-    return raw?.tournament?.uniqueTournament?.id === WORLD_CUP_ID;
-}
+// claudial parses ESPN's public soccer scoreboard (league fifa.world).
+// One scoreboard response carries every match for a date plus, inline, each
+// match's goals and cards — so a single request powers scores, scorer lines,
+// and goal/red-card takeovers. Substitutions and VAR live only in ESPN's heavy
+// per-match summary endpoint and are intentionally not used here.
 function toStatus(raw) {
     const t = raw?.status?.type;
-    if (t === 'inprogress') {
-        return raw.status?.description === 'Halftime' ? 'halftime' : 'live';
-    }
-    if (t === 'finished')
+    const state = t?.state;
+    if (state === 'in')
+        return t?.name === 'STATUS_HALFTIME' ? 'halftime' : 'live';
+    if (state === 'post')
         return 'finished';
     return 'upcoming';
 }
-export function toMinute(raw, nowSeconds) {
-    const time = raw?.time;
-    if (raw?.status?.type !== 'inprogress' || !time?.currentPeriodStartTimestamp)
+function competitor(raw, side) {
+    const comps = raw?.competitions?.[0]?.competitors ?? [];
+    return comps.find((c) => c.homeAway === side) ?? {};
+}
+function teamOf(c) {
+    const t = c?.team ?? {};
+    return {
+        name: t.displayName ?? t.shortDisplayName ?? t.name ?? '?',
+        code: t.abbreviation ?? t.shortDisplayName ?? '?',
+    };
+}
+function scoreOf(c, status) {
+    if (status === 'upcoming')
         return null;
-    if (raw.status?.description === 'Halftime')
+    const n = Number(c?.score);
+    return Number.isFinite(n) ? n : null;
+}
+/** "21'" -> 21, "90'+7'" -> 90, "HT"/"" -> null */
+function minuteOf(raw, status) {
+    if (status !== 'live')
         return null;
-    const played = (time.initial ?? 0) + (nowSeconds - time.currentPeriodStartTimestamp);
-    // football minutes are 1-based: 0–59s of play is the 1st minute
-    const minute = Math.floor(played / 60) + 1;
-    return Math.min(minute, Math.ceil((time.max ?? 5400) / 60));
+    const m = /(\d+)/.exec(raw?.status?.displayClock ?? '');
+    return m ? Number(m[1]) : null;
 }
-export function parseEvent(raw, nowSeconds) {
-    const group = /Group [A-L]/.exec(raw?.tournament?.name ?? '')?.[0] ?? null;
+export function parseEvent(raw) {
+    const status = toStatus(raw);
+    const home = competitor(raw, 'home');
+    const away = competitor(raw, 'away');
     return {
-        id: raw.id,
-        group,
-        home: { name: raw.homeTeam?.name ?? '?', code: raw.homeTeam?.nameCode ?? raw.homeTeam?.shortName ?? '' },
-        away: { name: raw.awayTeam?.name ?? '?', code: raw.awayTeam?.nameCode ?? raw.awayTeam?.shortName ?? '' },
-        homeScore: raw.homeScore?.current ?? null,
-        awayScore: raw.awayScore?.current ?? null,
-        status: toStatus(raw),
-        statusText: raw.status?.description ?? '',
-        minute: toMinute(raw, nowSeconds),
-        startTimestamp: raw.startTimestamp ?? 0,
-        // live feed sends an object ({ homeTeam, awayTeam }); be tolerant of a plain boolean too
-        varInProgress: typeof raw.varInProgress === 'object' && raw.varInProgress !== null
-            ? !!(raw.varInProgress.homeTeam || raw.varInProgress.awayTeam)
-            : !!raw.varInProgress,
+        id: Number(raw.id),
+        group: null, // ESPN's scoreboard does not expose the group letter
+        home: teamOf(home),
+        away: teamOf(away),
+        homeScore: scoreOf(home, status),
+        awayScore: scoreOf(away, status),
+        status,
+        statusText: raw?.status?.type?.shortDetail ?? raw?.status?.type?.description ?? '',
+        minute: minuteOf(raw, status),
+        startTimestamp: Math.floor(Date.parse(raw?.date ?? '') / 1000) || 0,
+        varInProgress: false, // not surfaced by the scoreboard feed
     };
 }
-/** "goalNotAwarded" → "Goal not awarded" */
-function humanize(klass) {
-    if (!klass)
-        return '';
-    const words = klass.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
-    return words.charAt(0).toUpperCase() + words.slice(1);
-}
-function toKind(i) {
-    switch (i.incidentType) {
-        case 'goal':
-            return 'goal';
-        case 'card':
-            if (i.incidentClass === 'yellow')
-                return 'yellowCard';
-            if (i.incidentClass === 'red' || i.incidentClass === 'yellowRed')
-                return 'redCard';
-            return null;
-        case 'varDecision':
-            return 'var';
-        case 'inGamePenalty':
-            return 'penaltyMiss';
-        case 'substitution':
-            return 'substitution';
-        case 'injuryTime':
-            return 'injuryTime';
-        default:
-            return null; // 'period' and anything unknown
-    }
+function kindOf(det) {
+    if (det?.scoringPlay)
+        return 'goal';
+    if (det?.redCard)
+        return 'redCard';
+    if (det?.yellowCard)
+        return 'yellowCard';
+    return null; // substitutions / VAR are not in the scoreboard feed
 }
-function toDetail(i, kind) {
-    if (kind === 'var')
-        return humanize(i.incidentClass ?? 'decision');
-    if (kind === 'goal') {
-        if (i.incidentClass === 'penalty')
-            return 'Penalty';
-        if (i.incidentClass === 'ownGoal')
-            return 'Own goal';
+function detailOf(det, kind) {
+    if (kind !== 'goal')
         return null;
-    }
-    if (kind === 'substitution')
-        return i.playerOut?.name ? `for ${i.playerOut.name}` : null;
-    if (kind === 'injuryTime')
-        return i.length != null ? `+${i.length}` : null;
-    if (kind === 'penaltyMiss')
-        return 'Penalty missed';
+    if (det?.ownGoal)
+        return 'Own goal';
+    if (det?.penaltyKick)
+        return 'Penalty';
     return null;
 }
+function minuteFromClock(det) {
+    const m = /(\d+)/.exec(det?.clock?.displayValue ?? '');
+    return m ? Number(m[1]) : null;
+}
 export function parseIncidents(raw) {
+    const homeTeamId = competitor(raw, 'home')?.team?.id;
+    const details = raw?.competitions?.[0]?.details ?? [];
     const out = [];
-    for (const i of raw?.incidents ?? []) {
-        const kind = toKind(i);
+    for (const det of details) {
+        const kind = kindOf(det);
         if (!kind)
             continue;
-        const player = kind === 'substitution' ? i.playerIn : i.player;
+        const athlete = det?.athletesInvolved?.[0];
         out.push({
-            // fallback id must be stable across polls (the diff engine dedupes on it),
-            // so derive it from incident content, never from array position
-            id: String(i.id ?? `${i.incidentType}-${i.time}-${player?.id ?? 'x'}`),
+            // content-derived, stable across polls (the diff engine dedupes on it)
+            id: `${raw.id}-${det?.type?.id ?? '?'}-${det?.clock?.value ?? '?'}-${athlete?.id ?? '?'}`,
             kind,
-            minute: i.time ?? null,
-            player: player?.name ?? null,
-            playerShort: player?.shortName ?? player?.name ?? null,
-            detail: toDetail(i, kind),
-            isHome: !!i.isHome,
-            homeScore: kind === 'goal' ? i.homeScore ?? null : null,
-            awayScore: kind === 'goal' ? i.awayScore ?? null : null,
+            minute: minuteFromClock(det),
+            player: athlete?.displayName ?? null,
+            playerShort: athlete?.shortName ?? athlete?.displayName ?? null,
+            detail: detailOf(det, kind),
+            isHome: det?.team?.id != null && det.team.id === homeTeamId,
+            homeScore: null, // running score not provided per incident; unused downstream
+            awayScore: null,
         });
     }
-    // API returns newest first; we want chronological
-    return out.reverse();
+    // ESPN already lists details chronologically (earliest first)
+    return out;
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink';
 import { App } from './ui/App.js';
-import { resolveSeasonId } from './api/sofascore.js';
+import { resolveSeasonId } from './api/espn.js';
 // exit quietly when the consumer of a pipe closes early (e.g. `claudial | head`)
 process.stdout.on('error', (err) => {
     if (err.code === 'EPIPE')
@@ -15,7 +15,7 @@ async function main() {
         seasonId = await resolveSeasonId();
     }
     catch {
-        console.error('claudial: could not reach SofaScore. Check your connection and try again.');
+        console.error('claudial: could not reach ESPN. Check your connection and try again.');
         process.exit(1);
     }
     if (!process.stdout.isTTY) {
@@ -27,6 +27,6 @@ async function main() {
     render(_jsx(App, { seasonId: seasonId, mode: mode }));
 }
 main().catch(() => {
-    console.error('claudial: could not reach SofaScore. Check your connection and try again.');
+    console.error('claudial: could not reach ESPN. Check your connection and try again.');
     process.exit(1);
 });

package/dist/snapshot.js

@@ -1,4 +1,4 @@
-import { fetchLive, fetchRecent, fetchUpcoming } from './api/sofascore.js';
+import { fetchLive, fetchRecent, fetchUpcoming } from './api/espn.js';
 import { formatKickoff } from './ui/UpcomingSection.js';
 function line(m) {
     if (m.status === 'upcoming')

package/dist/ui/App.js

@@ -3,7 +3,7 @@ import { useEffect, useReducer, useRef } from 'react';
 import { Box, useApp, useInput } from 'ink';
 import { initialState, reducer } from '../state.js';
 import { startPoller } from '../engine/poller.js';
-import { fetchIncidents, fetchLive, fetchRecent, fetchUpcoming } from '../api/sofascore.js';
+import { fetchIncidents, fetchLive, fetchRecent, fetchUpcoming } from '../api/espn.js';
 import { Header } from './Header.js';
 import { LiveSection } from './LiveSection.js';
 import { UpcomingSection } from './UpcomingSection.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudial",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "node": ">=18.18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "dev": "tsx src/index.tsx",
     "test": "vitest run",
     "prepublishOnly": "npm run build"

package/dist/api/sofascore.js

@@ -1,51 +0,0 @@
-import { isWorldCup, parseEvent, parseIncidents } from './parse.js';
-const HOST = 'https://api.sofascore.app';
-// api.sofascore.com is challenge-blocked (403). The app host works with this
-// exact recipe; Accept-Encoding is mandatory or some endpoints return empty 200s.
-const HEADERS = {
-    'User-Agent': 'SofaScore/5.95.2 (Linux; Android 13)',
-    Accept: 'application/json',
-    'Accept-Encoding': 'gzip',
-};
-async function get(path) {
-    const res = await fetch(`${HOST}${path}`, { headers: HEADERS });
-    if (!res.ok)
-        throw new Error(`sofascore ${res.status} ${path}`);
-    const text = await res.text();
-    if (!text)
-        throw new Error(`sofascore empty body ${path}`);
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        throw new Error(`sofascore: malformed JSON from ${path}: ${text.slice(0, 120)}`);
-    }
-}
-const now = () => Math.floor(Date.now() / 1000);
-export async function resolveSeasonId() {
-    const data = await get(`/api/v1/unique-tournament/16/seasons`);
-    if (!data.seasons?.length)
-        throw new Error(`sofascore: no seasons for tournament 16`);
-    return data.seasons[0].id; // newest first; 2026 = 58210
-}
-export async function fetchLive() {
-    const data = await get(`/api/v1/sport/football/events/live`);
-    const t = now();
-    return (data.events ?? []).filter(isWorldCup).map((e) => parseEvent(e, t));
-}
-export async function fetchUpcoming(seasonId) {
-    const data = await get(`/api/v1/unique-tournament/16/season/${seasonId}/events/next/0`);
-    const t = now();
-    return (data.events ?? []).map((e) => parseEvent(e, t));
-}
-export async function fetchRecent(seasonId) {
-    const data = await get(`/api/v1/unique-tournament/16/season/${seasonId}/events/last/0`);
-    const t = now();
-    const dayAgo = t - 86_400;
-    return (data.events ?? [])
-        .map((e) => parseEvent(e, t))
-        .filter((m) => m.status === 'finished' && m.startTimestamp > dayAgo);
-}
-export async function fetchIncidents(eventId) {
-    return parseIncidents(await get(`/api/v1/event/${eventId}/incidents`));
-}