@robinthues/rt-claude-coach 0.1.0

package/dist/schema/training-plan.js

@@ -0,0 +1,88 @@
+/**
+ * Training Plan JSON Schema
+ *
+ * Designed to be comprehensive enough for export to:
+ * - Zwift (.zwo workouts)
+ * - Garmin Connect (.fit workouts)
+ * - TrainingPeaks
+ * - Other training platforms
+ */
+// Default preferences (metric)
+export const defaultPreferences = {
+    swim: "meters",
+    bike: "kilometers",
+    run: "kilometers",
+    firstDayOfWeek: "monday",
+};
+// ============================================================================
+// Example/Template
+// ============================================================================
+export const exampleWorkout = {
+    id: "week1-tue-swim",
+    sport: "swim",
+    type: "technique",
+    name: "Technique + Endurance",
+    description: "Focus on catch and pull mechanics with aerobic base work",
+    durationMinutes: 60,
+    distanceMeters: 2500,
+    primaryZone: "Zone 2",
+    targetHR: { low: 120, high: 135 },
+    structure: {
+        warmup: [
+            {
+                type: "warmup",
+                name: "Easy swim",
+                duration: { unit: "meters", value: 300 },
+                intensity: { unit: "css_offset", value: 15, description: "CSS + 15s/100m" },
+            },
+            {
+                type: "warmup",
+                name: "Drill set",
+                duration: { unit: "meters", value: 200 },
+                intensity: { unit: "rpe", value: 3, description: "Easy" },
+                notes: "4x50m: catch-up, fingertip drag, fist drill, swim",
+            },
+        ],
+        main: [
+            {
+                type: "interval_set",
+                name: "Threshold set",
+                repeats: 5,
+                steps: [
+                    {
+                        type: "work",
+                        duration: { unit: "meters", value: 100 },
+                        intensity: { unit: "css_offset", value: 0, description: "CSS pace" },
+                    },
+                    {
+                        type: "rest",
+                        duration: { unit: "seconds", value: 15 },
+                        intensity: { unit: "rpe", value: 1 },
+                    },
+                ],
+            },
+            {
+                type: "work",
+                name: "Aerobic pull",
+                duration: { unit: "meters", value: 800 },
+                intensity: { unit: "css_offset", value: 10, description: "CSS + 10s" },
+                notes: "With pull buoy, focus on rotation",
+            },
+        ],
+        cooldown: [
+            {
+                type: "cooldown",
+                name: "Easy swim",
+                duration: { unit: "meters", value: 200 },
+                intensity: { unit: "rpe", value: 2 },
+            },
+        ],
+        totalDuration: { unit: "minutes", value: 60 },
+        estimatedTSS: 45,
+    },
+    humanReadable: `Warm-up: 300m easy, 4x50m drills
+Main: 5x100m @ CSS, 15s rest
+      800m pull @ CSS+10
+Cool-down: 200m easy`,
+    completed: false,
+};

package/dist/strava/api.d.ts

@@ -0,0 +1,23 @@
+import type { Tokens } from "../lib/config.js";
+import { type ReadRateLimit } from "./rate-limit.js";
+import type { StravaActivity, StravaAthlete, StravaDetailedActivity } from "./types.js";
+export declare function getAthlete(tokens: Tokens): Promise<StravaAthlete>;
+export declare function getActivities(tokens: Tokens, after: number, before?: number, page?: number, perPage?: number): Promise<StravaActivity[]>;
+export declare function getAllActivities(tokens: Tokens, afterDate: Date): Promise<StravaActivity[]>;
+export interface DetailFetchOptions {
+    retries?: number;
+    retryDelayMs?: number;
+}
+export type ActivityDetailResult = {
+    status: "ok";
+    activity: StravaDetailedActivity;
+    rateLimit: ReadRateLimit | null;
+} | {
+    status: "not-found";
+} | {
+    status: "rate-limited";
+} | {
+    status: "error";
+    httpStatus: number;
+};
+export declare function getActivityDetail(tokens: Tokens, id: number, opts?: DetailFetchOptions): Promise<ActivityDetailResult>;

package/dist/strava/api.js

@@ -0,0 +1,88 @@
+import { log } from "../lib/logging.js";
+import { parseReadRateLimit } from "./rate-limit.js";
+const API_BASE = "https://www.strava.com/api/v3";
+async function fetchWithRetry(url, options, retries = 3) {
+    const response = await fetch(url, options);
+    if (response.status === 429) {
+        const retryAfter = parseInt(response.headers.get("retry-after") || "60");
+        log.warn(`Rate limited. Waiting ${retryAfter}s...`);
+        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+        return fetchWithRetry(url, options, retries);
+    }
+    if (!response.ok && retries > 0) {
+        log.warn(`Request failed (${response.status}), retrying...`);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return fetchWithRetry(url, options, retries - 1);
+    }
+    return response;
+}
+export async function getAthlete(tokens) {
+    const response = await fetchWithRetry(`${API_BASE}/athlete`, {
+        headers: { Authorization: `Bearer ${tokens.access_token}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch athlete: ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function getActivities(tokens, after, before, page = 1, perPage = 100) {
+    const url = new URL(`${API_BASE}/athlete/activities`);
+    url.searchParams.set("after", after.toString());
+    if (before) {
+        url.searchParams.set("before", before.toString());
+    }
+    url.searchParams.set("page", page.toString());
+    url.searchParams.set("per_page", perPage.toString());
+    const response = await fetchWithRetry(url.toString(), {
+        headers: { Authorization: `Bearer ${tokens.access_token}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch activities: ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function getAllActivities(tokens, afterDate) {
+    const after = Math.floor(afterDate.getTime() / 1000);
+    const activities = [];
+    let page = 1;
+    const perPage = 100;
+    log.start(`Fetching activities since ${afterDate.toISOString().split("T")[0]}...`);
+    while (true) {
+        const batch = await getActivities(tokens, after, undefined, page, perPage);
+        activities.push(...batch);
+        log.progress(`   Fetched ${activities.length} activities...`);
+        if (batch.length < perPage) {
+            break;
+        }
+        page++;
+        // Small delay to be nice to the API
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    log.progressEnd();
+    log.success(`Fetched ${activities.length} activities total`);
+    return activities;
+}
+// Deliberately not fetchWithRetry: the detail pass must stop on 429, not wait
+// out the 15-minute window inside a sync run.
+export async function getActivityDetail(tokens, id, opts = {}) {
+    const { retries = 2, retryDelayMs = 1000 } = opts;
+    const response = await fetch(`${API_BASE}/activities/${id}`, {
+        headers: { Authorization: `Bearer ${tokens.access_token}` },
+    });
+    if (response.status === 429)
+        return { status: "rate-limited" };
+    if (response.status === 404)
+        return { status: "not-found" };
+    if (!response.ok) {
+        if (retries > 0) {
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            return getActivityDetail(tokens, id, { retries: retries - 1, retryDelayMs });
+        }
+        return { status: "error", httpStatus: response.status };
+    }
+    return {
+        status: "ok",
+        activity: await response.json(),
+        rateLimit: parseReadRateLimit(response.headers),
+    };
+}

package/dist/strava/details.d.ts

@@ -0,0 +1,11 @@
+import type { Tokens } from "../lib/config.js";
+import { type DetailFetchOptions } from "./api.js";
+export interface DetailSyncResult {
+    fetched: number;
+    total: number;
+    stopped: "complete" | "budget" | "rate-limited";
+}
+export declare function syncActivityDetails(tokens: Tokens, opts?: {
+    delayMs?: number;
+    fetchOptions?: DetailFetchOptions;
+}): Promise<DetailSyncResult>;

package/dist/strava/details.js

@@ -0,0 +1,50 @@
+import { log } from "../lib/logging.js";
+import { getActivityDetail } from "./api.js";
+import { isBudgetExhausted } from "./rate-limit.js";
+import { applyActivityDetail, getDetailCandidateIds, markDetailsSynced } from "./store.js";
+const RESUME_HINT = "run sync again in ~15 min to continue.";
+export async function syncActivityDetails(tokens, opts = {}) {
+    const delayMs = opts.delayMs ?? 100;
+    const ids = getDetailCandidateIds();
+    const total = ids.length;
+    if (total === 0) {
+        log.success("Activity details are up to date");
+        return { fetched: 0, total: 0, stopped: "complete" };
+    }
+    log.start(`Fetching details for ${total} activities...`);
+    let fetched = 0;
+    for (const id of ids) {
+        const result = await getActivityDetail(tokens, id, opts.fetchOptions);
+        if (result.status === "rate-limited") {
+            log.progressEnd();
+            log.warn(`Rate limited — ${fetched} of ${total} details fetched, ${RESUME_HINT}`);
+            return { fetched, total, stopped: "rate-limited" };
+        }
+        if (result.status === "ok") {
+            applyActivityDetail(result.activity);
+            fetched++;
+            if (fetched % 25 === 0) {
+                log.progress(`   Fetched ${fetched}/${total} details...`);
+            }
+            if (result.rateLimit && isBudgetExhausted(result.rateLimit)) {
+                log.progressEnd();
+                log.warn(`Detail budget reached — ${fetched} of ${total} fetched, ${RESUME_HINT}`);
+                return { fetched, total, stopped: "budget" };
+            }
+        }
+        else if (result.status === "not-found") {
+            // Deleted on Strava since the summary sync; mark so it isn't retried forever.
+            markDetailsSynced(id);
+            fetched++;
+        }
+        else {
+            log.warn(`Failed to fetch details for activity ${id} (HTTP ${result.httpStatus}), will retry next sync`);
+        }
+        if (delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    log.progressEnd();
+    log.success(`Fetched details for ${fetched} of ${total} activities`);
+    return { fetched, total, stopped: "complete" };
+}

package/dist/strava/oauth.d.ts

@@ -0,0 +1,4 @@
+import { type Tokens } from "../lib/config.js";
+export declare function authorize(): Promise<Tokens>;
+export declare function refreshTokens(): Promise<Tokens>;
+export declare function getValidTokens(): Promise<Tokens>;

package/dist/strava/oauth.js

@@ -0,0 +1,113 @@
+import { createServer } from "http";
+import { URL } from "url";
+import open from "open";
+import { loadConfig, loadTokens, saveTokens, tokensExist, tokensExpired, } from "../lib/config.js";
+import { log } from "../lib/logging.js";
+const REDIRECT_PORT = 8765;
+const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/callback`;
+const AUTHORIZE_URL = "https://www.strava.com/oauth/authorize";
+const TOKEN_URL = "https://www.strava.com/oauth/token";
+export async function authorize() {
+    const config = loadConfig();
+    const { client_id, client_secret } = config.strava;
+    const authUrl = new URL(AUTHORIZE_URL);
+    authUrl.searchParams.set("client_id", client_id);
+    authUrl.searchParams.set("response_type", "code");
+    authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+    authUrl.searchParams.set("scope", "activity:read_all");
+    authUrl.searchParams.set("approval_prompt", "auto");
+    log.info("Opening browser for Strava authorization...");
+    const code = await new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost:${REDIRECT_PORT}`);
+            if (url.pathname === "/callback") {
+                const code = url.searchParams.get("code");
+                const error = url.searchParams.get("error");
+                if (error) {
+                    res.writeHead(400, { "Content-Type": "text/html" });
+                    res.end(`<h1>Authorization Failed</h1><p>${error}</p>`);
+                    server.close();
+                    reject(new Error(`Authorization failed: ${error}`));
+                    return;
+                }
+                if (code) {
+                    res.writeHead(200, { "Content-Type": "text/html" });
+                    res.end("<h1>✅ Authorization Successful!</h1><p>You can close this window.</p>");
+                    server.close();
+                    resolve(code);
+                }
+            }
+        });
+        server.listen(REDIRECT_PORT, () => {
+            open(authUrl.toString());
+        });
+        server.on("error", (err) => {
+            reject(new Error(`Failed to start callback server: ${err.message}`));
+        });
+    });
+    log.success("Authorization code received, exchanging for tokens...");
+    const tokenResponse = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            client_id,
+            client_secret,
+            code,
+            grant_type: "authorization_code",
+        }),
+    });
+    if (!tokenResponse.ok) {
+        const error = await tokenResponse.text();
+        throw new Error(`Token exchange failed: ${error}`);
+    }
+    const data = await tokenResponse.json();
+    const tokens = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: data.expires_at,
+        athlete_id: data.athlete.id,
+    };
+    saveTokens(tokens);
+    log.success(`Authenticated as ${data.athlete.firstname} ${data.athlete.lastname}`);
+    return tokens;
+}
+export async function refreshTokens() {
+    const config = loadConfig();
+    const oldTokens = loadTokens();
+    const { client_id, client_secret } = config.strava;
+    log.start("Refreshing access token...");
+    const response = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            client_id,
+            client_secret,
+            refresh_token: oldTokens.refresh_token,
+            grant_type: "refresh_token",
+        }),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Token refresh failed: ${error}`);
+    }
+    const data = await response.json();
+    const tokens = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: data.expires_at,
+        athlete_id: oldTokens.athlete_id,
+    };
+    saveTokens(tokens);
+    log.success("Token refreshed");
+    return tokens;
+}
+export async function getValidTokens() {
+    if (!tokensExist()) {
+        return authorize();
+    }
+    const tokens = loadTokens();
+    if (tokensExpired(tokens)) {
+        return refreshTokens();
+    }
+    return tokens;
+}

package/dist/strava/rate-limit.d.ts

@@ -0,0 +1,9 @@
+export interface ReadRateLimit {
+    shortTermUsage: number;
+    shortTermLimit: number;
+    dailyUsage: number;
+    dailyLimit: number;
+}
+export declare const BUDGET_MARGIN = 5;
+export declare function parseReadRateLimit(headers: Headers): ReadRateLimit | null;
+export declare function isBudgetExhausted(rl: ReadRateLimit, margin?: number): boolean;

package/dist/strava/rate-limit.js

@@ -0,0 +1,16 @@
+export const BUDGET_MARGIN = 5;
+export function parseReadRateLimit(headers) {
+    const limit = headers.get("x-readratelimit-limit");
+    const usage = headers.get("x-readratelimit-usage");
+    if (!limit || !usage)
+        return null;
+    const [shortTermLimit, dailyLimit] = limit.split(",").map(Number);
+    const [shortTermUsage, dailyUsage] = usage.split(",").map(Number);
+    if ([shortTermLimit, dailyLimit, shortTermUsage, dailyUsage].some((n) => !Number.isFinite(n))) {
+        return null;
+    }
+    return { shortTermUsage, shortTermLimit, dailyUsage, dailyLimit };
+}
+export function isBudgetExhausted(rl, margin = BUDGET_MARGIN) {
+    return rl.shortTermUsage >= rl.shortTermLimit - margin || rl.dailyUsage >= rl.dailyLimit - margin;
+}

package/dist/strava/store.d.ts

@@ -0,0 +1,13 @@
+import type { StravaActivity, StravaDetailedActivity } from "./types.js";
+export declare function escapeString(str: string | null | undefined): string;
+export declare function upsertSummaryActivity(activity: StravaActivity): void;
+export declare function insertAthlete(athlete: {
+    id: number;
+    firstname: string;
+    lastname: string;
+    weight?: number;
+    ftp?: number;
+}): void;
+export declare function applyActivityDetail(detail: StravaDetailedActivity): void;
+export declare function markDetailsSynced(id: number): void;
+export declare function getDetailCandidateIds(windowDays?: number): number[];

package/dist/strava/store.js

@@ -0,0 +1,107 @@
+import { execute, queryJson } from "../db/client.js";
+export function escapeString(str) {
+    if (str == null)
+        return "NULL";
+    return `'${str.replace(/'/g, "''")}'`;
+}
+// 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.
+export function upsertSummaryActivity(activity) {
+    const sql = `
+    INSERT INTO activities (
+      id, name, sport_type, start_date, elapsed_time, moving_time,
+      distance, total_elevation_gain, average_speed, max_speed,
+      average_heartrate, max_heartrate, average_watts, max_watts,
+      weighted_average_watts, kilojoules, suffer_score, average_cadence,
+      calories, description, workout_type, gear_id, raw_json, synced_at
+    ) VALUES (
+      ${activity.id},
+      ${escapeString(activity.name)},
+      ${escapeString(activity.sport_type)},
+      ${escapeString(activity.start_date)},
+      ${activity.elapsed_time ?? "NULL"},
+      ${activity.moving_time ?? "NULL"},
+      ${activity.distance ?? "NULL"},
+      ${activity.total_elevation_gain ?? "NULL"},
+      ${activity.average_speed ?? "NULL"},
+      ${activity.max_speed ?? "NULL"},
+      ${activity.average_heartrate ?? "NULL"},
+      ${activity.max_heartrate ?? "NULL"},
+      ${activity.average_watts ?? "NULL"},
+      ${activity.max_watts ?? "NULL"},
+      ${activity.weighted_average_watts ?? "NULL"},
+      ${activity.kilojoules ?? "NULL"},
+      ${activity.suffer_score ?? "NULL"},
+      ${activity.average_cadence ?? "NULL"},
+      ${activity.calories ?? "NULL"},
+      ${escapeString(activity.description)},
+      ${activity.workout_type ?? "NULL"},
+      ${escapeString(activity.gear_id)},
+      ${escapeString(JSON.stringify(activity))},
+      datetime('now')
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      sport_type = excluded.sport_type,
+      start_date = excluded.start_date,
+      elapsed_time = excluded.elapsed_time,
+      moving_time = excluded.moving_time,
+      distance = excluded.distance,
+      total_elevation_gain = excluded.total_elevation_gain,
+      average_speed = excluded.average_speed,
+      max_speed = excluded.max_speed,
+      average_heartrate = excluded.average_heartrate,
+      max_heartrate = excluded.max_heartrate,
+      average_watts = excluded.average_watts,
+      max_watts = excluded.max_watts,
+      weighted_average_watts = excluded.weighted_average_watts,
+      kilojoules = excluded.kilojoules,
+      suffer_score = excluded.suffer_score,
+      average_cadence = excluded.average_cadence,
+      workout_type = excluded.workout_type,
+      gear_id = excluded.gear_id,
+      synced_at = excluded.synced_at;
+  `;
+    execute(sql);
+}
+export function insertAthlete(athlete) {
+    const sql = `
+    INSERT OR REPLACE INTO athlete (id, firstname, lastname, weight, ftp, raw_json, updated_at)
+    VALUES (
+      ${athlete.id},
+      ${escapeString(athlete.firstname)},
+      ${escapeString(athlete.lastname)},
+      ${athlete.weight ?? "NULL"},
+      ${athlete.ftp ?? "NULL"},
+      ${escapeString(JSON.stringify(athlete))},
+      datetime('now')
+    );
+  `;
+    execute(sql);
+}
+export function applyActivityDetail(detail) {
+    execute(`
+    UPDATE activities SET
+      description = ${escapeString(detail.description)},
+      private_note = ${escapeString(detail.private_note)},
+      calories = ${detail.calories ?? "NULL"},
+      raw_json = ${escapeString(JSON.stringify(detail))},
+      details_synced_at = datetime('now')
+    WHERE id = ${detail.id};
+  `);
+}
+export function markDetailsSynced(id) {
+    execute(`UPDATE activities SET details_synced_at = datetime('now') WHERE id = ${id};`);
+}
+// NULL marker = full-history backfill; the window re-fetches recent rows so
+// notes written after the first sync are picked up. Newest first, so the most
+// coaching-relevant rows land before any rate-limit stop.
+export function getDetailCandidateIds(windowDays = 14) {
+    return queryJson(`
+    SELECT id FROM activities
+    WHERE details_synced_at IS NULL
+       OR start_date >= strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '-${windowDays} days')
+    ORDER BY start_date DESC;
+  `).map((row) => row.id);
+}

package/dist/strava/types.d.ts

@@ -0,0 +1,49 @@
+export interface StravaAthlete {
+    id: number;
+    firstname: string;
+    lastname: string;
+    weight?: number;
+    ftp?: number;
+}
+export interface StravaTokenResponse {
+    token_type: string;
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    expires_in: number;
+    athlete: StravaAthlete;
+}
+export interface StravaActivity {
+    id: number;
+    name: string;
+    sport_type: string;
+    start_date: string;
+    elapsed_time: number;
+    moving_time: number;
+    distance: number;
+    total_elevation_gain: number;
+    average_speed: number;
+    max_speed: number;
+    average_heartrate?: number;
+    max_heartrate?: number;
+    average_watts?: number;
+    max_watts?: number;
+    weighted_average_watts?: number;
+    kilojoules?: number;
+    suffer_score?: number;
+    average_cadence?: number;
+    calories?: number;
+    description?: string;
+    workout_type?: number;
+    gear_id?: string;
+}
+export interface StravaDetailedActivity extends StravaActivity {
+    private_note?: string;
+}
+export interface StravaStream {
+    type: string;
+    data: number[];
+    series_type: string;
+    original_size: number;
+    resolution: string;
+}

package/dist/strava/types.js

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

package/dist/viewer/lib/export/erg.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ERG/MRC Export
+ *
+ * Generates ERG/MRC workout files for indoor cycling trainers.
+ * Widely supported by TrainerRoad, Zwift, PerfPRO, Golden Cheetah, and others.
+ *
+ * - ERG format: Uses absolute watts
+ * - MRC format: Uses percentage of FTP (more portable)
+ *
+ * We generate MRC format since it scales to each user's FTP.
+ */
+import type { Workout, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+/**
+ * Check if a sport is supported by ERG/MRC export
+ * Only cycling workouts make sense for trainer files
+ */
+export declare function isErgSupported(sport: Sport): boolean;
+/**
+ * Generate a complete MRC file for a workout
+ */
+export declare function generateMrc(workout: Workout, _settings: Settings): string;
+/**
+ * Generate ERG file (absolute watts) - requires FTP
+ */
+export declare function generateErg(workout: Workout, settings: Settings): string;