claudial 0.2.1 → 0.3.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Wim Iliano
+Copyright (c) 2026 lefProg
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,11 +1,29 @@
-# claudial
+<div align="center">
 
-Live World Cup 2026 fixtures in your terminal. One line, zero install:
+# ⚽ claudial
+
+### Live World Cup 2026 in your terminal — goal, red-card and VAR takeovers included
+
+One line. Zero install. Every score, while you work.
 
 ```
 npx claudial
 ```
 
+<br/>
+
+[![npm version](https://img.shields.io/npm/v/claudial?style=flat-square&color=CB3837&logo=npm)](https://www.npmjs.com/package/claudial)
+[![npm downloads](https://img.shields.io/npm/dm/claudial?style=flat-square&color=CB3837&logo=npm)](https://www.npmjs.com/package/claudial)
+[![node](https://img.shields.io/node/v/claudial?style=flat-square&color=339933&logo=node.js&logoColor=white)](https://nodejs.org)
+[![license](https://img.shields.io/npm/l/claudial?style=flat-square&color=blue)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6?style=flat-square&logo=typescript&logoColor=white)](tsconfig.json)
+[![GitHub stars](https://img.shields.io/github/stars/lefProg/claudial?style=flat-square&color=f5c518&logo=github)](https://github.com/lefProg/claudial/stargazers)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square)](https://github.com/lefProg/claudial/issues)
+
+</div>
+
+---
+
 Live matches with scores, minutes and scorers on top. Upcoming fixtures in
 your local time below. Auto-refreshing while you work.
 
@@ -81,9 +99,22 @@ When a goal goes in, the strip lights up while Claude keeps working.
 Claude rather than a strip below? Use
 `split-window -h -l 44 'claudial'` in the alias.)
 
+Don't want to hand-edit your shell config? `claudial setup --tmux` appends the
+right alias for you — zsh, bash or fish — idempotently.
+
 Want the score *inside* Claude Code itself — in its status bar, no tmux at
-all? There's a [statusline integration](extras/statusline/) for that:
-`⚽ QAT 0—1 SUI 67' · main`, refreshed every 15 s.
+all? Install everything in one step:
+
+```bash
+npm install -g claudial
+claudial setup
+```
+
+The wizard adds a live-score statusline (`⚽ QAT 0—1 SUI 67' · main`, refreshed
+every few seconds) to your Claude Code settings, and can also wire up the tmux
+ticker alias below. It works on zsh, bash and fish, and the statusline itself
+is pure Node — no `jq`/`flock`/`curl`, so it runs on macOS and Windows too.
+Non-interactive: `claudial setup --statusline --global --tmux --shell zsh --yes`.
 
 ## Why a TUI
 
@@ -108,10 +139,10 @@ claudial
 
 Requires Node ≥ 18. No account, no API key, no config.
 
-| Key | Action  |
-|-----|---------|
+| Key | Action      |
+|-----|-------------|
 | `r` | refresh now |
-| `q` | quit    |
+| `q` | quit        |
 
 Beyond goals, every live match carries its incident feed: yellow cards,
 substitutions, injury time — and a `⚖ VAR` badge the moment a review starts.
@@ -139,6 +170,31 @@ v1 is being built live during the group stage. Follow the commits.
 // up in a smoke test before any UI existed to celebrate it. Legendary.
 ```
 
+## Contributing
+
+Issues and PRs welcome — bug reports, new incident types, terminal quirks,
+all of it. Keep the polling gentle and the spirit playful.
+
+```bash
+git clone https://github.com/lefProg/claudial.git
+cd claudial
+npm install
+npm run dev     # live TUI from source
+npm test        # vitest
+```
+
 ## License
 
-MIT
+[MIT](LICENSE) © lefProg
+
+<div align="center">
+
+<br/>
+
+**If this made a goal feel a little louder, drop a ⭐ — it helps others find it.**
+
+[Report a bug](https://github.com/lefProg/claudial/issues) ·
+[Request a feature](https://github.com/lefProg/claudial/issues) ·
+[npm](https://www.npmjs.com/package/claudial)
+
+</div>

package/dist/api/espn.js

@@ -40,6 +40,12 @@ function todayRange(daysAhead) {
     const end = new Date(now.getTime() + daysAhead * 86_400_000);
     return `${start}-${yyyymmdd(end)}`;
 }
+// Past date range "YYYYMMDD-YYYYMMDD" from (today - daysBack) through today (UTC).
+export function pastRange(daysBack, now = Date.now()) {
+    const end = new Date(now);
+    const start = new Date(now - daysBack * 86_400_000);
+    return `${yyyymmdd(start)}-${yyyymmdd(end)}`;
+}
 // Kept for call-site compatibility; ESPN needs no season id to query.
 export async function resolveSeasonId() {
     return 2026;
@@ -56,8 +62,11 @@ export async function fetchUpcoming(_seasonId) {
         .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');
+    const events = await scoreboard(pastRange(1));
+    return events
+        .map(parseEvent)
+        .filter((m) => m.status === 'finished')
+        .sort((a, b) => a.startTimestamp - b.startTimestamp);
 }
 export async function fetchIncidents(eventId) {
     const events = await scoreboard(todayRange(0));

package/dist/index.js

@@ -9,7 +9,33 @@ process.stdout.on('error', (err) => {
         process.exit(0);
     throw err;
 });
+function readStdin() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve('');
+            return;
+        }
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (c) => { data += c; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', () => resolve(data));
+    });
+}
 async function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === 'setup') {
+        const { runSetup } = await import('./setup/index.js');
+        await runSetup(args.slice(1));
+        process.exit(0);
+    }
+    if (args.includes('--statusline')) {
+        const input = await readStdin();
+        const { runStatusline, defaultDeps } = await import('./statusline/run.js');
+        const line = await runStatusline(input, defaultDeps());
+        process.stdout.write(line);
+        process.exit(0);
+    }
     let seasonId;
     try {
         seasonId = await resolveSeasonId();

package/dist/setup/Wizard.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { ACCENT } from '../ui/Header.js';
+export function Wizard({ defaultShell, allowTmux, onDone }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState('statusline');
+    const [statusline, setStatusline] = useState(true);
+    const [scope, setScope] = useState('global');
+    const [tmux, setTmux] = useState(false);
+    const [shell, setShell] = useState(defaultShell);
+    const finish = () => {
+        onDone({ statusline, scope, tmux, shell, yes: true, interactive: false });
+        exit();
+    };
+    useInput((input, key) => {
+        const yes = input.toLowerCase() === 'y';
+        const no = input.toLowerCase() === 'n';
+        if (input === 'q') {
+            exit();
+            return;
+        }
+        if (step === 'statusline') {
+            if (yes || key.return) {
+                setStatusline(true);
+                setStep('scope');
+            }
+            else if (no) {
+                setStatusline(false);
+                setStep(allowTmux ? 'tmux' : 'confirm');
+            }
+        }
+        else if (step === 'scope') {
+            if (input === 'g' || key.return) {
+                setScope('global');
+                setStep(allowTmux ? 'tmux' : 'confirm');
+            }
+            else if (input === 'p') {
+                setScope('project');
+                setStep(allowTmux ? 'tmux' : 'confirm');
+            }
+        }
+        else if (step === 'tmux') {
+            if (yes) {
+                setTmux(true);
+                setStep('shell');
+            }
+            else if (no || key.return) {
+                setTmux(false);
+                setStep('confirm');
+            }
+        }
+        else if (step === 'shell') {
+            if (input === 'z')
+                setShell('zsh');
+            else if (input === 'b')
+                setShell('bash');
+            else if (input === 'f')
+                setShell('fish');
+            if (key.return || 'zbf'.includes(input))
+                setStep('confirm');
+        }
+        else if (step === 'confirm') {
+            if (yes || key.return)
+                finish();
+            else if (no)
+                exit();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsx(Text, { bold: true, color: ACCENT, children: "claudial setup" }) }), step === 'statusline' && _jsx(Text, { children: "Add the live-score statusline inside Claude Code? (Y/n)" }), step === 'scope' && _jsx(Text, { children: "Scope \u2014 [g]lobal (~/.claude) or [p]roject (.claude)? (G/p)" }), step === 'tmux' && _jsx(Text, { children: "Also add the tmux ticker alias (claude-mundial)? (y/N)" }), step === 'shell' && _jsxs(Text, { children: ["Shell for the alias \u2014 [z]sh [b]ash [f]ish? (default ", shell, ")"] }), step === 'confirm' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "About to apply:" }), statusline && _jsxs(Text, { dimColor: true, children: ["  \u2022 statusline \u2192 ", scope] }), tmux && _jsxs(Text, { dimColor: true, children: ["  \u2022 tmux alias \u2192 ", shell] }), !statusline && !tmux && _jsx(Text, { dimColor: true, children: "  \u2022 nothing selected" }), _jsx(Text, { children: "Proceed? (Y/n)" })] })), _jsx(Text, { dimColor: true, children: "q to quit" })] }));
+}

package/dist/setup/apply.js

@@ -0,0 +1,14 @@
+import { installStatusline } from './settings.js';
+import { appendAlias } from './shellrc.js';
+export function applySetup(opts, ctx) {
+    const report = { statuslineWritten: false, statuslineBackedUp: false, aliasAppended: false };
+    if (opts.statusline) {
+        const r = installStatusline(ctx.settingsPath, ctx.command, ctx.conflict);
+        report.statuslineWritten = r.written;
+        report.statuslineBackedUp = r.backedUp;
+    }
+    if (opts.tmux) {
+        report.aliasAppended = appendAlias(ctx.rcPath, ctx.shell).appended;
+    }
+    return report;
+}

package/dist/setup/detect.js

@@ -0,0 +1,34 @@
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+export function detectShell(env = process.env) {
+    const s = env.SHELL ?? '';
+    if (s.includes('zsh'))
+        return 'zsh';
+    if (s.includes('fish'))
+        return 'fish';
+    return 'bash';
+}
+export function rcPathFor(shell, home) {
+    if (shell === 'zsh')
+        return join(home, '.zshrc');
+    if (shell === 'fish')
+        return join(home, '.config', 'fish', 'config.fish');
+    return join(home, '.bashrc');
+}
+export function isWindows(platform = process.platform) {
+    return platform === 'win32';
+}
+/** True if `bin` resolves on PATH (so settings can use the bare command). */
+export function isOnPath(bin) {
+    const probe = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        execFileSync(probe, [bin], { stdio: ['ignore', 'ignore', 'ignore'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasTmux() {
+    return isOnPath('tmux');
+}

package/dist/setup/flags.js

@@ -0,0 +1,18 @@
+const SHELLS = ['zsh', 'bash', 'fish'];
+export function parseFlags(args) {
+    const has = (f) => args.includes(f);
+    const shellArg = args[args.indexOf('--shell') + 1];
+    const shell = SHELLS.includes(shellArg) ? shellArg : null;
+    const statusline = has('--statusline');
+    const tmux = has('--tmux');
+    // any actionable flag (or --yes) means run without prompting
+    const interactive = !(statusline || tmux || has('--yes'));
+    return {
+        statusline,
+        scope: has('--project') ? 'project' : 'global',
+        tmux,
+        shell,
+        yes: has('--yes'),
+        interactive,
+    };
+}

package/dist/setup/index.js

@@ -0,0 +1,63 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import React from 'react';
+import { render } from 'ink';
+import { parseFlags } from './flags.js';
+import { detectShell, rcPathFor, isOnPath, hasTmux, isWindows } from './detect.js';
+import { applySetup } from './apply.js';
+import { Wizard } from './Wizard.js';
+function commandFor() {
+    return isOnPath('claudial') ? 'claudial --statusline' : 'npx claudial --statusline';
+}
+function contextFor(opts) {
+    const shell = opts.shell ?? detectShell();
+    const settingsPath = opts.scope === 'project'
+        ? join(process.cwd(), '.claude', 'settings.json')
+        : join(homedir(), '.claude', 'settings.json');
+    return {
+        settingsPath,
+        rcPath: rcPathFor(shell, homedir()),
+        shell,
+        command: commandFor(),
+        conflict: 'overwrite',
+    };
+}
+function printReport(opts, ctx, report) {
+    if (report.statuslineWritten) {
+        console.log(`✓ statusline installed → ${ctx.settingsPath}`);
+        if (report.statuslineBackedUp)
+            console.log(`  (previous settings backed up to ${ctx.settingsPath}.bak)`);
+        console.log('  Restart Claude Code to see the score bar.');
+    }
+    else if (opts.statusline) {
+        console.log('• statusline unchanged (an existing statusLine was kept).');
+    }
+    if (report.aliasAppended) {
+        console.log(`✓ tmux alias added → ${ctx.rcPath}`);
+        console.log(`  Open a new shell, then run: claude-mundial`);
+    }
+    else if (opts.tmux) {
+        console.log('• tmux alias already present — left as-is.');
+    }
+    if (!opts.statusline && !opts.tmux)
+        console.log('Nothing selected. Run `claudial setup` again to choose options.');
+}
+export async function runSetup(args) {
+    const opts = parseFlags(args);
+    const run = (final) => {
+        const ctx = contextFor(final);
+        printReport(final, ctx, applySetup(final, ctx));
+    };
+    if (!opts.interactive) {
+        run(opts);
+        return;
+    }
+    await new Promise((resolve) => {
+        const { waitUntilExit } = render(React.createElement(Wizard, {
+            defaultShell: detectShell(),
+            allowTmux: !isWindows() && hasTmux(),
+            onDone: (final) => run(final),
+        }));
+        waitUntilExit().then(() => resolve());
+    });
+}

package/dist/setup/settings.js

@@ -0,0 +1,37 @@
+import { mkdirSync, readFileSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function statusLineBlock(command) {
+    return { type: 'command', command, refreshInterval: 3 };
+}
+/** Pure merge. Returns the new settings object and whether it changed. */
+export function mergeSettings(existing, block, conflict) {
+    const hasExisting = existing?.statusLine != null;
+    if (hasExisting && conflict !== 'overwrite') {
+        return { settings: existing, changed: false };
+    }
+    return { settings: { ...existing, statusLine: block }, changed: true };
+}
+/** Read → merge → (backup) → write. Creates parent dirs and a .bak. */
+export function installStatusline(settingsPath, command, conflict) {
+    let existing = {};
+    const fileExists = existsSync(settingsPath);
+    if (fileExists) {
+        try {
+            existing = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const { settings, changed } = mergeSettings(existing, statusLineBlock(command), conflict);
+    if (!changed)
+        return { written: false, backedUp: false };
+    let backedUp = false;
+    if (fileExists) {
+        copyFileSync(settingsPath, `${settingsPath}.bak`);
+        backedUp = true;
+    }
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    return { written: true, backedUp };
+}

package/dist/setup/shellrc.js

@@ -0,0 +1,24 @@
+import { mkdirSync, readFileSync, appendFileSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+const MARKER = '# claudial — World Cup ticker beside Claude Code';
+/** The `claude-mundial` alias, escaped for the target shell. */
+export function aliasLine(shell) {
+    if (shell === 'fish') {
+        return `${MARKER}\nalias claude-mundial "tmux new-session 'claude' ; split-window -v -l 5 'claudial --ticker' ; select-pane -U"\n`;
+    }
+    // zsh + bash share POSIX syntax; tmux command separators escaped as \;
+    return `${MARKER}\nalias claude-mundial="tmux new-session 'claude' \\; split-window -v -l 5 'claudial --ticker' \\; select-pane -U"\n`;
+}
+export function hasAlias(content) {
+    return content.includes('claude-mundial');
+}
+/** Append the alias unless one is already present. Creates the file/dir. */
+export function appendAlias(rcPath, shell) {
+    const current = existsSync(rcPath) ? readFileSync(rcPath, 'utf8') : '';
+    if (hasAlias(current))
+        return { appended: false };
+    mkdirSync(dirname(rcPath), { recursive: true });
+    const prefix = current && !current.endsWith('\n') ? '\n' : '';
+    appendFileSync(rcPath, `${prefix}\n${aliasLine(shell)}`);
+    return { appended: true };
+}

package/dist/statusline/cache.js

@@ -0,0 +1,106 @@
+import { mkdirSync, openSync, closeSync, writeFileSync, readFileSync, renameSync, statSync, existsSync, unlinkSync, utimesSync, futimesSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const TTL_MS = 10_000;
+export const GOAL_WINDOW_MS = 15_000;
+const LOCK_STALE_MS = 30_000;
+// ACCENT #D97757 → truecolor; bold. Matches the old bash celebration styling.
+const GOAL_OPEN = '\x1b[1;38;2;217;119;87m';
+const GOAL_CLOSE = '\x1b[0m';
+function goalText(m) {
+    return `${GOAL_OPEN}⚽ G O O O L  ·  ${m.home.code} ${m.homeScore ?? 0}—${m.awayScore ?? 0} ${m.away.code}${GOAL_CLOSE}`;
+}
+export function makeCache(dir = join(tmpdir(), 'claudial-statusline')) {
+    mkdirSync(dir, { recursive: true });
+    const cacheFile = join(dir, 'line');
+    const lockFile = join(dir, 'lock');
+    const stateFile = join(dir, 'goals.json');
+    const goalFile = join(dir, 'goal');
+    const goalTsFile = join(dir, 'goalts');
+    const atomicWrite = (path, data) => {
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, data);
+        renameSync(tmp, path);
+    };
+    const readJson = (path) => {
+        try {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    const totals = (live) => {
+        const out = {};
+        for (const m of live)
+            out[String(m.id)] = (m.homeScore ?? 0) + (m.awayScore ?? 0);
+        return out;
+    };
+    return {
+        read(now = Date.now()) {
+            if (!existsSync(cacheFile))
+                return null;
+            const line = readFileSync(cacheFile, 'utf8');
+            const ageMs = now - statSync(cacheFile).mtimeMs;
+            return { line, ageMs };
+        },
+        write(line, now = Date.now()) {
+            atomicWrite(cacheFile, line);
+            const t = now / 1000;
+            try {
+                utimesSync(cacheFile, t, t);
+            }
+            catch { /* best effort */ }
+        },
+        tryLock(now = Date.now()) {
+            if (existsSync(lockFile)) {
+                const age = now - statSync(lockFile).mtimeMs;
+                if (age > LOCK_STALE_MS) {
+                    try {
+                        unlinkSync(lockFile);
+                    }
+                    catch { /* race */ }
+                }
+            }
+            try {
+                const fd = openSync(lockFile, 'wx');
+                const t = now / 1000;
+                try {
+                    futimesSync(fd, t, t);
+                }
+                catch { /* best effort */ }
+                closeSync(fd);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        unlock() { try {
+            unlinkSync(lockFile);
+        }
+        catch { /* already gone */ } },
+        updateGoalState(live, now = Date.now()) {
+            const prev = readJson(stateFile);
+            const cur = totals(live);
+            for (const m of live) {
+                const id = String(m.id);
+                const was = prev[id] ?? cur[id]; // first sighting never fires
+                if (cur[id] > was) {
+                    atomicWrite(goalFile, goalText(m));
+                    atomicWrite(goalTsFile, String(now));
+                    break;
+                }
+            }
+            atomicWrite(stateFile, JSON.stringify(cur));
+        },
+        activeGoalLine(now = Date.now()) {
+            if (!existsSync(goalTsFile) || !existsSync(goalFile))
+                return null;
+            const ts = Number(readFileSync(goalTsFile, 'utf8'));
+            if (!Number.isFinite(ts) || now - ts > GOAL_WINDOW_MS)
+                return null;
+            return readFileSync(goalFile, 'utf8');
+        },
+    };
+}

package/dist/statusline/line.js

@@ -0,0 +1,44 @@
+import { formatKickoff } from '../ui/UpcomingSection.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;
+/** A live/halftime match: "⚽ QAT 0—1 SUI 67'" (em-dash U+2014 between scores). */
+export function liveLine(match) {
+    const clock = match.status === 'halftime' ? ' HT'
+        : match.minute != null ? ` ${match.minute}'`
+            : '';
+    return `⚽ ${match.home.code} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${match.away.code}${clock}`;
+}
+/** A finished match with its result: "⚽ QAT 2—1 SUI FT". */
+export function finishedLine(match) {
+    return `⚽ ${match.home.code} ${match.homeScore ?? 0}—${match.awayScore ?? 0} ${match.away.code} FT`;
+}
+/** The next kickoff: "○ BRA—MOR Sun 01:00". */
+function upcomingLine(match, now) {
+    return `○ ${match.home.code}—${match.away.code} ${formatKickoff(match.startTimestamp, now)}`;
+}
+/**
+ * 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 → "".
+ */
+export function scoreLine(live, recent, upcoming, now = Date.now()) {
+    if (live.length > 0)
+        return live.map(liveLine).join('  ');
+    const lastFinished = recent.length
+        ? recent.reduce((a, b) => (b.startTimestamp > a.startTimestamp ? b : a))
+        : null;
+    const next = upcoming[0] ?? null;
+    if (lastFinished && next) {
+        const finishMs = lastFinished.startTimestamp * 1000 + MATCH_MS;
+        const startMs = next.startTimestamp * 1000;
+        return Math.abs(now - finishMs) <= Math.abs(startMs - now)
+            ? finishedLine(lastFinished)
+            : upcomingLine(next, now);
+    }
+    if (lastFinished)
+        return finishedLine(lastFinished);
+    if (next)
+        return upcomingLine(next, now);
+    return '';
+}

package/dist/statusline/run.js

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { fetchLive as realFetchLive, fetchRecent as realFetchRecent, fetchUpcoming as realFetchUpcoming } from '../api/espn.js';
+import { scoreLine } from './line.js';
+import { makeCache, TTL_MS } from './cache.js';
+const PLACEHOLDER = '⚽ claudial · warming up';
+function withTimeout(p, ms) {
+    let id;
+    const timer = new Promise((_, reject) => {
+        id = setTimeout(() => reject(new Error('timeout')), ms);
+    });
+    return Promise.race([p, timer]).finally(() => clearTimeout(id));
+}
+export async function runStatusline(input, deps, now = Date.now()) {
+    const { cache } = deps;
+    const cached = cache.read(now);
+    let line = cached?.line ?? null;
+    const fresh = cached != null && cached.ageMs <= TTL_MS;
+    if (!fresh && cache.tryLock(now)) {
+        try {
+            const [liveM, recentM, upcomingM] = await withTimeout(Promise.all([deps.fetchLive(), deps.fetchRecent(), deps.fetchUpcoming(2026)]), deps.timeoutMs);
+            const next = scoreLine(liveM, recentM, upcomingM, now);
+            cache.updateGoalState(liveM, now);
+            if (next) {
+                cache.write(next, now);
+                line = next;
+            }
+        }
+        catch {
+            // keep last good cache (line already set)
+        }
+        finally {
+            cache.unlock();
+        }
+    }
+    const score = cache.activeGoalLine(now) ?? line ?? PLACEHOLDER;
+    const branch = deps.branchOf(input);
+    return branch ? `${score} · ${branch}` : score;
+}
+/** Resolve the git branch of the workspace dir named in Claude Code's stdin JSON. */
+export function defaultBranchOf(input) {
+    let dir = '';
+    try {
+        const j = JSON.parse(input || '{}');
+        dir = j?.workspace?.current_dir || j?.cwd || '';
+    }
+    catch { /* no/!json stdin */ }
+    if (!dir)
+        return null;
+    try {
+        const out = execFileSync('git', ['-C', dir, 'branch', '--show-current'], {
+            encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function defaultDeps() {
+    return {
+        fetchLive: realFetchLive,
+        fetchRecent: () => realFetchRecent(2026),
+        fetchUpcoming: realFetchUpcoming,
+        cache: makeCache(),
+        branchOf: defaultBranchOf,
+        timeoutMs: 3000,
+    };
+}

package/dist/ui/App.js

@@ -5,11 +5,22 @@ import { initialState, reducer } from '../state.js';
 import { startPoller } from '../engine/poller.js';
 import { fetchIncidents, fetchLive, fetchRecent, fetchUpcoming } from '../api/espn.js';
 import { Header } from './Header.js';
-import { LiveSection } from './LiveSection.js';
+import { DaySection } from './DaySection.js';
+import { partitionByDay } from './fixtures.js';
 import { UpcomingSection } from './UpcomingSection.js';
 import { Footer } from './Footer.js';
 import { TakeoverView } from './TakeoverView.js';
 import { Ticker } from './Ticker.js';
+function dedupeById(matches) {
+    const seen = new Set();
+    const out = [];
+    for (const m of matches)
+        if (!seen.has(m.id)) {
+            seen.add(m.id);
+            out.push(m);
+        }
+    return out;
+}
 export function App({ seasonId, mode = 'board' }) {
     const [state, dispatch] = useReducer(reducer, initialState);
     const { exit } = useApp();
@@ -46,5 +57,7 @@ export function App({ seasonId, mode = 'board' }) {
     if (mode === 'ticker') {
         return _jsx(Ticker, { live: state.live, upcoming: state.upcoming, takeover: playing });
     }
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { stale: state.stale, lastUpdated: state.lastUpdated }), _jsx(LiveSection, { matches: state.live, recent: state.recent, incidents: state.incidents, compact: compact }), _jsx(UpcomingSection, { matches: state.upcoming, compact: compact }), _jsx(Footer, {})] }));
+    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, {})] }));
 }

package/dist/ui/DaySection.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { MatchRow } from './MatchRow.js';
+/** A labelled group of match rows (e.g. TODAY / YESTERDAY). Hidden when empty. */
+export function DaySection({ label, matches, incidents, compact }) {
+    if (matches.length === 0)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: label }), matches.map((m) => (_jsx(MatchRow, { m: m, incidents: incidents[m.id] ?? [], compact: compact }, m.id)))] }));
+}

package/dist/ui/MatchRow.js

@@ -0,0 +1,43 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ACCENT } from './Header.js';
+import { formatKickoff } from './UpcomingSection.js';
+export function ScorerLine({ incidents }) {
+    const goals = incidents.filter((i) => i.kind === 'goal');
+    if (goals.length === 0)
+        return null;
+    const fmt = (g) => `${g.minute ?? '?'}' ${g.playerShort ?? '?'}`;
+    const home = goals.filter((g) => g.isHome).map(fmt).join(' · ');
+    const away = goals.filter((g) => !g.isHome).map(fmt).join(' · ');
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u26BD ", [home, away].filter(Boolean).join(' | ')] });
+}
+export function FeedLine({ incidents }) {
+    const feed = incidents.filter((i) => i.kind === 'yellowCard' || i.kind === 'substitution');
+    if (feed.length === 0)
+        return null;
+    const fmt = (i) => i.kind === 'yellowCard'
+        ? `${i.minute ?? '?'}' 🟨 ${i.playerShort ?? '?'}`
+        : `${i.minute ?? '?'}' ⇄ ${i.playerShort ?? '?'}`;
+    // last 4 only — the feed is a pulse, not a log
+    return _jsxs(Text, { dimColor: true, children: ['   ', "\u25AA ", feed.slice(-4).map(fmt).join(' · ')] });
+}
+function statusLabel(m) {
+    if (m.status === 'halftime')
+        return 'HT';
+    if (m.status === 'finished')
+        return 'FT';
+    return m.minute != null ? `LIVE ${m.minute}'` : 'LIVE';
+}
+/** One match row. Upcoming → kickoff line; live/halftime/finished → score + feed. */
+export function MatchRow({ m, incidents, compact }) {
+    if (m.status === 'upcoming') {
+        if (compact) {
+            return _jsxs(Text, { dimColor: true, children: ["\u25CB ", m.home.code, "\u2014", m.away.code, " ", formatKickoff(m.startTimestamp)] });
+        }
+        return (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["\u25CB ", formatKickoff(m.startTimestamp).padEnd(13)] }), m.home.name, " \u2014 ", m.away.name, m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null] }));
+    }
+    if (compact) {
+        return (_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", statusLabel(m), " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { bold: m.status !== 'finished', dimColor: m.status === 'finished', children: [" ", statusLabel(m)] }), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null, m.varInProgress ? _jsx(Text, { dimColor: true, children: "  \u00B7  \u2696 VAR" }) : null] }), _jsxs(Text, { children: ['   ', m.home.name, "  ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', " \u2014 ", m.awayScore ?? '–'] }), "  ", m.away.name] }), _jsx(ScorerLine, { incidents: incidents }), _jsx(FeedLine, { incidents: incidents })] }));
+}

package/dist/ui/fixtures.js

@@ -0,0 +1,32 @@
+const DAY_MS = 86_400_000;
+/** Local-midnight epoch (ms) for the instant `ms`. */
+function dayKey(ms) {
+    const d = new Date(ms);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+/**
+ * Partition matches by local calendar day relative to `now`:
+ * today (diff 0), yesterday (diff -1), future (diff ≥ 1). Anything older than
+ * yesterday — or with no usable timestamp — is dropped. Each bucket is sorted
+ * ascending by kickoff. `Match.startTimestamp` is unix seconds.
+ */
+export function partitionByDay(matches, now = Date.now()) {
+    const todayKey = dayKey(now);
+    const out = { yesterday: [], today: [], future: [] };
+    for (const m of matches) {
+        if (!m.startTimestamp)
+            continue;
+        const diffDays = Math.round((dayKey(m.startTimestamp * 1000) - todayKey) / DAY_MS);
+        if (diffDays === 0)
+            out.today.push(m);
+        else if (diffDays === -1)
+            out.yesterday.push(m);
+        else if (diffDays >= 1)
+            out.future.push(m);
+    }
+    const byStart = (a, b) => a.startTimestamp - b.startTimestamp;
+    out.yesterday.sort(byStart);
+    out.today.sort(byStart);
+    out.future.sort(byStart);
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudial",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Live World Cup 2026 fixtures in your terminal — goal, red-card and VAR takeovers included",
   "type": "module",
   "bin": {
@@ -46,5 +46,5 @@
   },
   "homepage": "https://github.com/lefProg/claudial#readme",
   "bugs": "https://github.com/lefProg/claudial/issues",
-  "author": "Wim Iliano"
+  "author": "lefProg"
 }

package/dist/ui/LiveSection.js

@@ -1,39 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { ACCENT } from './Header.js';
-function ScorerLine({ incidents }) {
-    const goals = incidents.filter((i) => i.kind === 'goal');
-    if (goals.length === 0)
-        return null;
-    const fmt = (g) => `${g.minute ?? '?'}' ${g.playerShort ?? '?'}`;
-    const home = goals.filter((g) => g.isHome).map(fmt).join(' · ');
-    const away = goals.filter((g) => !g.isHome).map(fmt).join(' · ');
-    return _jsxs(Text, { dimColor: true, children: ['   ', "\u26BD ", [home, away].filter(Boolean).join(' | ')] });
-}
-function FeedLine({ incidents }) {
-    const feed = incidents.filter((i) => i.kind === 'yellowCard' || i.kind === 'substitution');
-    if (feed.length === 0)
-        return null;
-    const fmt = (i) => i.kind === 'yellowCard'
-        ? `${i.minute ?? '?'}' 🟨 ${i.playerShort ?? '?'}`
-        : `${i.minute ?? '?'}' ⇄ ${i.playerShort ?? '?'}`;
-    // last 4 only — the feed is a pulse, not a log
-    return _jsxs(Text, { dimColor: true, children: ['   ', "\u25AA ", feed.slice(-4).map(fmt).join(' · ')] });
-}
-function statusLabel(m) {
-    if (m.status === 'halftime')
-        return 'HT';
-    if (m.status === 'finished')
-        return 'FT';
-    return m.minute != null ? `LIVE ${m.minute}'` : 'LIVE';
-}
-export function LiveSection({ matches, recent, incidents, compact }) {
-    const liveIds = new Set(matches.map((m) => m.id));
-    const rows = [...matches, ...recent.filter((r) => !liveIds.has(r.id))];
-    if (rows.length === 0)
-        return null;
-    if (compact) {
-        return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { dimColor: true, children: [" ", statusLabel(m), " "] }), m.home.code, " ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', "\u2014", m.awayScore ?? '–'] }), " ", m.away.code, m.varInProgress ? _jsx(Text, { dimColor: true, children: " \u2696" }) : null] }, m.id))) }));
-    }
-    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: rows.map((m) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: m.status === 'finished' ? undefined : ACCENT, children: "\u23FA" }), _jsxs(Text, { bold: m.status !== 'finished', dimColor: m.status === 'finished', children: [" ", statusLabel(m)] }), m.group ? _jsxs(Text, { dimColor: true, children: ["  \u00B7  ", m.group] }) : null, m.varInProgress ? _jsx(Text, { dimColor: true, children: "  \u00B7  \u2696 VAR" }) : null] }), _jsxs(Text, { children: ['   ', m.home.name, "  ", _jsxs(Text, { bold: true, color: ACCENT, children: [m.homeScore ?? '–', " \u2014 ", m.awayScore ?? '–'] }), "  ", m.away.name] }), _jsx(ScorerLine, { incidents: incidents[m.id] ?? [] }), _jsx(FeedLine, { incidents: incidents[m.id] ?? [] })] }, m.id))) }));
-}