@robinthues/rt-claude-coach 0.1.0

package/dist/garmin/steps.js

@@ -0,0 +1,147 @@
+/**
+ * Build Garmin workout steps from a Claude Coach workout.
+ *
+ * Structured workouts map warmup/main/cooldown steps to ExecutableStepDTO and
+ * interval sets to RepeatGroupDTO. Simple workouts synthesize warmup(~10%) /
+ * main(~80%) / cooldown(~10%), matching the old FIT exporter heuristic.
+ */
+import { STEP_TYPES, END_CONDITIONS, TARGET_TYPES, } from "./dto.js";
+import { resolveStepTarget, resolveWorkoutTarget } from "./targets.js";
+function stepTypeFor(type) {
+    switch (type) {
+        case "warmup":
+            return STEP_TYPES.warmup;
+        case "cooldown":
+            return STEP_TYPES.cooldown;
+        case "recovery":
+            return STEP_TYPES.recovery;
+        case "rest":
+            return STEP_TYPES.rest;
+        case "work":
+        case "interval_set":
+        default:
+            return STEP_TYPES.interval;
+    }
+}
+/** Map a DurationTarget to a Garmin end condition + value (seconds or meters). */
+function endConditionFor(duration) {
+    const unit = duration?.unit ?? "minutes";
+    const value = duration?.value ?? 0;
+    switch (unit) {
+        case "seconds":
+            return { endCondition: END_CONDITIONS.time, endConditionValue: value };
+        case "minutes":
+            return { endCondition: END_CONDITIONS.time, endConditionValue: value * 60 };
+        case "hours":
+            return { endCondition: END_CONDITIONS.time, endConditionValue: value * 3600 };
+        case "meters":
+        case "yards":
+            return { endCondition: END_CONDITIONS.distance, endConditionValue: value };
+        case "kilometers":
+            return { endCondition: END_CONDITIONS.distance, endConditionValue: value * 1000 };
+        case "miles":
+            return {
+                endCondition: END_CONDITIONS.distance,
+                endConditionValue: Math.round(value * 1609.344),
+            };
+        default:
+            return { endCondition: END_CONDITIONS.time, endConditionValue: value * 60 };
+    }
+}
+function buildExecutableStep(step, ctx, counter) {
+    const order = counter.next++;
+    const { endCondition, endConditionValue } = endConditionFor(step.duration);
+    const target = resolveStepTarget(step.intensity, ctx.sportZones);
+    const dto = {
+        type: "ExecutableStepDTO",
+        stepId: order,
+        stepOrder: order,
+        stepType: stepTypeFor(step.type),
+        endCondition,
+        endConditionValue,
+        targetType: target.targetType,
+    };
+    if (target.targetValueOne !== undefined)
+        dto.targetValueOne = target.targetValueOne;
+    if (target.targetValueTwo !== undefined)
+        dto.targetValueTwo = target.targetValueTwo;
+    const description = step.notes ?? step.name;
+    if (description)
+        dto.description = description;
+    return dto;
+}
+function buildRepeatGroup(set, ctx, counter) {
+    const order = counter.next++;
+    const children = set.steps.map((child) => buildExecutableStep(child, ctx, counter));
+    return {
+        type: "RepeatGroupDTO",
+        stepId: order,
+        stepOrder: order,
+        stepType: STEP_TYPES.repeat,
+        numberOfIterations: set.repeats,
+        endCondition: END_CONDITIONS.iterations,
+        workoutSteps: children,
+    };
+}
+export function buildStructuredSteps(structure, ctx) {
+    const counter = { next: 1 };
+    const steps = [];
+    for (const step of structure.warmup ?? []) {
+        steps.push(buildExecutableStep(step, ctx, counter));
+    }
+    for (const item of structure.main) {
+        if ("repeats" in item) {
+            steps.push(buildRepeatGroup(item, ctx, counter));
+        }
+        else {
+            steps.push(buildExecutableStep(item, ctx, counter));
+        }
+    }
+    for (const step of structure.cooldown ?? []) {
+        steps.push(buildExecutableStep(step, ctx, counter));
+    }
+    return steps;
+}
+export function buildSimpleSteps(workout, ctx) {
+    const totalMinutes = workout.durationMinutes ?? 60;
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = Math.max(0, totalMinutes - warmupMinutes - cooldownMinutes);
+    // Warmup and cooldown are always open (no.target); the workout-level target
+    // applies only to the main step.
+    const mainTarget = resolveWorkoutTarget(workout, ctx.sportZones);
+    const warmup = {
+        type: "ExecutableStepDTO",
+        stepId: 1,
+        stepOrder: 1,
+        stepType: STEP_TYPES.warmup,
+        endCondition: END_CONDITIONS.time,
+        endConditionValue: warmupMinutes * 60,
+        targetType: TARGET_TYPES.noTarget,
+    };
+    const main = {
+        type: "ExecutableStepDTO",
+        stepId: 2,
+        stepOrder: 2,
+        stepType: STEP_TYPES.interval,
+        endCondition: END_CONDITIONS.time,
+        endConditionValue: mainMinutes * 60,
+        targetType: mainTarget.targetType,
+    };
+    if (mainTarget.targetValueOne !== undefined)
+        main.targetValueOne = mainTarget.targetValueOne;
+    if (mainTarget.targetValueTwo !== undefined)
+        main.targetValueTwo = mainTarget.targetValueTwo;
+    if (workout.description)
+        main.description = workout.description;
+    const cooldown = {
+        type: "ExecutableStepDTO",
+        stepId: 3,
+        stepOrder: 3,
+        stepType: STEP_TYPES.cooldown,
+        endCondition: END_CONDITIONS.time,
+        endConditionValue: cooldownMinutes * 60,
+        targetType: TARGET_TYPES.noTarget,
+    };
+    return [warmup, main, cooldown];
+}

package/dist/garmin/targets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resolve Claude Coach intensity/target data into Garmin workout targets.
+ *
+ * Target rules (HR targets are ALWAYS absolute bpm — never zoneNumber — so the
+ * on-watch effort matches the plan's Friel model regardless of the athlete's
+ * Garmin zone configuration):
+ *  - Named HR zone   -> heart.rate.zone (id 4) with the zone's hrLow/hrHigh bpm.
+ *  - Explicit bpm    -> heart.rate.zone (id 4) with targetValueOne/Two.
+ *  - Pace range      -> pace.zone (id 6) with targetValueOne/Two in m/s.
+ *  - Otherwise       -> no.target (id 1).
+ */
+import type { IntensityTarget, Workout } from "../schema/training-plan.js";
+import type { SportZones, TargetResolution } from "./context.js";
+export declare function resolveStepTarget(intensity: IntensityTarget | undefined, sportZones: SportZones): TargetResolution;
+export declare function resolveWorkoutTarget(workout: Workout, sportZones: SportZones): TargetResolution;

package/dist/garmin/targets.js

@@ -0,0 +1,85 @@
+/**
+ * Resolve Claude Coach intensity/target data into Garmin workout targets.
+ *
+ * Target rules (HR targets are ALWAYS absolute bpm — never zoneNumber — so the
+ * on-watch effort matches the plan's Friel model regardless of the athlete's
+ * Garmin zone configuration):
+ *  - Named HR zone   -> heart.rate.zone (id 4) with the zone's hrLow/hrHigh bpm.
+ *  - Explicit bpm    -> heart.rate.zone (id 4) with targetValueOne/Two.
+ *  - Pace range      -> pace.zone (id 6) with targetValueOne/Two in m/s.
+ *  - Otherwise       -> no.target (id 1).
+ */
+import { TARGET_TYPES } from "./dto.js";
+import { parsePaceToMetersPerSecond } from "./pace.js";
+function noTarget() {
+    return { targetType: TARGET_TYPES.noTarget };
+}
+function hrBpmRange(low, high) {
+    return {
+        targetType: TARGET_TYPES.heartRateZone,
+        targetValueOne: Math.min(low, high),
+        targetValueTwo: Math.max(low, high),
+    };
+}
+/** Build a pace.zone target from one or two pace strings (m/s bounds, slow..fast). */
+function paceRange(low, high) {
+    const speedLow = parsePaceToMetersPerSecond(low);
+    const speedHigh = high ? parsePaceToMetersPerSecond(high) : speedLow;
+    return {
+        targetType: TARGET_TYPES.paceZone,
+        targetValueOne: Math.min(speedLow, speedHigh),
+        targetValueTwo: Math.max(speedLow, speedHigh),
+    };
+}
+/** Look up a pace zone's pace string by its zone id (number or string key). */
+function lookupPaceZone(sportZones, zone) {
+    return sportZones.paceZones?.find((z) => `${z.zone}` === `${zone}`)?.pace;
+}
+/** Resolve a named HR zone (by number) to its absolute bpm boundaries. */
+function hrZoneByNumber(sportZones, zone) {
+    const match = sportZones.hrZones?.find((z) => z.zone === zone);
+    return match ? hrBpmRange(match.hrLow, match.hrHigh) : noTarget();
+}
+/** Resolve a named HR zone (by name, e.g. "Tempo" or "Zone 3") to its bpm boundaries. */
+function hrZoneByName(sportZones, name) {
+    const target = name.trim().toLowerCase();
+    const match = sportZones.hrZones?.find((z) => z.name.toLowerCase() === target || `zone ${z.zone}` === target);
+    return match ? hrBpmRange(match.hrLow, match.hrHigh) : noTarget();
+}
+export function resolveStepTarget(intensity, sportZones) {
+    if (!intensity)
+        return noTarget();
+    switch (intensity.unit) {
+        case "hr_zone": {
+            // Explicit bpm range wins; otherwise resolve the named zone to bpm.
+            if (intensity.valueLow !== undefined && intensity.valueHigh !== undefined) {
+                return hrBpmRange(intensity.valueLow, intensity.valueHigh);
+            }
+            if (intensity.value >= 1 && intensity.value <= 5) {
+                return hrZoneByNumber(sportZones, intensity.value);
+            }
+            return noTarget();
+        }
+        case "pace_zone": {
+            const pace = lookupPaceZone(sportZones, intensity.value);
+            return pace ? paceRange(pace) : noTarget();
+        }
+        default:
+            return noTarget();
+    }
+}
+export function resolveWorkoutTarget(workout, sportZones) {
+    if (workout.targetHR) {
+        return hrBpmRange(workout.targetHR.low, workout.targetHR.high);
+    }
+    if (workout.primaryZone) {
+        const resolved = hrZoneByName(sportZones, workout.primaryZone);
+        if (resolved.targetType.workoutTargetTypeId === TARGET_TYPES.heartRateZone.workoutTargetTypeId) {
+            return resolved;
+        }
+    }
+    if (workout.targetPace) {
+        return paceRange(workout.targetPace.low, workout.targetPace.high);
+    }
+    return noTarget();
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,27 @@
+export interface StravaConfig {
+    client_id: string;
+    client_secret: string;
+}
+export interface Config {
+    strava: StravaConfig;
+    sync_days: number;
+}
+export interface Tokens {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    athlete_id: number;
+}
+export declare function ensureConfigDir(): void;
+export declare function getConfigPath(): string;
+export declare function getTokensPath(): string;
+export declare function getDbPath(): string;
+export declare function configExists(): boolean;
+export declare function tokensExist(): boolean;
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function loadTokens(): Tokens;
+export declare function saveTokens(tokens: Tokens): void;
+export declare function tokensExpired(tokens: Tokens): boolean;
+export declare function promptForConfig(): Promise<Config>;
+export declare function createConfig(client_id: string, client_secret: string, sync_days?: number): Config;

package/dist/lib/config.js

@@ -0,0 +1,86 @@
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import * as readline from "readline";
+const CONFIG_DIR = join(homedir(), ".claude-coach");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const TOKENS_FILE = join(CONFIG_DIR, "tokens.json");
+const DB_FILE = join(CONFIG_DIR, "coach.db");
+export function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+export function getTokensPath() {
+    return TOKENS_FILE;
+}
+export function getDbPath() {
+    return process.env.CLAUDE_COACH_DB ?? DB_FILE;
+}
+export function configExists() {
+    return existsSync(CONFIG_FILE);
+}
+export function tokensExist() {
+    return existsSync(TOKENS_FILE);
+}
+export function loadConfig() {
+    if (!configExists()) {
+        throw new Error(`Config not found at ${CONFIG_FILE}. Run setup first.`);
+    }
+    const data = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function loadTokens() {
+    if (!tokensExist()) {
+        throw new Error(`Tokens not found at ${TOKENS_FILE}. Run auth first.`);
+    }
+    const data = readFileSync(TOKENS_FILE, "utf-8");
+    return JSON.parse(data);
+}
+export function saveTokens(tokens) {
+    ensureConfigDir();
+    writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+}
+export function tokensExpired(tokens) {
+    // Add 60 second buffer
+    return Date.now() / 1000 > tokens.expires_at - 60;
+}
+async function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function promptForConfig() {
+    console.log("\n🚴 Claude Coach Setup\n");
+    console.log("To use this tool, you need a Strava API application.");
+    console.log("Create one at: https://www.strava.com/settings/api");
+    console.log('Set "Authorization Callback Domain" to: localhost\n');
+    const client_id = await prompt("Enter your Strava Client ID: ");
+    const client_secret = await prompt("Enter your Strava Client Secret: ");
+    const sync_days_str = await prompt("Days of history to sync (default 730): ");
+    const sync_days = parseInt(sync_days_str) || 730;
+    return {
+        strava: { client_id, client_secret },
+        sync_days,
+    };
+}
+export function createConfig(client_id, client_secret, sync_days = 730) {
+    return {
+        strava: { client_id, client_secret },
+        sync_days,
+    };
+}

package/dist/lib/logging.d.ts

@@ -0,0 +1,13 @@
+export declare const log: {
+    info: (message: string, ...args: unknown[]) => void;
+    success: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+    box: (message: string) => void;
+    start: (message: string) => void;
+    ready: (message: string) => void;
+    progress: (message: string) => void;
+    progressEnd: () => void;
+};
+export type Logger = typeof log;

package/dist/lib/logging.js

@@ -0,0 +1,28 @@
+import { consola } from "consola";
+// Configure consola with pretty formatting
+const logger = consola.create({
+    level: process.env.LOG_LEVEL === "debug" ? 4 : 3,
+    formatOptions: {
+        date: false,
+        colors: true,
+        compact: false,
+    },
+});
+export const log = {
+    info: (message, ...args) => logger.info(message, ...args),
+    success: (message, ...args) => logger.success(message, ...args),
+    warn: (message, ...args) => logger.warn(message, ...args),
+    error: (message, ...args) => logger.error(message, ...args),
+    debug: (message, ...args) => logger.debug(message, ...args),
+    box: (message) => logger.box(message),
+    start: (message) => logger.start(message),
+    ready: (message) => logger.ready(message),
+    // Progress-style logging (overwrites current line)
+    progress: (message) => {
+        process.stdout.write(`\r${message}`);
+    },
+    // End progress line
+    progressEnd: () => {
+        process.stdout.write("\n");
+    },
+};

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" | "trailrun" | "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;