claude-coach 0.0.1

package/dist/schema/training-plan.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Training Plan JSON Schema
+ *
+ * Designed to be comprehensive enough for export to:
+ * - Zwift (.zwo workouts)
+ * - Garmin Connect (.fit workouts)
+ * - TrainingPeaks
+ * - Other training platforms
+ */
+export type Sport = "swim" | "bike" | "run" | "strength" | "brick" | "race" | "rest";
+export type WorkoutType = "rest" | "recovery" | "endurance" | "tempo" | "threshold" | "intervals" | "vo2max" | "sprint" | "race" | "brick" | "technique" | "openwater" | "hills" | "long";
+export type IntensityUnit = "percent_ftp" | "percent_lthr" | "hr_zone" | "pace_zone" | "rpe" | "css_offset";
+export type DurationUnit = "seconds" | "minutes" | "hours" | "meters" | "kilometers" | "miles" | "yards" | "laps";
+export type StepType = "warmup" | "work" | "recovery" | "rest" | "cooldown" | "interval_set";
+export type SwimDistanceUnit = "meters" | "yards";
+export type LandDistanceUnit = "kilometers" | "miles";
+export type FirstDayOfWeek = "monday" | "sunday";
+export interface UnitPreferences {
+    swim: SwimDistanceUnit;
+    bike: LandDistanceUnit;
+    run: LandDistanceUnit;
+    firstDayOfWeek: FirstDayOfWeek;
+}
+export declare const defaultPreferences: UnitPreferences;
+export interface IntensityTarget {
+    unit: IntensityUnit;
+    value: number;
+    valueLow?: number;
+    valueHigh?: number;
+    description?: string;
+}
+export interface DurationTarget {
+    unit: DurationUnit;
+    value: number;
+}
+export interface WorkoutStep {
+    type: StepType;
+    name?: string;
+    duration: DurationTarget;
+    intensity: IntensityTarget;
+    cadence?: {
+        low: number;
+        high: number;
+    };
+    notes?: string;
+}
+export interface IntervalSet {
+    type: "interval_set";
+    name?: string;
+    repeats: number;
+    steps: WorkoutStep[];
+}
+export interface StructuredWorkout {
+    warmup?: WorkoutStep[];
+    main: (WorkoutStep | IntervalSet)[];
+    cooldown?: WorkoutStep[];
+    totalDuration?: DurationTarget;
+    estimatedTSS?: number;
+    estimatedIF?: number;
+}
+export interface Workout {
+    id: string;
+    sport: Sport;
+    type: WorkoutType;
+    name: string;
+    description: string;
+    durationMinutes?: number;
+    distanceMeters?: number;
+    primaryZone?: string;
+    targetHR?: {
+        low: number;
+        high: number;
+    };
+    targetPower?: {
+        low: number;
+        high: number;
+    };
+    targetPace?: {
+        low: string;
+        high: string;
+    };
+    rpe?: number;
+    structure?: StructuredWorkout;
+    humanReadable?: string;
+    completed: boolean;
+    completedAt?: string;
+    actualDuration?: number;
+    actualDistance?: number;
+    notes?: string;
+}
+export interface TrainingDay {
+    date: string;
+    dayOfWeek: string;
+    workouts: Workout[];
+}
+export interface WeekSummary {
+    totalHours: number;
+    totalTSS?: number;
+    bySport: {
+        [key in Sport]?: {
+            sessions: number;
+            hours: number;
+            km?: number;
+        };
+    };
+}
+export interface TrainingWeek {
+    weekNumber: number;
+    startDate: string;
+    endDate: string;
+    phase: string;
+    focus: string;
+    targetHours: number;
+    days: TrainingDay[];
+    summary: WeekSummary;
+    isRecoveryWeek: boolean;
+}
+export interface HeartRateZones {
+    lthr: number;
+    zones: {
+        zone: number;
+        name: string;
+        percentLow: number;
+        percentHigh: number;
+        hrLow: number;
+        hrHigh: number;
+    }[];
+}
+export interface PowerZones {
+    ftp: number;
+    zones: {
+        zone: number;
+        name: string;
+        percentLow: number;
+        percentHigh: number;
+        wattsLow: number;
+        wattsHigh: number;
+    }[];
+}
+export interface SwimZones {
+    css: string;
+    cssSeconds: number;
+    zones: {
+        zone: number;
+        name: string;
+        paceOffset: number;
+        pace: string;
+    }[];
+}
+export interface PaceZones {
+    thresholdPace: string;
+    thresholdPaceSeconds: number;
+    zones: {
+        zone: string;
+        name: string;
+        pace: string;
+        paceSeconds: number;
+    }[];
+}
+export interface AthleteZones {
+    run?: {
+        hr?: HeartRateZones;
+        pace?: PaceZones;
+    };
+    bike?: {
+        hr?: HeartRateZones;
+        power?: PowerZones;
+    };
+    swim?: SwimZones;
+    maxHR?: number;
+    restingHR?: number;
+    weight?: number;
+}
+export interface AthleteAssessment {
+    foundation: {
+        raceHistory: string[];
+        peakTrainingLoad: number;
+        foundationLevel: "beginner" | "intermediate" | "advanced" | "elite";
+        yearsInSport: number;
+    };
+    currentForm: {
+        weeklyVolume: {
+            total: number;
+            swim?: number;
+            bike?: number;
+            run?: number;
+        };
+        longestSessions: {
+            swim?: number;
+            bike?: number;
+            run?: number;
+        };
+        consistency: number;
+        timeSincePeakFitness?: string;
+        reasonForTimeOff?: string;
+    };
+    strengths: {
+        sport: Sport;
+        evidence: string;
+    }[];
+    limiters: {
+        sport: Sport;
+        evidence: string;
+    }[];
+    constraints: string[];
+}
+export interface TrainingPhase {
+    name: string;
+    startWeek: number;
+    endWeek: number;
+    focus: string;
+    weeklyHoursRange: {
+        low: number;
+        high: number;
+    };
+    keyWorkouts: string[];
+    physiologicalGoals: string[];
+}
+export interface RaceStrategy {
+    event: {
+        name: string;
+        date: string;
+        type: string;
+        distances?: {
+            swim?: number;
+            bike?: number;
+            run?: number;
+        };
+    };
+    pacing: {
+        swim?: {
+            target: string;
+            notes: string;
+        };
+        bike?: {
+            targetPower: string;
+            targetHR: string;
+            notes: string;
+        };
+        run?: {
+            targetPace: string;
+            targetHR: string;
+            notes: string;
+        };
+    };
+    nutrition: {
+        preRace: string;
+        during: {
+            carbsPerHour: number;
+            fluidPerHour: string;
+            products: string[];
+        };
+        notes: string;
+    };
+    taper: {
+        startDate: string;
+        volumeReduction: number;
+        notes: string;
+    };
+    raceDay: {
+        wakeUpTime?: string;
+        preRaceMeal?: string;
+        warmUp?: string;
+        mentalCues?: string[];
+    };
+}
+export interface TrainingPlan {
+    version: "1.0";
+    meta: {
+        id: string;
+        athlete: string;
+        event: string;
+        eventDate: string;
+        planStartDate: string;
+        planEndDate: string;
+        createdAt: string;
+        updatedAt: string;
+        totalWeeks: number;
+        generatedBy: string;
+    };
+    preferences: UnitPreferences;
+    assessment: AthleteAssessment;
+    zones: AthleteZones;
+    phases: TrainingPhase[];
+    weeks: TrainingWeek[];
+    raceStrategy: RaceStrategy;
+}
+export declare const exampleWorkout: Workout;

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,5 @@
+import type { Tokens } from "../lib/config.js";
+import type { StravaActivity, StravaAthlete } 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[]>;

package/dist/strava/api.js

@@ -0,0 +1,63 @@
+import { log } from "../lib/logging.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;
+}

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/types.d.ts

@@ -0,0 +1,46 @@
+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 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;