claudial 0.6.0 → 0.6.2

package/dist/engine/poller.js

@@ -106,6 +106,12 @@ export function startPoller(deps, opts = {}) {
         catch {
             deps.dispatch({ type: 'stale' });
         }
+        // Predictions ride the gentle fixtures cadence. fetchPredictions is
+        // fail-silent (returns [] when disabled or on error), so this never
+        // disturbs the board.
+        const predictions = await deps.fetchPredictions();
+        if (predictions.length > 0)
+            deps.dispatch({ type: 'predictions', predictions });
         if (!stopped)
             fixturesTimer = setTimeout(fixturesTick, fixturesMs);
     }

package/dist/predictions/client.js

@@ -0,0 +1,90 @@
+import { mkdirSync, readFileSync, writeFileSync, renameSync, statSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const ENV = 'CLAUDIAL_PREDICTIONS_URL';
+// Shipped default so predictions work out of the box from the published package.
+// Override with CLAUDIAL_PREDICTIONS_URL (e.g. your own backend, or to disable
+// by pointing it elsewhere).
+const DEFAULT_PREDICTIONS_URL = 'http://161.97.67.12:8000/api/predictions/';
+// Predictions only change every few hours server-side, so poll gently.
+const CACHE_TTL_MS = 30 * 60 * 1000;
+/** Resolve the API URL: explicit env var wins, else the shipped default. */
+export function predictionsUrl(env = process.env) {
+    return env[ENV] || DEFAULT_PREDICTIONS_URL;
+}
+/** A URL is always resolvable now (shipped default), so predictions are on. */
+export function predictionsEnabled(env = process.env) {
+    return !!predictionsUrl(env);
+}
+function cachePath(dir) {
+    return join(dir, 'predictions.json');
+}
+function readCache(file, now) {
+    if (!existsSync(file))
+        return null;
+    if (now - statSync(file).mtimeMs > CACHE_TTL_MS)
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(file, preds) {
+    const tmp = `${file}.tmp`;
+    try {
+        writeFileSync(tmp, JSON.stringify(preds));
+        renameSync(tmp, file);
+    }
+    catch {
+        /* cache is best-effort */
+    }
+}
+/**
+ * Fetch predictions, fail-silent. NEVER rejects — returns [] on any problem
+ * (disabled, network error, bad JSON, timeout) so callers can drop predictions
+ * and render fixtures exactly as before. Uses a disk cache to avoid hammering
+ * the API on every statusline tick.
+ */
+export async function fetchPredictions(opts = {}) {
+    const { env = process.env, now = Date.now(), timeoutMs = 2500, dir = join(tmpdir(), 'claudial-statusline'), fetchImpl = fetch, } = opts;
+    const url = predictionsUrl(env);
+    if (!url)
+        return [];
+    mkdirSync(dir, { recursive: true });
+    const file = cachePath(dir);
+    const cached = readCache(file, now);
+    if (cached)
+        return cached;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetchImpl(url, { signal: controller.signal });
+        if (!resp.ok)
+            return cached ?? [];
+        const data = (await resp.json());
+        if (!Array.isArray(data))
+            return [];
+        writeCache(file, data);
+        return data;
+    }
+    catch {
+        // Stale-but-present cache beats nothing; otherwise empty.
+        return readCacheStale(file) ?? [];
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Last-resort read ignoring TTL (used only when a live fetch fails). */
+function readCacheStale(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/predictions/format.js

@@ -0,0 +1,23 @@
+const pct = (p) => `${Math.round(p * 100)}%`;
+/** Compact one-liner for the statusline: "🔮 SUI win 64% · 2-1". */
+export function headline(p) {
+    return `🔮 ${p.pick.label} ${pct(p.pick.confidence)} · ${p.markets.scoreline}`;
+}
+/**
+ * Full-slate lines for the dashboard, shown beside the next fixture. Returns an
+ * array of plain strings (the caller wraps them in ink <Text>).
+ */
+export function fullSlate(p) {
+    const { result, over_under_2_5: ou, btts, scoreline } = p.markets;
+    const fav = result.home >= result.draw && result.home >= result.away
+        ? `${p.home_code} ${pct(result.home)}`
+        : result.away >= result.draw
+            ? `${p.away_code} ${pct(result.away)}`
+            : `Draw ${pct(result.draw)}`;
+    const ouPick = ou.over >= ou.under ? `O2.5 ${pct(ou.over)}` : `U2.5 ${pct(ou.under)}`;
+    const bttsPick = btts.yes >= btts.no ? `BTTS ${pct(btts.yes)}` : `No BTTS ${pct(btts.no)}`;
+    return [
+        `🔮 PICK: ${p.pick.label} (${pct(p.pick.confidence)})  ·  stake €${p.suggested_stake_eur}`,
+        `   1X2 ${fav}   ${ouPick}   ${bttsPick}   score ${scoreline}`,
+    ];
+}

package/dist/predictions/index.js

@@ -0,0 +1,3 @@
+export { predictionsEnabled, fetchPredictions } from './client.js';
+export { matchPrediction } from './match.js';
+export { headline, fullSlate } from './format.js';

package/dist/predictions/match.js

@@ -0,0 +1,17 @@
+/**
+ * Find the prediction for a claudial `Match`, matching on FIFA codes. Two teams
+ * can meet more than once (group + knockout), so when several candidates share
+ * the same code pair we take the one whose kickoff is closest to the match's.
+ * Returns null when there's no prediction (engine disabled, API down, or the
+ * fixture simply isn't predicted yet).
+ */
+export function matchPrediction(m, preds) {
+    const candidates = preds.filter((p) => p.home_code === m.home.code && p.away_code === m.away.code);
+    if (candidates.length === 0)
+        return null;
+    if (candidates.length === 1)
+        return candidates[0];
+    return candidates.reduce((best, p) => Math.abs(p.kickoff_ts - m.startTimestamp) < Math.abs(best.kickoff_ts - m.startTimestamp)
+        ? p
+        : best);
+}

package/dist/predictions/types.js

@@ -0,0 +1,3 @@
+// Mirrors the predictions API contract (predictions/ Django service).
+// Kept structurally identical to the JSON so parsing is a straight cast.
+export {};

package/dist/state.js

@@ -1,6 +1,6 @@
 export const initialState = {
     live: [], upcoming: [], recent: [],
-    incidents: {}, takeovers: [],
+    incidents: {}, predictions: [], takeovers: [],
     stale: false, lastUpdated: null,
 };
 export function reducer(s, a) {
@@ -11,6 +11,8 @@ export function reducer(s, a) {
             return { ...s, upcoming: a.upcoming, recent: a.recent };
         case 'incidents':
             return { ...s, incidents: { ...s.incidents, [a.matchId]: a.incidents } };
+        case 'predictions':
+            return { ...s, predictions: a.predictions };
         case 'takeover':
             return { ...s, takeovers: [...s.takeovers, a.takeover] };
         case 'takeoverDone':

package/dist/statusline/line.js

@@ -1,5 +1,7 @@
 import { formatKickoff } from '../ui/UpcomingSection.js';
 import { homeTag, awayTag } from '../ui/flags.js';
+import { matchPrediction } from '../predictions/match.js';
+import { headline } from '../predictions/format.js';
 // Assumed wall-clock length of a match (kickoff → ~full time). ESPN exposes no
 // end-time, so a finished match is anchored at kickoff + this for proximity math.
 const MATCH_MS = 2 * 60 * 60 * 1000;
@@ -14,16 +16,24 @@ export function liveLine(match) {
 export function finishedLine(match) {
     return `⚽ ${homeTag(match.home.code)} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${awayTag(match.away.code)} FT`;
 }
-/** The next kickoff: "○ BRA 🇧🇷 — 🇲🇦 MAR Sun 01:00". */
-function upcomingLine(match, now) {
-    return `○ ${homeTag(match.home.code)} — ${awayTag(match.away.code)} ${formatKickoff(match.startTimestamp, now)}`;
+/**
+ * The next kickoff: "○ BRA 🇧🇷 — 🇲🇦 MAR Sun 01:00", with a prediction headline
+ * appended when one is available: "… · 🔮 BRA win 64% · 2-1".
+ */
+function upcomingLine(match, now, preds) {
+    const base = `○ ${homeTag(match.home.code)} — ${awayTag(match.away.code)} ${formatKickoff(match.startTimestamp, now)}`;
+    const pred = matchPrediction(match, preds);
+    return pred ? `${base} · ${headline(pred)}` : base;
 }
 /**
  * Live matches joined by two spaces. Otherwise show whichever moment is closer
  * to `now`: the latest finished result (end ≈ kickoff + MATCH_MS) or the next
- * kickoff. Only one present → that one; neither → "".
+ * kickoff. Only one present → that one; neither → "". When the chosen line is
+ * the next kickoff, a matching prediction headline is appended (`preds` is
+ * empty unless the predictions engine is enabled, so default behavior is
+ * unchanged).
  */
-export function scoreLine(live, recent, upcoming, now = Date.now()) {
+export function scoreLine(live, recent, upcoming, now = Date.now(), preds = []) {
     if (live.length > 0)
         return live.map(liveLine).join('  ');
     const lastFinished = recent.length
@@ -35,11 +45,11 @@ export function scoreLine(live, recent, upcoming, now = Date.now()) {
         const startMs = next.startTimestamp * 1000;
         return Math.abs(now - finishMs) <= Math.abs(startMs - now)
             ? finishedLine(lastFinished)
-            : upcomingLine(next, now);
+            : upcomingLine(next, now, preds);
     }
     if (lastFinished)
         return finishedLine(lastFinished);
     if (next)
-        return upcomingLine(next, now);
+        return upcomingLine(next, now, preds);
     return '';
 }

package/dist/statusline/run.js

@@ -3,6 +3,7 @@ import { fetchLive as realFetchLive, fetchRecent as realFetchRecent, fetchUpcomi
 import { scoreLine } from './line.js';
 import { makeCache, TTL_MS } from './cache.js';
 import { goalKickFrame } from './anim.js';
+import { fetchPredictions as realFetchPredictions } from '../predictions/client.js';
 const PLACEHOLDER = '⚽ claudial · warming up';
 function withTimeout(p, ms) {
     let id;
@@ -18,8 +19,8 @@ export async function runStatusline(input, deps, now = Date.now()) {
     const fresh = cached != null && cached.ageMs <= TTL_MS;
     if (!fresh && cache.tryLock(now)) {
         try {
-            const [liveM, recentM, upcomingM, redsM] = await withTimeout(Promise.all([deps.fetchLive(), deps.fetchRecent(), deps.fetchUpcoming(2026), deps.fetchRedCards()]), deps.timeoutMs);
-            const next = scoreLine(liveM, recentM, upcomingM, now);
+            const [liveM, recentM, upcomingM, redsM, predsM] = await withTimeout(Promise.all([deps.fetchLive(), deps.fetchRecent(), deps.fetchUpcoming(2026), deps.fetchRedCards(), deps.fetchPredictions()]), deps.timeoutMs);
+            const next = scoreLine(liveM, recentM, upcomingM, now, predsM);
             cache.updateGoalState(liveM, now);
             cache.updateRedCards(redsM, now);
             if (next) {
@@ -67,6 +68,7 @@ export function defaultDeps() {
         fetchRecent: () => realFetchRecent(2026),
         fetchUpcoming: realFetchUpcoming,
         fetchRedCards: realFetchLiveRedCards,
+        fetchPredictions: () => realFetchPredictions(),
         cache: makeCache(),
         branchOf: defaultBranchOf,
         timeoutMs: 3000,

package/dist/ui/App.js

@@ -4,6 +4,7 @@ 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/espn.js';
+import { fetchPredictions } from '../predictions/client.js';
 import { Header } from './Header.js';
 import { DaySection } from './DaySection.js';
 import { partitionByDay } from './fixtures.js';
@@ -33,6 +34,7 @@ export function App({ seasonId, mode = 'board' }) {
                 recent: await fetchRecent(seasonId),
             }),
             fetchIncidents,
+            fetchPredictions: () => fetchPredictions(),
             dispatch,
         };
         pollerRef.current = startPoller(deps);
@@ -59,5 +61,5 @@ export function App({ seasonId, mode = 'board' }) {
     }
     const all = dedupeById([...state.live, ...state.recent, ...state.upcoming]);
     const { yesterday, today, future } = partitionByDay(all, Date.now());
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(DaySection, { label: "TODAY", matches: today, incidents: state.incidents, compact: compact }), _jsx(DaySection, { label: "YESTERDAY", matches: yesterday, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: future, compact: compact }), _jsx(Footer, {})] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(DaySection, { label: "TODAY", matches: today, incidents: state.incidents, compact: compact }), _jsx(DaySection, { label: "YESTERDAY", matches: yesterday, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: future, compact: compact, predictions: state.predictions }), _jsx(Footer, {})] }));
 }

package/dist/ui/UpcomingSection.js

@@ -1,6 +1,8 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { homeTag, awayTag } from './flags.js';
+import { matchPrediction } from '../predictions/match.js';
+import { fullSlate, headline } from '../predictions/format.js';
 export function formatKickoff(ts, now = Date.now()) {
     const d = new Date(ts * 1000);
     const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
@@ -10,13 +12,22 @@ export function formatKickoff(ts, now = Date.now()) {
     const day = d.toLocaleDateString(undefined, { weekday: 'short' });
     return `${day} ${time}`;
 }
-export function UpcomingSection({ matches, compact }) {
+export function UpcomingSection({ matches, compact, predictions = [], }) {
     const shown = matches.slice(0, compact ? 1 : 8);
     if (shown.length === 0)
         return null;
     if (compact) {
         const m = shown[0];
-        return (_jsxs(Text, { dimColor: true, children: ["\u25CB ", homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), " ", formatKickoff(m.startTimestamp)] }));
+        const pred = matchPrediction(m, predictions);
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), " ", formatKickoff(m.startTimestamp)] }), pred ? _jsx(Text, { color: "yellow", children: headline(pred) }) : null] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "UPCOMING" }), shown.map((m) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }, m.id)))] }));
+    // Every fixture shows its pick; the NEXT one (shown[0]) gets the full slate.
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "UPCOMING" }), shown.map((m, i) => {
+                const pred = matchPrediction(m, predictions);
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), homeTag(m.home.code), " \u2014 ", awayTag(m.away.code), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }), pred && i === 0
+                            ? fullSlate(pred).map((ln, j) => _jsx(Text, { color: "yellow", children: ln }, j))
+                            : pred
+                                ? _jsxs(Text, { color: "yellow", children: ["   ", headline(pred)] })
+                                : null] }, m.id));
+            })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudial",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
   "type": "module",
   "bin": {