@robinthues/rt-claude-coach 0.1.2 → 0.2.0

package/dist/recovery/parse.js

@@ -0,0 +1,128 @@
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+/**
+ * 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 function unwrapPayload(payload) {
+    if (payload == null)
+        return null;
+    if (typeof payload === "string") {
+        return parseJson(payload);
+    }
+    if (typeof payload === "object" && "result" in payload) {
+        return unwrapPayload(payload.result);
+    }
+    return payload;
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error("payload could not be parsed as JSON");
+    }
+}
+/**
+ * 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 function selectReadinessEntry(payload) {
+    if (payload == null)
+        return null;
+    const entries = Array.isArray(payload)
+        ? payload
+        : [payload];
+    if (entries.length === 0)
+        return null;
+    const wakeup = entries.find((entry) => entry.context === "AFTER_WAKEUP_RESET");
+    if (wakeup)
+        return wakeup;
+    return [...entries].sort((a, b) => String(a.timestamp ?? "").localeCompare(String(b.timestamp ?? "")))[0];
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function int(value) {
+    const parsed = num(value);
+    return parsed === null ? null : Math.round(parsed);
+}
+function str(value) {
+    return typeof value === "string" ? value : null;
+}
+/** `allMetrics.metricsMap.WELLNESS_RESTING_HEART_RATE[0].value`, defensively. */
+function extractRestingHr(payload) {
+    const metricsMap = payload
+        ?.allMetrics?.metricsMap;
+    const series = metricsMap?.WELLNESS_RESTING_HEART_RATE;
+    if (!Array.isArray(series) || series.length === 0)
+        return null;
+    return int(series[0]?.value);
+}
+function unwrapGroup(input, group) {
+    try {
+        return unwrapPayload(input[group]);
+    }
+    catch (err) {
+        throw new Error(`${group}: ${err.message}`);
+    }
+}
+/**
+ * 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 function parseRecoveryDay(input) {
+    if (!DATE_PATTERN.test(input.date ?? "")) {
+        throw new Error(`invalid date: ${input.date}`);
+    }
+    const readinessRaw = unwrapGroup(input, "readiness");
+    const hrv = unwrapGroup(input, "hrv");
+    const sleep = unwrapGroup(input, "sleep");
+    const rhr = unwrapGroup(input, "rhr");
+    const readiness = selectReadinessEntry(readinessRaw);
+    const raw = {};
+    if (readinessRaw != null)
+        raw.readiness = readinessRaw;
+    if (hrv != null)
+        raw.hrv = hrv;
+    if (sleep != null)
+        raw.sleep = sleep;
+    if (rhr != null)
+        raw.rhr = rhr;
+    return {
+        date: input.date,
+        readiness_score: int(readiness?.score),
+        readiness_level: str(readiness?.level),
+        readiness_feedback: str(readiness?.feedback),
+        readiness_context: str(readiness?.context),
+        readiness_timestamp: str(readiness?.timestamp),
+        recovery_time_hours: num(readiness?.recovery_time_hours),
+        acute_load: int(readiness?.acute_load),
+        sleep_factor_percent: int(readiness?.sleep_factor_percent),
+        recovery_factor_percent: int(readiness?.recovery_factor_percent),
+        training_load_factor_percent: int(readiness?.training_load_factor_percent),
+        hrv_factor_percent: int(readiness?.hrv_factor_percent),
+        stress_history_factor_percent: int(readiness?.stress_history_factor_percent),
+        sleep_history_factor_percent: int(readiness?.sleep_history_factor_percent),
+        hrv_last_night_ms: int(hrv?.last_night_avg_hrv_ms),
+        hrv_weekly_avg_ms: int(hrv?.weekly_avg_hrv_ms),
+        hrv_status: str(hrv?.status),
+        hrv_baseline_low_ms: int(hrv?.baseline_balanced_low_ms),
+        hrv_baseline_upper_ms: int(hrv?.baseline_balanced_upper_ms),
+        sleep_seconds: int(sleep?.sleep_seconds),
+        deep_sleep_seconds: int(sleep?.deep_sleep_seconds),
+        light_sleep_seconds: int(sleep?.light_sleep_seconds),
+        rem_sleep_seconds: int(sleep?.rem_sleep_seconds),
+        awake_seconds: int(sleep?.awake_seconds),
+        sleep_score: int(sleep?.sleep_score),
+        sleep_score_qualifier: str(sleep?.sleep_score_qualifier),
+        avg_overnight_hrv: num(sleep?.avg_overnight_hrv),
+        avg_sleep_stress: num(sleep?.avg_sleep_stress),
+        resting_hr: extractRestingHr(rhr),
+        raw_json: JSON.stringify(raw),
+    };
+}

package/dist/recovery/store.d.ts

@@ -0,0 +1,14 @@
+import type { DateStatusRow, RecoveryDay } from "./types.js";
+/**
+ * Upsert one day. Every column coalesces to its existing value, so a partial
+ * re-sync (only sleep succeeded, say) never blanks columns written earlier.
+ * `raw_json` is merged group-by-group in TypeScript, because SQL coalescing
+ * would replace the whole blob and drop earlier groups.
+ */
+export declare function upsertRecoveryDay(day: RecoveryDay): void;
+/**
+ * Classify each requested date: `missing` (no row), `partial` (a row exists but
+ * at least one payload group is entirely NULL), or `present`. Order matches the
+ * requested order.
+ */
+export declare function getDateStatuses(dates: string[]): DateStatusRow[];

package/dist/recovery/store.js

@@ -0,0 +1,108 @@
+import { execute, queryJson } from "../db/client.js";
+import { escapeString, numOrNull } from "../db/sql.js";
+/**
+ * Columns written by an upsert, excluding `date`, `raw_json` and `synced_at`.
+ * These two lists must stay in sync with `garmin_daily` in `schema.sql`.
+ */
+const TEXT_COLUMNS = [
+    "readiness_level",
+    "readiness_feedback",
+    "readiness_context",
+    "readiness_timestamp",
+    "hrv_status",
+    "sleep_score_qualifier",
+];
+const NUMERIC_COLUMNS = [
+    "readiness_score",
+    "recovery_time_hours",
+    "acute_load",
+    "sleep_factor_percent",
+    "recovery_factor_percent",
+    "training_load_factor_percent",
+    "hrv_factor_percent",
+    "stress_history_factor_percent",
+    "sleep_history_factor_percent",
+    "hrv_last_night_ms",
+    "hrv_weekly_avg_ms",
+    "hrv_baseline_low_ms",
+    "hrv_baseline_upper_ms",
+    "sleep_seconds",
+    "deep_sleep_seconds",
+    "light_sleep_seconds",
+    "rem_sleep_seconds",
+    "awake_seconds",
+    "sleep_score",
+    "avg_overnight_hrv",
+    "avg_sleep_stress",
+    "resting_hr",
+];
+/** One representative column per payload group, for status classification. */
+const GROUP_MARKERS = {
+    readiness: "readiness_score",
+    hrv: "hrv_last_night_ms",
+    sleep: "sleep_seconds",
+    rhr: "resting_hr",
+};
+function mergeRawJson(date, incoming) {
+    const existing = queryJson(`SELECT raw_json FROM garmin_daily WHERE date = ${escapeString(date)};`);
+    if (existing.length === 0 || !existing[0].raw_json)
+        return incoming;
+    let previous;
+    try {
+        previous = JSON.parse(existing[0].raw_json);
+    }
+    catch {
+        previous = {};
+    }
+    const next = JSON.parse(incoming);
+    return JSON.stringify({ ...previous, ...next });
+}
+/**
+ * Upsert one day. Every column coalesces to its existing value, so a partial
+ * re-sync (only sleep succeeded, say) never blanks columns written earlier.
+ * `raw_json` is merged group-by-group in TypeScript, because SQL coalescing
+ * would replace the whole blob and drop earlier groups.
+ */
+export function upsertRecoveryDay(day) {
+    const columns = [...TEXT_COLUMNS, ...NUMERIC_COLUMNS];
+    const values = [
+        ...TEXT_COLUMNS.map((col) => escapeString(day[col])),
+        ...NUMERIC_COLUMNS.map((col) => numOrNull(day[col])),
+    ];
+    const updates = columns
+        .map((col) => `${col} = COALESCE(excluded.${col}, garmin_daily.${col})`)
+        .join(",\n      ");
+    execute(`
+    INSERT INTO garmin_daily (date, ${columns.join(", ")}, raw_json, synced_at)
+    VALUES (
+      ${escapeString(day.date)},
+      ${values.join(", ")},
+      ${escapeString(mergeRawJson(day.date, day.raw_json))},
+      datetime('now')
+    )
+    ON CONFLICT(date) DO UPDATE SET
+      ${updates},
+      raw_json = excluded.raw_json,
+      synced_at = excluded.synced_at;
+  `);
+}
+/**
+ * Classify each requested date: `missing` (no row), `partial` (a row exists but
+ * at least one payload group is entirely NULL), or `present`. Order matches the
+ * requested order.
+ */
+export function getDateStatuses(dates) {
+    if (dates.length === 0)
+        return [];
+    const markers = Object.values(GROUP_MARKERS);
+    const list = dates.map((date) => escapeString(date)).join(", ");
+    const rows = queryJson(`SELECT date, ${markers.join(", ")} FROM garmin_daily WHERE date IN (${list});`);
+    const byDate = new Map(rows.map((row) => [String(row.date), row]));
+    return dates.map((date) => {
+        const row = byDate.get(date);
+        if (!row)
+            return { date, status: "missing" };
+        const complete = markers.every((marker) => row[marker] !== null);
+        return { date, status: complete ? "present" : "partial" };
+    });
+}

package/dist/recovery/types.d.ts

@@ -0,0 +1,50 @@
+/** One row of `garmin_daily`. Every metric is nullable: absence is normal. */
+export interface RecoveryDay {
+    date: string;
+    readiness_score: number | null;
+    readiness_level: string | null;
+    readiness_feedback: string | null;
+    readiness_context: string | null;
+    readiness_timestamp: string | null;
+    recovery_time_hours: number | null;
+    acute_load: number | null;
+    sleep_factor_percent: number | null;
+    recovery_factor_percent: number | null;
+    training_load_factor_percent: number | null;
+    hrv_factor_percent: number | null;
+    stress_history_factor_percent: number | null;
+    sleep_history_factor_percent: number | null;
+    hrv_last_night_ms: number | null;
+    hrv_weekly_avg_ms: number | null;
+    hrv_status: string | null;
+    hrv_baseline_low_ms: number | null;
+    hrv_baseline_upper_ms: number | null;
+    sleep_seconds: number | null;
+    deep_sleep_seconds: number | null;
+    light_sleep_seconds: number | null;
+    rem_sleep_seconds: number | null;
+    awake_seconds: number | null;
+    sleep_score: number | null;
+    sleep_score_qualifier: string | null;
+    avg_overnight_hrv: number | null;
+    avg_sleep_stress: number | null;
+    resting_hr: number | null;
+    /** JSON object keyed by group name, holding the unwrapped MCP payloads. */
+    raw_json: string;
+}
+/** One day of verbatim MCP responses, as written by the skill's sync step. */
+export interface RecoveryDayInput {
+    date: string;
+    readiness?: unknown;
+    hrv?: unknown;
+    sleep?: unknown;
+    rhr?: unknown;
+}
+export interface RecoveryImportFile {
+    days: RecoveryDayInput[];
+}
+export type DateStatus = "present" | "partial" | "missing";
+export interface DateStatusRow {
+    date: string;
+    status: DateStatus;
+}

package/dist/recovery/types.js

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

package/dist/strava/store.d.ts

@@ -1,5 +1,6 @@
+import { escapeString } from "../db/sql.js";
 import type { StravaActivity, StravaDetailedActivity } from "./types.js";
-export declare function escapeString(str: string | null | undefined): string;
+export { escapeString };
 export declare function upsertSummaryActivity(activity: StravaActivity): void;
 export declare function insertAthlete(athlete: {
     id: number;

package/dist/strava/store.js

@@ -1,9 +1,6 @@
 import { execute, queryJson } from "../db/client.js";
-export function escapeString(str) {
-    if (str == null)
-        return "NULL";
-    return `'${str.replace(/'/g, "''")}'`;
-}
+import { escapeString } from "../db/sql.js";
+export { escapeString };
 // Summary-only upsert. On conflict, detail columns (description, private_note,
 // calories, raw_json, details_synced_at) are deliberately not updated: the
 // summary endpoint doesn't return them, and REPLACE would wipe fetched details.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinthues/rt-claude-coach",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "author": "Robin Thues",
   "license": "MIT",
   "repository": {