@semanticintent/semantic-chirp-intelligence-mcp 3.0.0 → 4.0.0

package/build/services/NhlStatsService.js

@@ -0,0 +1,297 @@
+/**
+ * 📊 NHL Stats Service — player identity and statistics, no account required
+ *
+ * The counterpart to NhlScheduleService. Together they replace every external
+ * data source this server used to need:
+ *
+ *   • who exists, and which club they play for  → club rosters
+ *   • what they have actually produced          → club season stats
+ *
+ * Both come from the NHL's public API: no key, no OAuth, no approval, no
+ * per-user account binding. That is the whole point of v4 — the intelligence
+ * layer works for anyone, on any fantasy platform, or none at all.
+ *
+ * 🏛️ Rule 1 (Semantic Over Structural): callers ask for a player by the name a
+ * human would type, not by a provider's internal id.
+ * 🏛️ Rule 3 (Observable Anchoring): a name that cannot be resolved is reported
+ * as unresolved. It is never silently matched to the nearest guess.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { NHL_TRICODES } from '../domain/nhl-teams.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const NHL_API_BASE = 'https://api-web.nhle.com/v1';
+const GAME_TYPE_REGULAR_SEASON = 2;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export class NhlStatsService {
+    byId = new Map();
+    byNameKey = new Map();
+    byLastName = new Map();
+    rosterSeason = null;
+    statsSeason = null;
+    loaded = false;
+    loadError = null;
+    inFlight = null;
+    cacheDir;
+    constructor(cacheDir) {
+        this.cacheDir = cacheDir ?? path.join(__dirname, '..', '..', '.nhl-schedule-cache');
+    }
+    // ==========================================
+    // 🎯 Loading
+    // ==========================================
+    /**
+     * Load every club's roster and season statistics.
+     *
+     * @param rosterSeason which season's rosters define current club membership
+     * @param statsSeason  which season's numbers to attach. Defaults to the
+     *                     previous season, because before opening night the
+     *                     current season has no statistics at all — and a draft
+     *                     is exactly when you need last season's line.
+     */
+    async load(rosterSeason, statsSeason) {
+        const roster = rosterSeason ?? NhlStatsService.currentSeason();
+        const stats = statsSeason ?? NhlStatsService.previousSeason(roster);
+        if (this.loaded && this.rosterSeason === roster && this.statsSeason === stats)
+            return;
+        if (this.inFlight)
+            return this.inFlight;
+        this.inFlight = this.performLoad(roster, stats).finally(() => {
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async performLoad(rosterSeason, statsSeason) {
+        this.rosterSeason = rosterSeason;
+        this.statsSeason = statsSeason;
+        this.loadError = null;
+        const cached = this.readCache(rosterSeason, statsSeason);
+        if (cached) {
+            this.index(cached.players);
+            this.loaded = true;
+            return;
+        }
+        const results = await Promise.all(NHL_TRICODES.map(team => this.fetchClub(team, rosterSeason, statsSeason)));
+        const failed = NHL_TRICODES.filter((_, i) => results[i] === null);
+        // A partial league makes "best available player" quietly wrong, so a
+        // partial load is treated as no load at all.
+        if (failed.length > 0) {
+            this.loaded = false;
+            this.loadError = `NHL player data unavailable for ${failed.length} club(s): ${failed.join(', ')}`;
+            return;
+        }
+        const players = results.flat();
+        this.index(players);
+        this.loaded = true;
+        this.writeCache(rosterSeason, statsSeason, players);
+    }
+    async fetchClub(team, rosterSeason, statsSeason) {
+        try {
+            const [rosterRes, statsRes] = await Promise.all([
+                fetch(`${NHL_API_BASE}/roster/${team}/${rosterSeason}`),
+                fetch(`${NHL_API_BASE}/club-stats/${team}/${statsSeason}/${GAME_TYPE_REGULAR_SEASON}`)
+            ]);
+            if (!rosterRes.ok)
+                return null;
+            const rosterData = await rosterRes.json();
+            // Stats are best-effort: a club with no published line still has players.
+            const statsData = statsRes.ok ? await statsRes.json() : { skaters: [], goalies: [] };
+            const statsById = new Map();
+            for (const s of statsData.skaters ?? []) {
+                statsById.set(String(s.playerId), this.skaterStats(s));
+            }
+            for (const g of statsData.goalies ?? []) {
+                statsById.set(String(g.playerId), this.goalieStats(g));
+            }
+            const players = [];
+            for (const group of ['forwards', 'defensemen', 'goalies']) {
+                for (const p of rosterData[group] ?? []) {
+                    const id = String(p.id);
+                    players.push({
+                        player_id: id,
+                        name: `${p.firstName?.default ?? ''} ${p.lastName?.default ?? ''}`.trim(),
+                        team,
+                        position: p.positionCode ?? (group === 'goalies' ? 'G' : '?'),
+                        stats: statsById.get(id)
+                    });
+                }
+            }
+            return players;
+        }
+        catch {
+            return null;
+        }
+    }
+    skaterStats(s) {
+        return {
+            games_played: Number(s.gamesPlayed ?? 0),
+            goals: Number(s.goals ?? 0),
+            assists: Number(s.assists ?? 0),
+            points: Number(s.points ?? 0),
+            plus_minus: Number(s.plusMinus ?? 0),
+            penalty_minutes: Number(s.penaltyMinutes ?? 0),
+            shots: Number(s.shots ?? 0),
+            power_play_goals: Number(s.powerPlayGoals ?? 0),
+            short_handed_goals: Number(s.shorthandedGoals ?? 0),
+            game_winning_goals: Number(s.gameWinningGoals ?? 0),
+            time_on_ice_per_game: Number(s.avgTimeOnIcePerGame ?? 0)
+        };
+    }
+    goalieStats(g) {
+        return {
+            games_played: Number(g.gamesPlayed ?? 0),
+            wins: Number(g.wins ?? 0),
+            losses: Number(g.losses ?? 0),
+            goals_against_average: Number(g.goalsAgainstAverage ?? 0),
+            // The NHL feed spells this savePercentage; it can be null for low samples.
+            save_percentage: g.savePercentage === null || g.savePercentage === undefined
+                ? undefined
+                : Number(g.savePercentage),
+            shutouts: Number(g.shutouts ?? 0),
+            saves: Number(g.saves ?? 0),
+            goals_against: Number(g.goalsAgainst ?? 0)
+        };
+    }
+    // ==========================================
+    // 🎯 Indexing and resolution
+    // ==========================================
+    index(players) {
+        this.byId = new Map();
+        this.byNameKey = new Map();
+        this.byLastName = new Map();
+        for (const p of players) {
+            this.byId.set(p.player_id, p);
+            const key = NhlStatsService.nameKey(p.name);
+            const bucket = this.byNameKey.get(key) ?? [];
+            bucket.push(p);
+            this.byNameKey.set(key, bucket);
+            const last = NhlStatsService.nameKey(p.name.split(/\s+/).slice(-1)[0]);
+            const lastBucket = this.byLastName.get(last) ?? [];
+            lastBucket.push(p);
+            this.byLastName.set(last, lastBucket);
+        }
+    }
+    /**
+     * Normalize a name for matching: lower-cased, accents folded, punctuation and
+     * spacing removed. Handles "Stützle" vs "Stutzle" and "J.T. Miller" vs
+     * "JT Miller", both of which people type either way.
+     */
+    static nameKey(name) {
+        return String(name)
+            .normalize('NFD')
+            .replace(/\p{Diacritic}/gu, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '');
+    }
+    /**
+     * Resolve a human-typed name to a player.
+     *
+     * Accepts "Auston Matthews", "auston matthews", "MATTHEWS, Auston" and
+     * "Matthews". A bare surname resolves only when exactly one player carries
+     * it; otherwise the candidates are returned so the caller can ask rather
+     * than guess.
+     */
+    resolve(input) {
+        const raw = String(input ?? '').trim();
+        if (!raw)
+            return { input: raw, player: null, reason: 'empty' };
+        // "Lastname, Firstname" -> "Firstname Lastname"
+        const normalized = raw.includes(',')
+            ? raw.split(',').map(s => s.trim()).reverse().join(' ')
+            : raw;
+        const exact = this.byNameKey.get(NhlStatsService.nameKey(normalized));
+        if (exact?.length === 1)
+            return { input: raw, player: exact[0] };
+        if (exact && exact.length > 1) {
+            return { input: raw, player: null, ambiguous: exact, reason: 'multiple players share this name' };
+        }
+        // Surname only
+        const surnameBucket = this.byLastName.get(NhlStatsService.nameKey(normalized));
+        if (surnameBucket?.length === 1)
+            return { input: raw, player: surnameBucket[0] };
+        if (surnameBucket && surnameBucket.length > 1) {
+            return { input: raw, player: null, ambiguous: surnameBucket, reason: 'surname matches several players' };
+        }
+        return { input: raw, player: null, reason: 'no NHL player found with that name' };
+    }
+    // ==========================================
+    // 🎯 Queries
+    // ==========================================
+    isAvailable() {
+        return this.loaded && this.byId.size > 0;
+    }
+    getUnavailableReason() {
+        if (this.isAvailable())
+            return null;
+        return this.loadError ?? 'NHL player data has not been loaded yet';
+    }
+    getById(playerId) {
+        return this.byId.get(String(playerId)) ?? null;
+    }
+    getAll() {
+        return [...this.byId.values()];
+    }
+    getByTeam(team) {
+        return this.getAll().filter(p => p.team === team);
+    }
+    getPlayerCount() {
+        return this.byId.size;
+    }
+    getSeasons() {
+        return { roster: this.rosterSeason, stats: this.statsSeason };
+    }
+    // ==========================================
+    // 🎯 Seasons
+    // ==========================================
+    /** Season id for today, rolling over in August. */
+    static currentSeason(date = new Date()) {
+        const year = date.getUTCFullYear();
+        const start = date.getUTCMonth() >= 7 ? year : year - 1;
+        return `${start}${start + 1}`;
+    }
+    /** The season before the given one, e.g. 20262027 -> 20252026. */
+    static previousSeason(season) {
+        const start = Number(season.slice(0, 4)) - 1;
+        return `${start}${start + 1}`;
+    }
+    // ==========================================
+    // 🎯 Cache
+    // ==========================================
+    cachePath(rosterSeason, statsSeason) {
+        return path.join(this.cacheDir, `players-${rosterSeason}-${statsSeason}.json`);
+    }
+    readCache(rosterSeason, statsSeason) {
+        try {
+            const file = this.cachePath(rosterSeason, statsSeason);
+            if (!fs.existsSync(file))
+                return null;
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (Date.now() - parsed.fetched_at > CACHE_TTL_MS)
+                return null;
+            if (!Array.isArray(parsed.players) || parsed.players.length === 0)
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    writeCache(rosterSeason, statsSeason, players) {
+        try {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+            const payload = {
+                roster_season: rosterSeason,
+                stats_season: statsSeason,
+                fetched_at: Date.now(),
+                players
+            };
+            fs.writeFileSync(this.cachePath(rosterSeason, statsSeason), JSON.stringify(payload));
+        }
+        catch (error) {
+            console.error('[DEBUG] Could not write NHL player cache:', error);
+        }
+    }
+}
+/** Shared instance — one player index serves every analysis in the process. */
+export const NHL_STATS = new NhlStatsService();

package/build/services/RosterStore.js

@@ -0,0 +1,233 @@
+/**
+ * 📋 Roster Store — league state without a league account
+ *
+ * v4 gets roster, opponent and standings from what the user pastes, rather than
+ * from a platform API. That removes the account binding entirely: the same
+ * server works for a Yahoo league, an ESPN league, Sleeper, or a spreadsheet.
+ *
+ * Pasted text is messy by nature, so parsing is deliberately forgiving about
+ * format and deliberately strict about identity:
+ *
+ *   🏛️ Rule 3 (Observable Anchoring): a name that does not resolve to exactly
+ *   one NHL player is reported back as unresolved or ambiguous. It is never
+ *   guessed. A roster silently containing the wrong player is worse than a
+ *   roster that tells you it could not read line 7.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { NHL_STATS } from './NhlStatsService.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** Tokens that appear beside names in pasted rosters and are never names. */
+const NOISE = new Set([
+    'c', 'lw', 'rw', 'd', 'g', 'w', 'f', 'util', 'bn', 'ir', 'ir+', 'na',
+    'bench', 'forwards', 'defense', 'defensemen', 'goalies', 'goaltenders',
+    'starters', 'reserve', 'injured', 'total', 'player', 'pos', 'team',
+    'opp', 'status', 'add', 'drop', 'pre-game', 'final', 'q', 'o', 'dtd'
+]);
+/** Slot labels worth preserving when a paste includes them. */
+const SLOT_TOKENS = new Set(['bn', 'ir', 'ir+', 'na', 'util', 'c', 'lw', 'rw', 'd', 'g']);
+export class RosterStore {
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir ?? path.join(__dirname, '..', '..', '.chirp-data');
+    }
+    // ==========================================
+    // 🎯 Parsing pasted text
+    // ==========================================
+    /**
+     * Turn pasted text into resolved players.
+     *
+     * Handles one player per line in the shapes people actually paste:
+     *   Auston Matthews
+     *   MATTHEWS, Auston
+     *   C  Auston Matthews  TOR - C  Q
+     *   1. Auston Matthews (TOR - C)
+     *   Auston Matthews, TOR, C, 60 GP, 27 G
+     */
+    parseRoster(text) {
+        const resolved = [];
+        const unresolved = [];
+        const ambiguous = [];
+        const seen = new Set();
+        const lines = String(text ?? '')
+            .split(/\r?\n/)
+            .map(l => l.trim())
+            .filter(Boolean);
+        for (const line of lines) {
+            const slot = this.detectSlot(line);
+            const candidates = this.candidateNames(line);
+            if (candidates.length === 0)
+                continue; // header or decoration
+            let resolution = null;
+            for (const candidate of candidates) {
+                const attempt = NHL_STATS.resolve(candidate);
+                if (attempt.player) {
+                    resolution = attempt;
+                    break;
+                }
+                // Keep the most informative failure to report.
+                if (!resolution || attempt.ambiguous)
+                    resolution = attempt;
+            }
+            if (resolution?.player) {
+                if (seen.has(resolution.player.player_id))
+                    continue;
+                seen.add(resolution.player.player_id);
+                resolved.push(this.toStored(resolution.player, slot));
+            }
+            else if (resolution?.ambiguous) {
+                ambiguous.push({
+                    line,
+                    candidates: resolution.ambiguous.map(p => `${p.name} (${p.team} ${p.position})`)
+                });
+            }
+            else if (resolution) {
+                unresolved.push({ line, reason: resolution.reason ?? 'no match' });
+            }
+        }
+        return { resolved, unresolved, ambiguous, lines_read: lines.length };
+    }
+    /**
+     * Extract plausible name strings from one pasted line, most specific first.
+     *
+     * Pasted rows carry positions, team codes, injury flags and statistics
+     * around the name. Rather than trying to write one regex for every fantasy
+     * site's layout, this produces a few candidates and lets the NHL index
+     * decide which is a real player.
+     */
+    candidateNames(line) {
+        // Drop leading rank numbers, bracketed groups and anything after a stat run.
+        let cleaned = line
+            .replace(/^\s*\d+[.)]\s*/, '')
+            .replace(/\([^)]*\)/g, ' ')
+            .replace(/\[[^\]]*\]/g, ' ');
+        // "Lastname, Firstname" is common enough to try verbatim first.
+        const candidates = [];
+        const commaForm = cleaned.match(/^\s*([A-Za-zÀ-ÿ'''.\-]+)\s*,\s*([A-Za-zÀ-ÿ'''.\-]+)/);
+        if (commaForm)
+            candidates.push(`${commaForm[2]} ${commaForm[1]}`);
+        // Split on separators, then keep runs of word-like tokens that are not noise.
+        const tokens = cleaned
+            .split(/[\t|,;]+|\s{2,}|\s+-\s+/)
+            .flatMap(seg => seg.trim())
+            .filter(Boolean);
+        for (const segment of tokens) {
+            const words = segment
+                .split(/\s+/)
+                .filter(w => /[A-Za-zÀ-ÿ]/.test(w) && !NOISE.has(w.toLowerCase().replace(/[^a-z+]/g, '')));
+            if (words.length >= 2)
+                candidates.push(words.slice(0, 3).join(' '));
+            if (words.length >= 2)
+                candidates.push(words.slice(0, 2).join(' '));
+            if (words.length === 1 && words[0].length > 2)
+                candidates.push(words[0]);
+        }
+        return [...new Set(candidates)];
+    }
+    /** Pull a lineup slot out of a line when one is present. */
+    detectSlot(line) {
+        const first = line.trim().split(/[\s\t|,]+/)[0]?.toLowerCase().replace(/[^a-z+]/g, '');
+        if (first && SLOT_TOKENS.has(first))
+            return first.toUpperCase();
+        if (/\bIR\+?\b/.test(line))
+            return 'IR';
+        if (/\bBN\b|\bbench\b/i.test(line))
+            return 'BN';
+        return undefined;
+    }
+    toStored(player, slot) {
+        return {
+            player_id: player.player_id,
+            name: player.name,
+            team: player.team,
+            position: player.position,
+            ...(slot ? { slot } : {})
+        };
+    }
+    // ==========================================
+    // 🎯 Standings
+    // ==========================================
+    /**
+     * Parse pasted league standings. Team names are free text — there is no
+     * authority to resolve them against — so this only structures what it reads.
+     */
+    parseStandings(text) {
+        const rows = [];
+        for (const raw of String(text ?? '').split(/\r?\n/)) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            const rankMatch = line.match(/^\s*(\d{1,2})[.)]?\s+(.+)$/);
+            const rest = rankMatch ? rankMatch[2] : line;
+            const record = rest.match(/\b(\d{1,3}\s*-\s*\d{1,3}(?:\s*-\s*\d{1,3})?)\b/);
+            const points = rest.match(/\b(\d{1,4}(?:\.\d+)?)\s*(?:pts?|points)\b/i);
+            const teamName = rest
+                .replace(record?.[0] ?? '', '')
+                .replace(points?.[0] ?? '', '')
+                .replace(/\s{2,}/g, ' ')
+                .trim();
+            if (!teamName || /^(rank|team|record|pts|points)$/i.test(teamName))
+                continue;
+            rows.push({
+                ...(rankMatch ? { rank: Number(rankMatch[1]) } : {}),
+                team_name: teamName,
+                ...(record ? { record: record[1].replace(/\s/g, '') } : {}),
+                ...(points ? { points: Number(points[1]) } : {})
+            });
+        }
+        return rows;
+    }
+    // ==========================================
+    // 🎯 Persistence
+    // ==========================================
+    filePath(name) {
+        return path.join(this.dataDir, `${name}.json`);
+    }
+    write(name, value) {
+        fs.mkdirSync(this.dataDir, { recursive: true });
+        fs.writeFileSync(this.filePath(name), JSON.stringify(value, null, 2));
+    }
+    read(name) {
+        try {
+            const file = this.filePath(name);
+            if (!fs.existsSync(file))
+                return null;
+            return JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    saveRoster(key, players, label) {
+        const stored = { label, players, updated_at: new Date().toISOString() };
+        this.write(key, stored);
+        return stored;
+    }
+    getRoster(key) {
+        return this.read(key);
+    }
+    saveStandings(rows) {
+        this.write('standings', { rows, updated_at: new Date().toISOString() });
+    }
+    getStandings() {
+        return this.read('standings');
+    }
+    clear(key) {
+        try {
+            const file = this.filePath(key);
+            if (!fs.existsSync(file))
+                return false;
+            fs.unlinkSync(file);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getDataDir() {
+        return this.dataDir;
+    }
+}
+export const ROSTER_STORE = new RosterStore();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@semanticintent/semantic-chirp-intelligence-mcp",
-  "version": "3.0.0",
-  "description": "Semantic Intent pattern implementation for fantasy hockey intelligence - AI analysis that chirps you into championships",
+  "version": "4.0.0",
+  "description": "Universal fantasy hockey intelligence \u2014 a Model Context Protocol server that reads NHL schedule and player data and analyses any roster you paste. No account, no API key, no platform lock-in.",
   "type": "module",
   "main": "build/index.js",
   "scripts": {
-    "build": "tsc",
+    "build": "npm run clean && tsc",
     "watch": "tsc --watch",
     "dev": "node --watch build/index.js",
     "start": "node build/index.js",
@@ -13,38 +13,37 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "preflight": "npm run build && node scripts/preflight.mjs",
+    "smoke": "npm run build && node scripts/smoke.mjs",
+    "clean": "rm -rf build",
+    "prepublishOnly": "npm run build && npm test"
   },
   "keywords": [
     "mcp",
     "semantic-intent",
     "fantasy-hockey",
+    "nhl",
     "chirp",
     "intelligence",
-    "yahoo-fantasy",
-    "ice"
+    "ice",
+    "model-context-protocol"
   ],
   "author": "semanticintent",
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/semanticintent/semantic-chirp-intelligence-mcp.git"
+    "url": "https://github.com/semanticintent/semantic-chirp-intelligence-mcp.git"
   },
   "devDependencies": {
     "@types/node": "^24.7.0",
-    "@types/xml2js": "^0.4.14",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/ui": "^4.1.10",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.10"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.19.1",
-    "dotenv": "^17.2.3",
-    "selfsigned": "^3.0.1",
-    "xml2js": "^0.6.2"
+    "dotenv": "^17.4.2"
   }
 }

package/scripts/preflight.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * 🚦 Preflight — is this server ready to run?
+ *
+ * v4 needs no credentials, no OAuth and no platform account, so this checks
+ * only what actually matters: the build, the NHL public API, and whether a
+ * roster has been provided yet.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+let failures = 0;
+const ok = (m) => console.log(`  ✅ ${m}`);
+const bad = (m) => { failures++; console.log(`  ❌ ${m}`); };
+const info = (m) => console.log(`  ℹ️  ${m}`);
+
+console.log('\n🚦 CHIRP preflight\n');
+
+console.log('Build');
+fs.existsSync('build/index.js')
+  ? ok('build/index.js present')
+  : bad('build/index.js missing — run `npm run build`');
+
+console.log('\nNHL public API (no key required)');
+for (const [label, url, check] of [
+  ['schedule', 'https://api-web.nhle.com/v1/club-schedule-season/TOR/20262027',
+    d => `${(d.games ?? []).filter(g => g.gameType === 2).length} regular-season games for TOR`],
+  ['rosters', 'https://api-web.nhle.com/v1/roster/TOR/20262027',
+    d => `${(d.forwards ?? []).length + (d.defensemen ?? []).length + (d.goalies ?? []).length} players on TOR`],
+  ['standings', 'https://api-web.nhle.com/v1/standings/now',
+    d => `${(d.standings ?? []).length} teams`]
+]) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) { bad(`${label}: HTTP ${res.status}`); continue; }
+    ok(`${label} reachable — ${check(await res.json())}`);
+  } catch (error) {
+    bad(`${label} unreachable: ${error.message}`);
+  }
+}
+
+for (const [dir, label] of [['.nhl-schedule-cache', 'NHL data cache'], ['.chirp-data', 'stored league data']]) {
+  fs.existsSync(dir)
+    ? info(`${label}: ${fs.readdirSync(dir).join(', ') || '(empty)'}`)
+    : info(`${label}: none yet`);
+}
+
+console.log('\nYour league');
+const rosterFile = path.join('.chirp-data', 'roster.json');
+if (fs.existsSync(rosterFile)) {
+  try {
+    const r = JSON.parse(fs.readFileSync(rosterFile, 'utf8'));
+    ok(`roster stored: "${r.label}" — ${r.players.length} players (updated ${r.updated_at})`);
+  } catch {
+    bad('roster file present but unreadable');
+  }
+} else {
+  info('no roster yet — paste one with the `set_roster` tool, then everything else works');
+}
+
+console.log(
+  failures === 0
+    ? '\n✅ Preflight clean — no credentials needed.\n'
+    : `\n❌ ${failures} check(s) failed.\n`
+);
+process.exit(failures === 0 ? 0 : 1);