@robinthues/rt-claude-coach 0.1.2 → 0.2.0

package/dist/calendar/dates.d.ts

@@ -0,0 +1,24 @@
+import type { RawEvent } from "./types.js";
+/** True when an event is all-day (uses `date`, not `dateTime`). */
+export declare function isAllDay(event: RawEvent): boolean;
+/** The YYYY-MM-DD portion of an all-day time value. */
+export declare function allDayDate(value: string): string;
+/** Advance a YYYY-MM-DD string by one day, UTC-safe (no DST drift). */
+export declare function addDay(date: string): string;
+/** True when a string is a YYYY-MM-DD calendar date. */
+export declare function isIsoDate(value: string): boolean;
+/** Enumerate dates from start (inclusive) to end (exclusive). */
+export declare function datesInRange(startInclusive: string, endExclusive: string): string[];
+/** The weekday name for a YYYY-MM-DD date. */
+export declare function weekdayOf(date: string): string;
+/**
+ * Some ICU builds render midnight on a 24-hour clock as "24"; normalise it to
+ * "00" so a wall-clock hour is always in [00, 23]. Defensive against ICU
+ * variation across Node runtimes — inert where the clock is already h23.
+ */
+export declare function normalizeHour(hour: string): string;
+/** Resolve an RFC3339 timed value to wall-clock date + HH:MM in the target zone. */
+export declare function resolveWallClock(dateTime: string, timeZone: string): {
+    date: string;
+    time: string;
+};

package/dist/calendar/dates.js

@@ -0,0 +1,57 @@
+/** True when an event is all-day (uses `date`, not `dateTime`). */
+export function isAllDay(event) {
+    return Boolean(event.start?.date) && !event.start?.dateTime;
+}
+/** The YYYY-MM-DD portion of an all-day time value. */
+export function allDayDate(value) {
+    return value.slice(0, 10);
+}
+/** Advance a YYYY-MM-DD string by one day, UTC-safe (no DST drift). */
+export function addDay(date) {
+    const [y, m, d] = date.split("-").map(Number);
+    return new Date(Date.UTC(y, m - 1, d + 1)).toISOString().slice(0, 10);
+}
+/** True when a string is a YYYY-MM-DD calendar date. */
+export function isIsoDate(value) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+/** Enumerate dates from start (inclusive) to end (exclusive). */
+export function datesInRange(startInclusive, endExclusive) {
+    const out = [];
+    let cur = startInclusive;
+    while (cur < endExclusive) {
+        out.push(cur);
+        cur = addDay(cur);
+    }
+    return out;
+}
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** The weekday name for a YYYY-MM-DD date. */
+export function weekdayOf(date) {
+    const [y, m, d] = date.split("-").map(Number);
+    return WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
+}
+/**
+ * Some ICU builds render midnight on a 24-hour clock as "24"; normalise it to
+ * "00" so a wall-clock hour is always in [00, 23]. Defensive against ICU
+ * variation across Node runtimes — inert where the clock is already h23.
+ */
+export function normalizeHour(hour) {
+    return hour === "24" ? "00" : hour;
+}
+/** Resolve an RFC3339 timed value to wall-clock date + HH:MM in the target zone. */
+export function resolveWallClock(dateTime, timeZone) {
+    const dt = new Date(dateTime);
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    }).formatToParts(dt);
+    const get = (type) => parts.find((p) => p.type === type).value;
+    const hour = normalizeHour(get("hour"));
+    return { date: `${get("year")}-${get("month")}-${get("day")}`, time: `${hour}:${get("minute")}` };
+}

package/dist/calendar/index.d.ts

@@ -0,0 +1,3 @@
+export { isCancelled, isFree, isNonBlockingType, isDeclined, isBusy, eventTitle, buildAvailability, } from "./parse.js";
+export { isAllDay, allDayDate, addDay, isIsoDate, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";
+export type { RawEvent, RawEventTime, RawAttendee, CalendarEventsResponse, CalendarInput, AvailabilityInput, BusyBlock, AllDayEvent, DayAvailability, AvailabilityOutput, } from "./types.js";

package/dist/calendar/index.js

@@ -0,0 +1,2 @@
+export { isCancelled, isFree, isNonBlockingType, isDeclined, isBusy, eventTitle, buildAvailability, } from "./parse.js";
+export { isAllDay, allDayDate, addDay, isIsoDate, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";

package/dist/calendar/parse.d.ts

@@ -0,0 +1,19 @@
+import type { RawEvent, AvailabilityInput, AvailabilityOutput } from "./types.js";
+/** Google marks deleted/cancelled instances with status "cancelled". */
+export declare function isCancelled(e: RawEvent): boolean;
+/** The athlete set themselves free during this event, so it does not block training. */
+export declare function isFree(e: RawEvent): boolean;
+/** Event types that never represent a real time commitment. */
+export declare function isNonBlockingType(e: RawEvent): boolean;
+/** The athlete declined this invitation. */
+export declare function isDeclined(e: RawEvent): boolean;
+/** Whether this event should count against the athlete's availability. */
+export declare function isBusy(e: RawEvent): boolean;
+/** A display title, with a placeholder for untitled events. */
+export declare function eventTitle(e: RawEvent): string;
+/**
+ * Normalise verbatim `list_events` responses into a clean per-day picture of
+ * busy blocks and all-day events. Every date in the window appears, so a clear
+ * day reads as clear rather than missing. All-day `end` dates are exclusive.
+ */
+export declare function buildAvailability(input: AvailabilityInput): AvailabilityOutput;

package/dist/calendar/parse.js

@@ -0,0 +1,74 @@
+import { isAllDay, allDayDate, addDay, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";
+/** Google marks deleted/cancelled instances with status "cancelled". */
+export function isCancelled(e) {
+    return e.status === "cancelled";
+}
+/** The athlete set themselves free during this event, so it does not block training. */
+export function isFree(e) {
+    return e.transparency === "transparent" || e.availability === "AVAILABILITY_FREE";
+}
+const NON_BLOCKING_TYPES = new Set(["BIRTHDAY", "WORKING_LOCATION"]);
+/** Event types that never represent a real time commitment. */
+export function isNonBlockingType(e) {
+    return e.eventType !== undefined && NON_BLOCKING_TYPES.has(e.eventType);
+}
+/** The athlete declined this invitation. */
+export function isDeclined(e) {
+    const self = e.attendees?.find((a) => a.self);
+    return self?.responseStatus === "declined";
+}
+/** Whether this event should count against the athlete's availability. */
+export function isBusy(e) {
+    return !isCancelled(e) && !isFree(e) && !isNonBlockingType(e) && !isDeclined(e);
+}
+/** A display title, with a placeholder for untitled events. */
+export function eventTitle(e) {
+    const title = (e.summary ?? "").trim();
+    return title.length > 0 ? title : "(no title)";
+}
+/**
+ * Normalise verbatim `list_events` responses into a clean per-day picture of
+ * busy blocks and all-day events. Every date in the window appears, so a clear
+ * day reads as clear rather than missing. All-day `end` dates are exclusive.
+ */
+export function buildAvailability(input) {
+    const { timeZone, window } = input;
+    const days = new Map();
+    for (const date of datesInRange(window.start, window.end)) {
+        days.set(date, { date, weekday: weekdayOf(date), allDayEvents: [], busyBlocks: [] });
+    }
+    for (const cal of input.calendars) {
+        const events = cal.responses.flatMap((r) => r.events ?? []);
+        for (const event of events) {
+            if (!isBusy(event))
+                continue;
+            const title = eventTitle(event);
+            if (isAllDay(event)) {
+                const startDate = allDayDate(event.start.date);
+                const endExclusive = event.end?.date ? allDayDate(event.end.date) : addDay(startDate);
+                for (const date of datesInRange(startDate, endExclusive)) {
+                    days.get(date)?.allDayEvents.push({ title, calendar: cal.summary });
+                }
+                continue;
+            }
+            if (event.start?.dateTime && event.end?.dateTime) {
+                const start = resolveWallClock(event.start.dateTime, timeZone);
+                const end = resolveWallClock(event.end.dateTime, timeZone);
+                // A timed block is attributed to its start day; multi-day timed events are vanishingly rare.
+                days.get(start.date)?.busyBlocks.push({
+                    start: start.time,
+                    end: end.time,
+                    title,
+                    calendar: cal.summary,
+                });
+            }
+        }
+    }
+    for (const day of days.values()) {
+        day.busyBlocks.sort((a, b) => a.start.localeCompare(b.start) || a.end.localeCompare(b.end));
+    }
+    return {
+        window: { start: window.start, end: window.end, timeZone },
+        days: [...days.values()],
+    };
+}

package/dist/calendar/types.d.ts

@@ -0,0 +1,70 @@
+/** One time endpoint of a calendar event: all-day (`date`) or timed (`dateTime`). */
+export interface RawEventTime {
+    /** All-day marker, e.g. "2026-07-25T00:00:00Z" or "2026-07-25". */
+    date?: string;
+    /** Timed RFC3339 value with offset, e.g. "2026-08-04T18:00:00+02:00". */
+    dateTime?: string;
+    timeZone?: string;
+}
+export interface RawAttendee {
+    email?: string;
+    self?: boolean;
+    responseStatus?: string;
+}
+/** A single event from a `list_events` response. All fields optional. */
+export interface RawEvent {
+    summary?: string;
+    status?: string;
+    transparency?: string;
+    availability?: string;
+    eventType?: string;
+    start?: RawEventTime;
+    end?: RawEventTime;
+    attendees?: RawAttendee[];
+}
+/** One verbatim `list_events` page response. */
+export interface CalendarEventsResponse {
+    events?: RawEvent[];
+    summary?: string;
+    timeZone?: string;
+    nextPageToken?: string;
+}
+/** One selected calendar's verbatim page responses. */
+export interface CalendarInput {
+    summary: string;
+    responses: CalendarEventsResponse[];
+}
+/** The wrapper file the skill assembles and passes to the CLI. */
+export interface AvailabilityInput {
+    timeZone: string;
+    /** Window covered; `end` is exclusive, both YYYY-MM-DD. */
+    window: {
+        start: string;
+        end: string;
+    };
+    calendars: CalendarInput[];
+}
+export interface BusyBlock {
+    start: string;
+    end: string;
+    title: string;
+    calendar: string;
+}
+export interface AllDayEvent {
+    title: string;
+    calendar: string;
+}
+export interface DayAvailability {
+    date: string;
+    weekday: string;
+    allDayEvents: AllDayEvent[];
+    busyBlocks: BusyBlock[];
+}
+export interface AvailabilityOutput {
+    window: {
+        start: string;
+        end: string;
+        timeZone: string;
+    };
+    days: DayAvailability[];
+}

package/dist/calendar/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -7,6 +7,8 @@ import { getAllActivities, getAthlete } from "./strava/api.js";
 import { insertAthlete, upsertSummaryActivity } from "./strava/store.js";
 import { syncActivityDetails } from "./strava/details.js";
 import { convertPlan } from "./garmin/index.js";
+import { buildFetchList, getDateStatuses, lastNDates, parseRecoveryDay, upsertRecoveryDay, } from "./recovery/index.js";
+import { buildAvailability, isIsoDate } from "./calendar/index.js";
 import { readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
@@ -96,6 +98,42 @@ function parseArgs() {
         }
         return exportArgs;
     }
+    if (args[0] === "garmin-status") {
+        const statusArgs = {
+            command: "garmin-status",
+            days: 14,
+            json: args.includes("--json"),
+        };
+        for (const arg of args) {
+            if (arg.startsWith("--days=")) {
+                const parsed = parseInt(arg.slice("--days=".length), 10);
+                if (Number.isNaN(parsed) || parsed < 1) {
+                    log.error("--days must be a positive integer");
+                    process.exit(1);
+                }
+                statusArgs.days = parsed;
+            }
+        }
+        return statusArgs;
+    }
+    if (args[0] === "import-garmin") {
+        if (!args[1]) {
+            log.error("import-garmin command requires an input JSON file");
+            process.exit(1);
+        }
+        return { command: "import-garmin", inputFile: args[1] };
+    }
+    if (args[0] === "calendar-availability") {
+        if (!args[1]) {
+            log.error("calendar-availability command requires an input JSON file");
+            process.exit(1);
+        }
+        return {
+            command: "calendar-availability",
+            inputFile: args[1],
+            json: args.includes("--json"),
+        };
+    }
     if (args[0] === "query") {
         if (!args[1]) {
             log.error("query command requires a SQL statement");
@@ -140,6 +178,9 @@ Commands:
   auth              Get Strava authorization URL or exchange code for tokens
   render <file>     Render a training plan JSON to HTML
   export-garmin <file>  Convert a plan JSON to Garmin sync workouts
+  garmin-status     Show which dates have Garmin recovery data, and what to fetch
+  import-garmin <file>  Import Garmin recovery MCP responses into the database
+  calendar-availability <file>  Normalize calendar MCP events into per-day busy blocks
   query <sql>       Run a SQL query against the database
   help              Show this help message
 
@@ -167,6 +208,13 @@ Export Garmin Options:
   --workout=ID          Export only the workout with this id
   --date=YYYY-MM-DD     Export only workouts on this date
 
+Garmin Status Options:
+  --days=N              Days of history to check (default: 14)
+  --json                Output as JSON, including the computed fetch list
+
+Calendar Availability Options:
+  --json                Output as JSON (default: plain per-day text)
+
 Query Options:
   --json                Output as JSON (default: plain text)
 
@@ -192,6 +240,18 @@ Examples:
 
   # Query the database
   npx @robinthues/rt-claude-coach query "SELECT * FROM weekly_volume LIMIT 5"
+
+  # Which recovery dates are missing, and what should be fetched?
+  npx @robinthues/rt-claude-coach garmin-status --days=14 --json
+
+  # Import verbatim Garmin MCP responses
+  npx @robinthues/rt-claude-coach import-garmin garmin-recovery.json
+
+  # Normalize verbatim calendar MCP events into per-day availability
+  npx @robinthues/rt-claude-coach calendar-availability calendar-events.json --json
+
+  # Read recovery data back
+  npx @robinthues/rt-claude-coach query "SELECT * FROM recovery_recent LIMIT 14"
 `);
 }
 // ============================================================================
@@ -485,6 +545,125 @@ function runExportGarmin(args) {
     log.success(`Wrote ${entries.length} Garmin workout entries to: ${outputFile}`);
 }
 // ============================================================================
+// Garmin Recovery Commands
+// ============================================================================
+async function runGarminStatus(args) {
+    await initDatabase();
+    migrate();
+    const dates = lastNDates(args.days);
+    const statuses = getDateStatuses(dates);
+    const today = dates[dates.length - 1];
+    const yesterday = lastNDates(2)[0];
+    const fetch = buildFetchList(statuses, today, yesterday);
+    if (args.json) {
+        console.log(JSON.stringify({ dates: statuses, fetch }, null, 2));
+        return;
+    }
+    for (const { date, status } of statuses) {
+        console.log(`${date}  ${status}`);
+    }
+    console.log(`\nFetch these ${fetch.length} date(s): ${fetch.join(", ")}`);
+}
+async function runImportGarmin(args) {
+    let fileContents;
+    try {
+        fileContents = readFileSync(args.inputFile, "utf-8");
+    }
+    catch {
+        log.error(`Could not read input file: ${args.inputFile}`);
+        process.exit(1);
+    }
+    let file;
+    try {
+        file = JSON.parse(fileContents);
+    }
+    catch {
+        log.error("Input file is not valid JSON");
+        process.exit(1);
+    }
+    if (typeof file !== "object" || file === null || !Array.isArray(file.days)) {
+        log.error('Input file must be an object with a "days" array');
+        process.exit(1);
+    }
+    await initDatabase();
+    migrate();
+    const failures = [];
+    let imported = 0;
+    for (const day of file.days) {
+        try {
+            upsertRecoveryDay(parseRecoveryDay(day));
+            console.log(`  ${day.date ?? "(no date)"}  imported`);
+            imported++;
+        }
+        catch (err) {
+            const date = day.date ?? "(no date)";
+            const reason = err.message;
+            console.log(`  ${date}  FAILED — ${reason}`);
+            failures.push({ date, reason });
+        }
+    }
+    if (failures.length === 0) {
+        log.success(`Imported ${imported} of ${file.days.length} date(s)`);
+    }
+    else if (imported > 0) {
+        log.warn(`Imported ${imported} of ${file.days.length} date(s)`);
+    }
+    if (failures.length > 0) {
+        log.error(`${failures.length} date(s) failed; successfully parsed dates were still committed`);
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Calendar Availability Command
+// ============================================================================
+function runCalendarAvailability(args) {
+    let fileContents;
+    try {
+        fileContents = readFileSync(args.inputFile, "utf-8");
+    }
+    catch {
+        log.error(`Could not read input file: ${args.inputFile}`);
+        process.exit(1);
+    }
+    let input;
+    try {
+        input = JSON.parse(fileContents);
+    }
+    catch {
+        log.error("Input file is not valid JSON");
+        process.exit(1);
+    }
+    if (typeof input !== "object" ||
+        input === null ||
+        typeof input.timeZone !== "string" ||
+        typeof input.window !== "object" ||
+        input.window === null ||
+        typeof input.window.start !== "string" ||
+        typeof input.window.end !== "string" ||
+        !Array.isArray(input.calendars)) {
+        log.error('Input file must have "timeZone", "window" {start,end}, and a "calendars" array');
+        process.exit(1);
+    }
+    if (!isIsoDate(input.window.start) || !isIsoDate(input.window.end)) {
+        log.error('Input file "window.start" and "window.end" must be YYYY-MM-DD dates');
+        process.exit(1);
+    }
+    const output = buildAvailability(input);
+    if (args.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    for (const day of output.days) {
+        const parts = [];
+        for (const e of day.allDayEvents)
+            parts.push(`[all-day] ${e.title}`);
+        for (const b of day.busyBlocks)
+            parts.push(`${b.start}-${b.end} ${b.title}`);
+        const label = parts.length > 0 ? parts.join("; ") : "clear";
+        console.log(`${day.date} ${day.weekday.padEnd(9)} ${label}`);
+    }
+}
+// ============================================================================
 // Query Command
 // ============================================================================
 async function runQuery(args) {
@@ -519,6 +698,15 @@ async function main() {
         case "export-garmin":
             runExportGarmin(args);
             break;
+        case "garmin-status":
+            await runGarminStatus(args);
+            break;
+        case "import-garmin":
+            await runImportGarmin(args);
+            break;
+        case "calendar-availability":
+            runCalendarAvailability(args);
+            break;
         case "query":
             await runQuery(args);
             break;

package/dist/db/schema.sql

@@ -106,3 +106,67 @@ SELECT
 FROM activities
 ORDER BY start_date DESC
 LIMIT 50;
+
+-- Garmin daily recovery data (one row per calendar date)
+CREATE TABLE IF NOT EXISTS garmin_daily (
+  date TEXT PRIMARY KEY,              -- YYYY-MM-DD, local calendar date
+
+  -- Training readiness (selected entry; see src/recovery/parse.ts)
+  readiness_score INTEGER,
+  readiness_level TEXT,               -- LOW | MODERATE | HIGH | ...
+  readiness_feedback TEXT,            -- RESTED_AND_READY, WELL_DONE, ...
+  readiness_context TEXT,             -- which entry the parser selected
+  readiness_timestamp TEXT,
+  recovery_time_hours REAL,
+  acute_load INTEGER,
+
+  -- Readiness contributing factors (percent, 0-100)
+  sleep_factor_percent INTEGER,
+  recovery_factor_percent INTEGER,
+  training_load_factor_percent INTEGER,
+  hrv_factor_percent INTEGER,
+  stress_history_factor_percent INTEGER,
+  sleep_history_factor_percent INTEGER,
+
+  -- HRV
+  hrv_last_night_ms INTEGER,
+  hrv_weekly_avg_ms INTEGER,
+  hrv_status TEXT,                    -- BALANCED | UNBALANCED | LOW | ...
+  hrv_baseline_low_ms INTEGER,
+  hrv_baseline_upper_ms INTEGER,
+
+  -- Sleep
+  sleep_seconds INTEGER,
+  deep_sleep_seconds INTEGER,
+  light_sleep_seconds INTEGER,
+  rem_sleep_seconds INTEGER,
+  awake_seconds INTEGER,
+  sleep_score INTEGER,
+  sleep_score_qualifier TEXT,         -- EXCELLENT | GOOD | FAIR | POOR
+  avg_overnight_hrv REAL,
+  avg_sleep_stress REAL,
+
+  -- Resting heart rate
+  resting_hr INTEGER,
+
+  raw_json TEXT,                      -- merged raw MCP payloads for this date
+  synced_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_garmin_daily_date ON garmin_daily(date);
+
+DROP VIEW IF EXISTS recovery_recent;
+CREATE VIEW recovery_recent AS
+SELECT
+  date,
+  readiness_score,
+  readiness_level,
+  hrv_last_night_ms,
+  hrv_weekly_avg_ms,
+  hrv_status,
+  ROUND(sleep_seconds / 3600.0, 1) AS sleep_hours,
+  sleep_score,
+  resting_hr
+FROM garmin_daily
+WHERE date >= date('now', '-60 days')
+ORDER BY date DESC;

package/dist/db/sql.d.ts

@@ -0,0 +1,4 @@
+/** Quote a value as a SQL string literal, or NULL. */
+export declare function escapeString(str: string | null | undefined): string;
+/** Render a number as a SQL numeric literal, or NULL. */
+export declare function numOrNull(value: number | null | undefined): string;

package/dist/db/sql.js

@@ -0,0 +1,10 @@
+/** Quote a value as a SQL string literal, or NULL. */
+export function escapeString(str) {
+    if (str == null)
+        return "NULL";
+    return `'${str.replace(/'/g, "''")}'`;
+}
+/** Render a number as a SQL numeric literal, or NULL. */
+export function numOrNull(value) {
+    return value == null ? "NULL" : String(value);
+}

package/dist/recovery/dates.d.ts

@@ -0,0 +1,12 @@
+import type { DateStatusRow } from "./types.js";
+/** Format a Date as a local-calendar YYYY-MM-DD, matching Garmin's day grain. */
+export declare function toLocalIsoDate(d: Date): string;
+/** The last `n` local dates ending with `today`, oldest first. */
+export declare function lastNDates(n: number, today?: Date): string[];
+/**
+ * Dates the skill should fetch from the Garmin MCP: anything missing or
+ * partial, plus today and yesterday unconditionally — Garmin revises last
+ * night's sleep and HRV hours after the fact, so a `present` row for those two
+ * days may still be stale.
+ */
+export declare function buildFetchList(statuses: DateStatusRow[], today: string, yesterday: string): string[];

package/dist/recovery/dates.js

@@ -0,0 +1,31 @@
+/** Format a Date as a local-calendar YYYY-MM-DD, matching Garmin's day grain. */
+export function toLocalIsoDate(d) {
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+/** The last `n` local dates ending with `today`, oldest first. */
+export function lastNDates(n, today = new Date()) {
+    const dates = [];
+    for (let offset = n - 1; offset >= 0; offset--) {
+        const d = new Date(today.getTime());
+        d.setDate(d.getDate() - offset);
+        dates.push(toLocalIsoDate(d));
+    }
+    return dates;
+}
+/**
+ * Dates the skill should fetch from the Garmin MCP: anything missing or
+ * partial, plus today and yesterday unconditionally — Garmin revises last
+ * night's sleep and HRV hours after the fact, so a `present` row for those two
+ * days may still be stale.
+ */
+export function buildFetchList(statuses, today, yesterday) {
+    const fetch = new Set([today, yesterday]);
+    for (const { date, status } of statuses) {
+        if (status !== "present")
+            fetch.add(date);
+    }
+    return [...fetch].sort();
+}

package/dist/recovery/index.d.ts

@@ -0,0 +1,4 @@
+export { unwrapPayload, selectReadinessEntry, parseRecoveryDay } from "./parse.js";
+export { upsertRecoveryDay, getDateStatuses } from "./store.js";
+export { toLocalIsoDate, lastNDates, buildFetchList } from "./dates.js";
+export type { RecoveryDay, RecoveryDayInput, RecoveryImportFile, DateStatus, DateStatusRow, } from "./types.js";

package/dist/recovery/index.js

@@ -0,0 +1,3 @@
+export { unwrapPayload, selectReadinessEntry, parseRecoveryDay } from "./parse.js";
+export { upsertRecoveryDay, getDateStatuses } from "./store.js";
+export { toLocalIsoDate, lastNDates, buildFetchList } from "./dates.js";

package/dist/recovery/parse.d.ts

@@ -0,0 +1,21 @@
+import type { RecoveryDay, RecoveryDayInput } from "./types.js";
+/**
+ * Garmin MCP tools return `{ result: "<JSON string>" }` — the payload is a
+ * string containing JSON, not an object. Unwrap it, tolerating an already
+ * parsed object so a hand-assembled import file also works.
+ */
+export declare function unwrapPayload(payload: unknown): unknown;
+/**
+ * Readiness returns several entries per day with different contexts and
+ * different scores. Prefer the morning reading: it answers "should I train
+ * hard today". The post-exercise reset reflects the session just completed and
+ * would double-count fatigue already visible in that day's Strava activity.
+ */
+export declare function selectReadinessEntry(payload: unknown): Record<string, unknown> | null;
+/**
+ * Map one day of verbatim MCP payloads onto a flat row. All field mapping
+ * lives here so a Garmin field rename fails a test instead of being silently
+ * absorbed. Throws on an invalid date or unparseable payload; never on absent
+ * data.
+ */
+export declare function parseRecoveryDay(input: RecoveryDayInput): RecoveryDay;